local ADDON_LOADED, shared = ...

local typeMap = {
	spell = "S",
	item = "I",
	macro = "M",
	companion = "C",
	equipmentset = "E",
	summonmount = "U",
}
local inverseTypeMap = {
	S = "spell",
	I = "item",
	M = "macro",
	C = "companion",
	E = "equipmentset",
	U = "summonmount",
}

local function PickupEquipmentSet(setName)
	local setIndex = 0

	for i = 1, C_EquipmentSet.GetNumEquipmentSets() do
		local sn = C_EquipmentSet.GetEquipmentSetInfo(i)

		if sn == setName then setIndex = i end
	end

	C_EquipmentSet.PickupEquipmentSet(setIndex)
end

local pickupActionButton = {
	item = PickupItem,
	spell = PickupSpell,
	macro = PickupMacro,
	companion = PickupSpell,
	equipmentset = PickupEquipmentSet,
	summonmount = C_MountJournal.Pickup,
}

local function RestoreActionButton(self, index, actionButton)
	if GetActionInfo(index) then
		PickupAction(index)
		ClearCursor()
	end

	if not actionButton then return true, nil end

	local aliases = ActionBarSaverReloaded.spellAliases[actionButton.id] or {}
	table.insert(aliases, actionButton.id)

	for _, id in ipairs(aliases) do
		pickupActionButton[actionButton.type](id)

		if GetCursorInfo() == actionButton.type then
			PlaceAction(index)
			return true, id
		end

		ClearCursor()
	end

	return false
end

local function IsMacro(actionButton) return actionButton and actionButton.type == "macro" end

local function GetMacroDuplicates()
	local t = {}
	local duplicates = {}

	for i = 1, MAX_MACROS do
		local macroName = GetMacroInfo(i)

		if macroName then
			if not t[macroName] then
				t[macroName] = 1
			else
				t[macroName] = t[macroName] + 1
				duplicates[macroName] = t[macroName]
			end
		end
	end

	return duplicates
end

local function AddWarning(warnings, macroName, usages)
	table.insert(
		warnings,
		string.format("Warning: Found %d macros named '%s'. Consider renaming them to avoid issues", usages, macroName)
	)
end

function SaveSet(setName)
	if not setName or setName == "" then
		print("Set name cannot be empty")
		return
	end

	local duplicates = GetMacroDuplicates()
	local set = {}
	local warnings = {}

	for i = 1, MAX_ACTION_BUTTONS do
		local type, id = GetActionInfo(i)

		if type == "macro" then
			-- use macro name as the ID
			id = GetMacroInfo(id)
			if duplicates[id] then AddWarning(warnings, id, duplicates[id]) end
		end

		if type and id then set[i] = type and {
			type = type,
			id = id,
		} end
	end

	ActionBarSaverReloaded.sets[setName] = set
	print(string.format("Saved set '%s'!", setName))
	for _, warning in ipairs(warnings) do
		print(warning)
	end
end

function RestoreSet(setName)
	if not setName or setName == "" then
		print("Set name cannot be empty")
		return
	end

	local set = ActionBarSaverReloaded.sets[setName]

	if not set then
		print(string.format("No set with the name '%s' exists", setName))
		return
	end
	if InCombatLockdown() then
		print("Cannot restore sets while in combat")
		return
	end

	local duplicates = GetMacroDuplicates()
	local messages = {}

	-- Start with an empty cursor
	ClearCursor()

	for i = 1, MAX_ACTION_BUTTONS do
		local actionButton = set[i]

		if IsMacro(actionButton) and duplicates[actionButton.id] then
			AddWarning(messages, actionButton.id, duplicates[actionButton.id])
		end

		local succeeded, restoredID = RestoreActionButton(self, i, actionButton)
		if not succeeded then
			table.insert(
				messages,
				string.format(
					"Error: Unable to restore %s with id [%s] to slot %d",
					actionButton.type,
					actionButton.id or "",
					i
				)
			)
		elseif actionButton and restoredID ~= actionButton.id then
			table.insert(
				messages,
				string.format(
					"Info: Restored spell %d (%s) in place of spell %d",
					restoredID,
					GetSpellInfo(restoredID),
					actionButton.id
				)
			)
		end
	end

	print(string.format("Restored set '%s'", setName))
	for _, warning in ipairs(messages) do
		print(warning)
	end
end

function DeleteSet(setName)
	if not setName or setName == "" then
		print("Set name cannot be empty")
		return
	end

	if not ActionBarSaverReloaded.sets[setName] then
		print(string.format("No set with the name '%s' exists", setName))
		return
	end

	ActionBarSaverReloaded.sets[setName] = nil

	print(string.format("Deleted set '%s'", setName))
end

