local Chest = require("storage.chest")
local ItemGroup = require("storage.itemgroup")
local Storage = require("storage")
local Text = require("gfx.text")
local List = require("gfx.list")
local Event = require("gfx.event")
local Padding = require("gfx.padding")


local CACHE_FILE = "/.storage.cache"
LOCK_FILE = "/.storage.lock"

local function lock()
  if fs.exists(LOCK_FILE) then
    return false
  end

  -- Create lock file
  return fs.open(LOCK_FILE, "w+").close()
end

local function unlock()
  if not fs.exists(LOCK_FILE) then
    return false
  end

  -- Delete lock file
  local result, reason = pcall(fs.delete, LOCK_FILE)
  if not result then
    print("ERROR: Lock file could not be deleted: " .. reason)
  end

  return result
end

local function isLocked()
  return fs.exists(LOCK_FILE)
end

local function saveState(fname, ctrl)
  local ser = ctrl:toSerializable()
  local file = fs.open(fname, "w+")
  file.write(textutils.serialize(ser))
  file.close()
end

local function loadState(fname, node)
  if not isLocked() then
    print("Not locked! Loading cache...")
    local file = fs.open(fname, "r")
    if file ~= nil then
        local ser = textutils.unserialize(file.readAll())
        file.close()
        return Storage:fromSerializable(ser)
    end
  end

  print("Controller must scan chests...")
  local nodeName = peripheral.getName(node)
  local storageChests = {peripheral.find("inventory")}
  for i,v in ipairs(storageChests) do
    if peripheral.getName(v) == nodeName then
      table.remove(storageChests, i)
      break
    end
  end
  local controller = Storage:fromPeripherals(Storage.assumeHomogeneous(storageChests))
  saveState(fname, controller)
  unlock()
  return controller
end

