local mythosAreaApi             = require("core/MythosAreaApi")

-- common parameters
local buttonParameters          = {}
buttonParameters.function_owner = self
buttonParameters.label          = ""
buttonParameters.tooltip        = "Add / Remove"
buttonParameters.color          = { 0, 0, 0, 0 }
buttonParameters.width          = 325
buttonParameters.height         = 325

local inputParameters           = {}
inputParameters.function_owner  = self
inputParameters.font_size       = 100
inputParameters.width           = 250
inputParameters.height          = inputParameters.font_size + 23
inputParameters.alignment       = 3
inputParameters.validation      = 2
inputParameters.tab             = 2

local latestLoad = "XXX"
local updating = false
local percentage = false
local tokenPrecedence = {}
local TOKEN_NAMES = {
  "Elder Sign",
  "Skull",
  "Cultist",
  "Tablet",
  "Elder Thing",
  "Auto-fail",
  "Bless",
  "Curse",
  "Frost",
  ""
}

-- saving the precedence settings and information on the most recently loaded data
function onSave()
  return JSON.encode({
    tokenPrecedence = tokenPrecedence,
    latestLoad      = latestLoad,
    percentage      = percentage
  })
end

function onLoad(saveState)
  if saveState ~= nil and saveState ~= "" then
    local loadedData = JSON.decode(saveState)
    tokenPrecedence  = loadedData.tokenPrecedence
    latestLoad       = loadedData.latestLoad or "XXX"
    percentage       = loadedData.percentage
  else
    loadDefaultValues()
  end

  createDefaultButtonsAndInputs(true)

  -- reset context menu
  self.addContextMenuItem("Load default values", function()
    loadDefaultValues()
    updateUI()
    layout()
  end)
  self.addContextMenuItem("Toggle Percentages", function() 
    if percentage then
      percentage = false
    else
      percentage = "basic"
    end
    layout()
  end)
  self.addContextMenuItem("Toggle Cumulative", function() 
    if percentage == "basic" or not percentage then
      percentage = "cumulative"
      broadcastToAll("Cumulative percentages are unreliable when using tokens that draw other tokens (bless or curse for example)", Color.Yellow)
    else
      percentage = "basic"
    end 
    layout()
  end)
  layout()
  -- grab token metadata from mythos area
  Wait.time(function() onTokenDataChanged(mythosAreaApi.returnTokenData()) end, 0.5)
end

-- delete temporary tokens when destroyed
function onDestroy() deleteCopiedTokens() end

-- layout tokens when dropped (after 2 seconds)
function onDrop() Wait.time(layout, 2) end

-- delete temporary tokens when picked up
function onPickUp() deleteCopiedTokens() end

-- helper functions to carry index
function attachIndex(click_function, index)
  local fn_name = click_function .. index
  _G[fn_name] = function(_, _, isRightClick)
    _G[click_function](isRightClick, index)
  end
  return fn_name
end

function attachIndex2(input_function, index)
  local fn_name = input_function .. index
  _G[fn_name] = function(_, _, input, selected)
    _G[input_function](input, selected, index)
  end
  return fn_name
end

-- click_function for buttons on chaos tokens
function tokenClick(isRightClick, index)
  local change = tonumber(isRightClick and "-1" or "1")
  tokenPrecedence[TOKEN_NAMES[index]][1] = tokenPrecedence[TOKEN_NAMES[index]][1] + change
  self.editInput({ index = index - 1, value = tokenPrecedence[TOKEN_NAMES[index]][1] })
  layout()
end

-- input_function for input_boxes
function tokenInput(input, selected, index)
  if selected == false then
    local num = tonumber(input)
    if num ~= nil then
      tokenPrecedence[TOKEN_NAMES[index]][1] = num
    end
    layout()
  end
end