function ListSets()
	local sets = {}
	for setName, foo in pairs(ActionBarSaverReloaded.sets) do
		sets[#sets + 1] = setName
	end
	table.sort(sets)
	local setsStr = table.concat(sets, ", ")

	print(not (not setsStr or setsStr == "") and setsStr or "No sets found")
end

function AliasSpell(args)
	if not args or args == "" then
		print("Must provide args in the format 'spellID aliasID'")
		return
	end
	local spellID, aliasID = string.match(args, "(%d+)%s+(%d+)")

	spellID = tonumber(spellID)
	aliasID = tonumber(aliasID)

	if not (spellID and aliasID) then
		print(string.format("Could not parse spellID and aliasID from '%s'", args))
		return
	end

	local aliases = ActionBarSaverReloaded.spellAliases[spellID] or {}

	for _, id in ipairs(aliases) do
		if id == aliasID then
			print(string.format("Spell %d is already aliased by %d", spellID, aliasID))
			return
		end
	end

	table.insert(ActionBarSaverReloaded.spellAliases[spellID], aliasID)
	print(string.format("Added %d as an alias for %d", aliasID, spellID))
end

function DeleteSpellAliases(spellID)
	if not spellID or spellID == "" then
		print("Must provide a valid spellID")
		return
	end

	spellID = tonumber(spellID)

	if not ActionBarSaverReloaded.spellAliases[spellID] then
		print(string.format("No aliases to remove for spell with ID %d", spellID))
		return
	end

	ActionBarSaverReloaded.spellAliases[spellID] = nil

	print(string.format("Removed all aliases for spell with ID %d", spellID))
end

function ListAliases()
	local aliases = ActionBarSaverReloaded.spellAliases

	if Dict.isEmpty(aliases) then
		print("No aliases found")
		return
	end

	Dict.iter(
		ActionBarSaverReloaded.spellAliases,
		function(spellID, aliases)
			print(string.format("Spell %d is aliased by: %s", spellID, table.concat(aliases, ", ")))
		end
	)
end

---@param text string
---@param size number
---@param deliminer string
---@return string[]
local function Partition(text, size, deliminer)
	local words = {}
	for word in text:gmatch("[^" .. deliminer .. "]+") do
		words[#words + 1] = word
	end

	local ret = {}
	local currentChunk = ""

	for _, word in ipairs(words) do
		if #currentChunk + #word + 1 <= size then
			currentChunk = currentChunk .. deliminer .. word
		else
			if #currentChunk > 0 then ret[#ret + 1] = currentChunk end
			currentChunk = word
		end
	end

	if #currentChunk > 0 then ret[#ret + 1] = currentChunk end

	return ret
end

local importingSet = nil
local importExportFrame = CreateFrame("Frame", "ABSImportExportFrame", UIParent)
importExportFrame:SetSize(512, 512)
importExportFrame:SetPoint("CENTER")
importExportFrame:SetFrameStrata("HIGH")
importExportFrame:EnableMouse(true)
importExportFrame:SetMovable(true)
importExportFrame:SetResizable(false)
importExportFrame:SetBackdrop({
	bgFile = "Interface/Tooltips/UI-Tooltip-Background",
	edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
	tile = true,
	tileSize = 4,
	edgeSize = 4,
	insets = {
		left = 4,
		right = 4,
		top = 4,
		bottom = 4,
	},
})
importExportFrame:SetBackdropColor(0, 0, 0, 0.8)
importExportFrame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)

importExportFrame:SetMovable(true)
importExportFrame:EnableMouse(true)
importExportFrame:RegisterForDrag("LeftButton")
importExportFrame:SetScript("OnDragStart", function(self) self:StartMoving() end)
importExportFrame:SetScript("OnDragStop", function(self) self:StopMovingOrSizing() end)
importExportFrame:SetScript("OnShow", function(self) self:SetScale(1) end)
importExportFrame:Hide()

local importExportFrameTextBox = CreateFrame("EditBox", "ABSImportExportFrameTextBox", importExportFrame)
importExportFrameTextBox:SetSize(512, 512)
importExportFrameTextBox:SetPoint("TOPLEFT", importExportFrame, "TOPLEFT", 0, 0)
importExportFrameTextBox:SetFont("Fonts\\FRIZQT__.ttf", 12)
importExportFrameTextBox:SetTextColor(1, 1, 1, 1)
importExportFrameTextBox:SetTextInsets(20, 20, 20, 20)
importExportFrameTextBox:SetMultiLine(true)
importExportFrameTextBox:SetAutoFocus(true)
importExportFrameTextBox:SetMaxLetters(1000000)
importExportFrameTextBox:SetScript("OnEscapePressed", function(self)
	importExportFrame:Hide()
	if importingSet then
		local lines = { strsplit("\n", self:GetText()) }
		for _, line in ipairs(lines) do
			line = strtrim(line)
			if line ~= "" then ImportSet(importingSet, line) end
		end
		importingSet = nil
	end
end)

function ExportSet(setName)
	local set = ActionBarSaverReloaded.sets[setName]
	if not set then
		print(string.format("No set with the name '%s' exists", setName))
		return
	end
	local macros = {}
	local stringified = {}
	for slot, action in pairs(set) do
		local typeChar = typeMap[action.type]
		if not typeChar then
			print(string.format("Unknown action type '%s' in set '%s'", action.type, setName))
			return
		end
		stringified[#stringified + 1] =
			string.format("%s\\%s\\%s", tostring(slot), tostring(action.id), tostring(typeChar))
		if typeChar == "M" then
			local _, _, macro = GetMacroInfo(action.id)
			if macro then macros[action.id] = macro end
		end
	end

	local export = {}
	for name, macro in pairs(macros) do
		local content = B64.Encode(macro)
		export[#export + 1] = string.format("Mž%sž%s", name, content)
	end
	export[#export + 1] = table.concat(stringified, "ž")
	local str = table.concat(export, "\n")
	importExportFrame:Show()
	importExportFrameTextBox:SetText(str)
	importExportFrameTextBox:SetFocus()
end

function ParseAction(action)
	if not action or action == "" then return nil end
	action = strtrim(action)
	local slot, id, typeChar = string.match(action, "([^\\]+)\\([^\\]+)\\([^\\]+)")
	if not typeChar then
		print(string.format("Unknown action type '%s' in set '%s'", tostring(typeChar), tostring(setName)))
		return
	end
	local type = inverseTypeMap[typeChar]
	if not type then
		print(string.format("Unknown action type '%s' in set '%s'", tostring(typeChar), tostring(setName)))
		return
	end

	slot = tonumber(slot)

	if not slot then
		print(string.format("Unknown slot '%s' in set '%s'", tostring(slot), tostring(setName)))
		return
	end

	if not id then
		print(string.format("Unknown id '%s' in set '%s'", tostring(id), tostring(setName)))
		return
	end

	return {
		slot = slot,
		id = id,
		type = type,
	}
end

function ImportMacro(importString)
	if not importString or importString == "" then
		print("Must provide a valid macro string")
		return
	end
	importString = strtrim(importString)
	local name, content = string.match(importString, "^Mž([^ž]+)ž([^ž]+)")
	if not name or not content then
		print("Error: Invalid macro part format")
		return
	end
	content = strtrim(content)
	name = strtrim(name)

	local reconstructed = B64.Decode(content)
	local macroIdx = GetMacroIndexByName(name)
	if macroIdx == 0 then
		macroIdx = CreateMacro(name, "Inv_misc_questionmark", "")
		macroIdx = GetMacroIndexByName(name)
	end
	EditMacro(macroIdx, name, nil, reconstructed)
	print(string.format("Imported macro '%s' with index %d and content '%s'", name, macroIdx, reconstructed))
	return
end

function ImportSet(setName, str)
	if not setName or setName == "" then
		print("Must provide a valid set name")
		return
	end

	if string.find(str, "^Mž") then
		ImportMacro(str)
		return
	end
	local set = ActionBarSaverReloaded.sets[setName] or {}
	--    if set then
	--        print(string.format("Set '%s' already exists", setName))
	--        return
	--    end

	str = strtrim(str)
	local data = { strsplit("ž", str) }
	for _, action in ipairs(data) do
		local paction = ParseAction(action)
		if paction then set[paction.slot] = {
			type = paction.type,
			id = paction.id,
		} end
	end

	-- /dump ActionBarSaverReloaded.sets["havoc"]
	-- /dump ActionBarSaverReloaded.sets["havoc2"]
	ActionBarSaverReloaded.sets[setName] = set
	print(string.format("Imported set '%s'", setName))
end

function ImportSetDialogue(setName)
	if not setName or setName == "" then
		print("Must provide a valid set name")
		return
	end
	importingSet = setName
	importExportFrameTextBox:SetText("")
	importExportFrame:Show()
	importExportFrameTextBox:SetFocus()
end

function PrintUsage()
	print("ABS Slash commands")
	print("/abs save <set> - Saves your current action bar setup under the given <set>")
	print("/abs restore <set> - Restores the saved <set>")
	print("/abs delete <set> - Deletes the saved <set>")
	print("/abs list - Lists all saved sets")
	print("/abs alias <spellID> <aliasID> - Adds an alias with <aliasID> to <spellID>")
	print("/abs unalias <spellID> - Removes all aliases associated with <spellID>")
	print("/abs aliases - List all spell aliases")
	print("/abs export <set> - Brings up a dialog to export the given <set>")
	print("/abs import <set> - Brings up a dialog to import the given <set>")
end

SlashCmdList["ABS"] = function(argv)
	local args = { strsplit(" ", argv) }
	local cmd = args[1]

	if cmd == "save" then SaveSet(args[2]) end
	if cmd == "restore" then RestoreSet(args[2]) end
	if cmd == "delete" then DeleteSet(args[2]) end
	if cmd == "list" then ListSets() end
	if cmd == "alias" then AliasSpell(args[2], args[3]) end
	if cmd == "unalias" then DeleteSpellAliases(args[2]) end
	if cmd == "aliases" then ListAliases() end
	if cmd == "export" then ExportSet(args[2]) end
	if cmd == "import" then ImportSetDialogue(args[2]) end

	if cmd == "" or not cmd then PrintUsage() end
end
SLASH_ABS1 = "/abs"