local function itemList(groups, wBudget, hBudget, savedState, onClick, setPage, runImport)
  local state = savedState or {}
  state.tab = state.tab or 1

  local pages = math.ceil(#groups / (hBudget - 1))

  -- Tab controls
  local btnPrev = Text:new{
    text = " < ",
    bgColor = state.tab == 1 and colors.black or colors.gray,
    fgColor = state.tab == 1 and colors.red or colors.white,
    onClick = function(e, x, y, s)
      if state.tab > 1 then
        state.tab = state.tab - 1
        setPage(nil)
      end
      return true
    end
  }

  local btnImport = Text:new{
    text = "IMPORT",
    bgColor = colors.gray,
    fgColor = colors.white,
    onClick = function(e, x, y, s)
      runImport()
      return true
    end
  }

  local btnNext = Text:new{
    text = " > ",
    bgColor = state.tab == pages and colors.black or colors.gray,
    fgColor = state.tab == pages and colors.red or colors.white,
    onClick = function(e, x, y, s)
      if state.tab < pages then
        state.tab = state.tab + 1
        setPage(nil)
      end
      return true
    end
  }

  local padImport = Padding:new{
    left = math.floor((wBudget - btnPrev:getWidth() - btnNext:getWidth() - btnImport:getWidth())/2),
    element = btnImport
  }

  local padNext = Padding:new{
    left = wBudget - btnPrev:getWidth() - padImport:getWidth() - btnNext:getWidth(),
    element = btnNext
  }

  local tabLine = List:new{
    children = {
      btnPrev,
      padImport,
      padNext
    },
    vertical = false
  }

  local bgColors = {
    colors.gray,
    colors.black
  }
  local entryBudget = hBudget - tabLine:getHeight()
  local entryStart = 1 + (state.tab - 1) * (entryBudget)
  local entryEnd = math.min(state.tab * entryBudget, #groups)
  local entries = {}

  for i=entryStart,entryEnd do
    local group = groups[i]
    local text = group:getSimpleName()
    local count = tostring(group:getItemCount())

    -- Fit text inside of width budget
    local countLen = #count
    if countLen + 2 > wBudget then
      error("Width budget is too small")
    end

    local textBudget = wBudget - 2 - countLen
    if #text > textBudget then
      -- Truncate to available budget
      text = text:sub(1,textBudget)
    end

    local textLabel = Text:new{ text = text, bgColor = bgColors[i % 2] }
    local countLabel = Text:new{ text = count, bgColor = bgColors[i % 2] }
    local paddedText = Padding:new{
      left = 0,
      right = wBudget - #count - #text,
      top = 0,
      bottom = 0,
      bgColor = bgColors[i % 2],
      element = textLabel
    }

    local list = List:new{
      children = {
        paddedText,
        countLabel
      },
      vertical = false,
      onClick = onClick and function(element, x, y, source)
        return onClick(element, x, y, source, group)
      end or nil
    }
    table.insert(entries, list)
  end

  local tabLinePad = Padding:new{
    top = hBudget - (entryEnd - entryStart) - 1 - tabLine:getHeight(),
    element = tabLine
  }

  table.insert(entries, tabLinePad)

  return List:new{
    children = entries,
    vertical = true
  }, state
end

local function updatePageRender(state, pages)
  if state.nextPage ~= nil then
    state.changingPage = state.nextPage ~= state.currentPage
    state.currentPage = state.nextPage
    state.nextPage = nil

    state.monitor.clear()
    state._pageRender = pages[state.currentPage](state)
    os.queueEvent("dummy_event")
  else
    state.changingPage = false
  end
end

local function renderDefault(state, rootElement)
  return function()
    local event = {os.pullEvent()}
    local handled = rootElement:handleEvent(event)
    if not handled and event[1] == "monitor_resize" then
      local width, height = state.monitor.getSize()
      if state.width ~= width or state.height ~= height then
        state.width = width
        state.height = height
  
        -- Trigger re-render
        rootElement:setDirty(true)
      end
    end
  
    if not handled and not Event.isClickEvent(event) then
      os.queueEvent(table.unpack(event))
    end
  
    rootElement:draw()
  end
end

local function NOOP() end

local PAGES = {
  MAIN = function(state)
    local pageState = state:currentPageState({})

    if pageState.stacks == nil then
      pageState.stacks = ItemGroup.collectStacks(state.controller:find(function(stack)
        return not stack:isEmpty()
      end))
  
      table.sort(pageState.stacks, function(a, b) return a:getItemCount() > b:getItemCount() end)
    end

    local listResult, listState = itemList(
      pageState.stacks,
      state.width,
      state.height,
      pageState.listState,
      function(element, x, y, source, group)
        state:setPage("GROUP_DETAIL", group)
        return true
      end,
      function(page)
        if page == nil then
          state:reloadPage()
        else
          state:setPage(page)
        end
      end,
      function()
        print("Importing...")
        state.node:rescan()
        -- Safely handle transfers, priming computer for a full reset/rescan in case server stops mid-transaction
        state:itemTransaction(function()
          for _,nodeStack in ipairs(state.node:find(function(s) return not s:isEmpty() end)) do
            if not state.controller:insertStack(nodeStack) then
              print("Couldn't find a free slot for: "..nodeStack:getSimpleName())
            end
          end
        end)
        -- Force reload stacks
        state:currentPageState({}).stacks = nil
        state:reloadPage()
      end
    )
    pageState.listState = listState
    listResult:setParent(state.monitor)

    return renderDefault(state, listResult)
  end,

  GROUP_DETAIL = function(state, newPage)
    local group = state:getExtra()
    if group == nil then
      state:setPage("MAIN")
      return NOOP
    end
    local hello = Text:new{
      text = "Detail: "..group:getSimpleName(),
      parent = state.monitor,
      onClick = function(e, x, y, s)
        state:setPage("MAIN")
      end
    }

    return renderDefault(state, hello)
  end,

  REQUEST = function(state, newPage)

  end
}


local accessNode = Chest:fromPeripheral("minecraft:trapped_chest", true)
---@diagnostic disable-next-line: need-check-nil
local controller = loadState(CACHE_FILE, accessNode:getInventory())
local monitor = peripheral.find("monitor")
local width, height = monitor.getSize()

local CONTROLLER_STATE = {
  controller = controller,
  node = accessNode,
  width = width,
  height = height,
  monitor = monitor,
  nextPage = "MAIN",
  exit = false,
  pageState = {}
}

function CONTROLLER_STATE:itemTransaction(transact)
  lock()
  transact()
  saveState(CACHE_FILE, self.controller)
  unlock()
end

function CONTROLLER_STATE:currentPageState(default)
  self.pageState[self.currentPage] = self.pageState[self.currentPage] or default
  return self.pageState[self.currentPage]
end

function CONTROLLER_STATE:setPage(page, extra)
  self.nextPage = page
  self.extra = extra
end

function CONTROLLER_STATE:getExtra()
  return self.extra
end

function CONTROLLER_STATE:reloadPage()
  self.nextPage = self.currentPage
end

while not CONTROLLER_STATE.exit do
  updatePageRender(CONTROLLER_STATE, PAGES)
  CONTROLLER_STATE._pageRender()
end