-- loads the default precedence table
function loadDefaultValues()
  -- token modifiers for sorting (and order for same modifier)
  -- order starts at 2 because there is a "+1" token
  tokenPrecedence = {
    ["Elder Sign"]  = { 100, 2 },
    ["Skull"]       = { -1, 3 },
    ["Cultist"]     = { -2, 4 },
    ["Tablet"]      = { -3, 5 },
    ["Elder Thing"] = { -4, 6 },
    ["Auto-fail"]   = { -100, 7 },
    ["Bless"]       = { 101, 8 },
    ["Curse"]       = { -101, 9 },
    ["Frost"]       = { -99, 10 },
    [""]            = { 0, 11 }
  }
end

-- creates all starting buttons and inputs
function createDefaultButtonsAndInputs(loadInputs)
  loadInputs = loadInputs or false

  buttonParameters.function_owner = self
  buttonParameters.label          = ""
  buttonParameters.tooltip        = "Increase / Decrease"
  buttonParameters.color          = { 0, 0, 0, 0 }
  buttonParameters.width          = 325
  buttonParameters.height         = 325
  -- create UI
  local offset = 0.725
  local pos = { x = { -1.067, 0.377 }, z = -2.175 }

  -- button and inputs index 0-9
  for i = 1, 10 do
    if i < 6 then
      buttonParameters.position = { pos.x[1], 0, pos.z + i * offset }
      if loadInputs then
        inputParameters.position  = { pos.x[1] + offset, 0.1, pos.z + i * offset }
      end  
    else
      buttonParameters.position = { pos.x[2], 0, pos.z + (i - 5) * offset }
      if loadInputs then
        inputParameters.position  = { pos.x[2] + offset, 0.1, pos.z + (i - 5) * offset }
      end     
    end

    buttonParameters.click_function = attachIndex("tokenClick", i)
    self.createButton(buttonParameters)

    if loadInputs then
      inputParameters.input_function  = attachIndex2("tokenInput", i)
      inputParameters.value           = tokenPrecedence[TOKEN_NAMES[i]][1]
      self.createInput(inputParameters)
    end
    
  end

  -- index 10: "Update / Hide" button
  buttonParameters.label          = "Update / Hide"
  buttonParameters.click_function = "layout"
  buttonParameters.tooltip        = "Left-Click: Update!\nRight-Click: Hide Tokens!"
  buttonParameters.position       = { 0.725, 0.1, 2.025 }
  buttonParameters.color          = { 1, 1, 1 }
  buttonParameters.width          = 675
  buttonParameters.height         = 175
  self.createButton(buttonParameters)
end

-- update input fields
function updateUI()
  for i = 1, 10 do
    self.editInput({ index = i - 1, value = tokenPrecedence[TOKEN_NAMES[i]][1] })
  end
end

-- order function for data sorting
function token_value_comparator(left, right)
  if left.value > right.value then
    return true
  elseif right.value > left.value then
    return false
  elseif left.order < right.order then
    return true
  elseif right.order < left.order then
    return false
  else
    return left.token.getGUID() > right.token.getGUID()
  end
end

-- checks scripting zone for chaos bag
function findChaosBag()
  for _, item in ipairs(getObjectFromGUID("83ef06").getObjects()) do
    if item.getDescription() == "Chaos Bag" then
      return item
    end
  end
end

-- deletes previously placed tokens AND percentage buttons
function deleteCopiedTokens()
  self.clearButtons()
  createDefaultButtonsAndInputs()
  for _, token in ipairs(getObjectsWithTag("tempToken")) do token.destruct() end
end

-- creates percentage representation buttons
function createPercentageButton(token_count, value_count, data, token_name, cumulative_percentage)
  local offset = -2.675
  local label_string = string.format("%s", string.format("%05.2f", math.floor((token_count / #data) * 10000) / 100) .. "%")
  local buttonScale = {2, 2, 2}
  local textColor = {1, 1, 1}
  if percentage == "cumulative" then
    
    buttonScale = {1.5, 1.5, 1.5}
    offset = -2.85
  end
  if cumulative_percentage then
    offset = -2.45
    textColor = {1, 1, 1}
    label_string = string.format("%s", string.format("%05.2f", cumulative_percentage) .. "%")
    if cumulative_percentage == 100 then
      label_string = string.format("%s", string.format("%05.1f", cumulative_percentage) .. "%")
    end
  else
    if token_name == "Elder Sign" then
      textColor = {0.35, 0.71, 0.85}
    elseif token_name == "Auto-fail" then
      textColor = {0.86, 0.1, 0.1}
    elseif token_name then
      textColor = {0.68, 0.53, 0.86}
    else
      textColor = {0.85, 0.67, 0.33}
    end
  end

  self.createButton({
    label = label_string,
    click_function = "print",
    width = 0,
    height = 0,
    scale = buttonScale,
    font_color = textColor,
    position = (Vector(2.2, -0.05, offset) + Vector(0.1, 0, 0.875 * value_count))
  })
end

-- main function (delete old tokens, clone chaos bag content, sort it and position it)
function layout(_, _, isRightClick)
  if updating then return end
  updating = true
  deleteCopiedTokens()

  -- stop here if right-clicked
  if isRightClick then
    updating = false
    return
  end

  local chaosBag = findChaosBag()
  local data = {}

  -- clone tokens from chaos bag (default position above trash can)
  for i, obj in ipairs(chaosBag.getData().ContainedObjects) do
    obj["Tags"] = { "tempToken" }
    local spawnedObj = spawnObjectData({
      data = obj,
      position = { 0.49, 3, 0 }
    })

    local value = tonumber(obj["Nickname"])
    local precedence = tokenPrecedence[obj["Nickname"]]

    data[i] = {
      token = spawnedObj,
      value = value or precedence[1]
    }

    if precedence ~= nil then
      data[i].order = precedence[2]
    else
      data[i].order = value
    end
  end

  -- sort table by value (symbols last if same value)
  table.sort(data, token_value_comparator)

  -- error handling for removal of token arranger
  if self == nil then
    for _, token in ipairs(getObjectsWithTag("tempToken")) do token.destruct() end
    return
  end

  -- laying out the tokens
  local pos           = self.getPosition() + Vector(3.55, -0.05, -3.95)
  if percentage then
    pos.z = self.getPosition().z - 7
  end
  local location      = { x = pos.x, y = pos.y, z = pos.z }
  local current_value = data[1].value
  local token_count = 0
	local value_count = 1
	local cumulative_percentage = 0
  local current_token = false

  for _, item in ipairs(data) do
    if item.value ~= current_value then
      if percentage then
				cumulative_percentage = cumulative_percentage + math.floor((token_count / #data) * 10000) / 100
				createPercentageButton(token_count, value_count, data, current_token)
        if percentage == "cumulative" then
          createPercentageButton(token_count, value_count, data, current_token, cumulative_percentage)
        end       
			end
      location.x = location.x - 1.75
      location.z = pos.z
      current_value = item.value
      value_count = value_count + 1
			token_count = 0
      current_token = false
    end
    if string.match(item.token.getName(), "%a") ~= nil then
      current_token = item.token.getName()
    end
    item.token.setPosition(location)
    item.token.setRotation(self.getRotation())
    location.z = location.z - 1.75
    token_count = token_count + 1
  end
  if percentage then
    cumulative_percentage = cumulative_percentage + math.floor((token_count / #data) * 10000) / 100
		createPercentageButton(token_count, value_count, data, current_token)
    if percentage == "cumulative" then
      createPercentageButton(token_count, value_count, data, current_token, cumulative_percentage)
    end
    
	end
  Wait.time(function() updating = false end, 0.1)
end

-- called from outside to set default values for tokens
function onTokenDataChanged(parameters)
  local tokenData = parameters.tokenData or {}
  local currentScenario = parameters.currentScenario or ""
  local useFrontData = parameters.useFrontData or true

  -- only update if this data is new
  local info = currentScenario .. tostring(useFrontData)
  if latestLoad == info then return end
  latestLoad = info

  -- update token precedence
  for key, table in pairs(tokenData) do
    local modifier = table.modifier
    if modifier == -999 then modifier = 0 end
    tokenPrecedence[key][1] = modifier
  end

  updateUI()
  layout()
end