local addonname, shared = ...
---@cast shared HeimdallShared
---@cast addonname string

---@class GridFrame
---@field name string
---@field columns number
---@field frame Frame
---@field cellWidth number
---@field cellHeight number
---@field allowOverflow boolean
---@field columnHeights table<number, number>
GridFrame = {
    ---@param name string
    ---@param parent Frame
    ---@param columns number
    ---@param cellHeight number
    ---@param size {w: number, h:number}?
    ---@return GridFrame
    new = function(name, parent, columns, cellHeight, size)
        local self = setmetatable({}, {
            __index = GridFrame
        })
        self.frame = CreateFrame("Frame", name, parent)
        size = size or {}
        if size.w then self.frame:SetWidth(size.w) end
        if size.h then self.frame:SetHeight(size.h) end
        self.allowOverflow = false
        self.frame:SetPoint("CENTER", parent, "CENTER")
        self.frame:SetBackdrop({
            bgFile = "Interface/Tooltips/UI-Tooltip-Background",
            tileSize = 64,
            tile = true
        })
        self.frame:SetBackdropColor(0, 0, 0, 0.8)
        self.frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)

        self.columns = columns
        self.cellWidth = self.frame:GetWidth() / columns
        self.cellHeight = cellHeight
        self.columnHeights = {}
        for i = 1, columns do
            self.columnHeights[i] = 0
        end
        return self
    end,
    ---@param self GridFrame
    ---@param frame Frame
    ---@param rowspan number
    ---@param colspan number
    Add = function(self, frame, rowspan, colspan)
        colspan = math.min(colspan, self.columns)

        local bestColumn = nil
        local bestRow = math.huge

        for startColumn = 1, self.columns - colspan + 1 do
            local currentMaxY = 0
            for c = startColumn, startColumn + colspan - 1 do
                currentMaxY = math.max(currentMaxY, self.columnHeights[c])
            end
            if currentMaxY < bestRow then
                bestRow = currentMaxY
                bestColumn = startColumn
            end
        end

        if not self.allowOverflow then
            if bestRow + self.cellHeight * rowspan > self.frame:GetHeight() then
                print("Frame is too tall")
                return
            end
        end

        if bestColumn then
            frame:SetParent(self.frame)
            frame.gridData = {
                row = bestRow,
                column = bestColumn,
                colspan = colspan,
                rowspan = rowspan,
                parent = self
            }
            frame.SetPos = function(self)
                if not self.gridData then return end
                local parent = self.gridData.parent
                local x = (self.gridData.column - 1) * parent.cellWidth
                local y = -(self.gridData.row * parent.cellHeight)
                self:SetPoint("TOPLEFT", parent.frame, "TOPLEFT", x, y)
                self:SetWidth(parent.cellWidth * self.gridData.colspan)
                self:SetHeight(parent.cellHeight * self.gridData.rowspan)
            end
            frame.SetPos(frame)

            for c = bestColumn, bestColumn + colspan - 1 do
                self.columnHeights[c] = self.columnHeights[c] + rowspan
            end
        else
            print("No available space in the grid.")
        end
    end,
    Recalculate = function(self)
        local children = { self.frame:GetChildren() }
        for _, child in pairs(children) do child:SetPos() end
    end,
    SetWidth = function(self, width)
        self.frame:SetWidth(width)
        self.cellWidth = width / self.columns
        self:Recalculate()
    end,
    SetHeight = function(self, height)
        self.frame:SetHeight(height)
        local tallestRow = 0
        for _, height in pairs(self.columnHeights) do
            tallestRow = math.max(tallestRow, height)
        end
        self.cellHeight = height / tallestRow
        self:Recalculate()
    end
}

---@class StaticGridFrame
---@field name string
---@field rows number
---@field columns number
---@field frame Frame
---@field cellWidth number
---@field cellHeight number
---@field occupancy table<number, table<number, boolean>>
StaticGridFrame = {
    ---@param name string
    ---@param parent Frame
    ---@param rows number
    ---@param columns number
    ---@param size {w: number, h:number}?
    ---@return StaticGridFrame
    new = function(name, parent, rows, columns, size)
        local self = setmetatable({}, {
            __index = StaticGridFrame
        })
        size = size or {}
        self.frame = CreateFrame("Frame", name, parent)
        self.frame:SetWidth(columns * 128)
        self.frame:SetHeight(rows * 128)
        self.frame:SetPoint("CENTER", UIParent, "CENTER")
        self.frame:SetBackdrop({
            bgFile = "Interface/Tooltips/UI-Tooltip-Background",
            tileSize = 64,
            tile = true
        })
        self.frame:SetBackdropColor(0, 0, 0, 0.8)
        self.frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
        if size.w then self.frame:SetWidth(size.w) end
        if size.h then self.frame:SetHeight(size.h) end

        self.rows = rows
        self.columns = columns
        self.cellWidth = self.frame:GetWidth() / columns
        self.cellHeight = self.frame:GetHeight() / rows
        self.occupancy = {}
        for row = 1, rows do
            self.occupancy[row] = {}
            for column = 1, columns do
                self.occupancy[row][column] = false
            end
        end
        return self
    end,
    ---@param self StaticGridFrame
    ---@param frame Frame
    ---@param rowspan number
    ---@param colspan number
    Add = function(self, frame, rowspan, colspan)
        for row = 1, self.rows do
            for col = 1, self.columns do
                if not self.occupancy[row][col] then
                    local canPlace = true
                    for r = row, row + rowspan - 1 do
                        for c = col, col + colspan - 1 do
                            if not self.occupancy[r] or self.occupancy[r][c] then
                                canPlace = false
                                break
                            end
                            if not canPlace then break end
                        end
                    end
                    if canPlace then
                        local x = (col - 1) * self.cellWidth
                        local y = -(row - 1) * self.cellHeight
                        frame.colspan = colspan
                        frame.rowspan = rowspan
                        frame:SetWidth(self.cellWidth * colspan)
                        frame:SetHeight(self.cellHeight * rowspan)
                        frame:SetPoint("TOPLEFT", self.frame, "TOPLEFT", x, y)
                        frame:SetParent(self.frame)
                        for r = row, row + rowspan - 1 do
                            for c = col, col + colspan - 1 do
                                self.occupancy[r][c] = true
                            end
                        end
                        return
                    end
                end
            end
        end
        print("No available space in the grid.")
    end,
    MakeMovable = function(self)
        self.frame:SetMovable(true)
        self.frame:EnableMouse(true)
        self.frame:RegisterForDrag("LeftButton")
        self.frame:SetScript("OnDragStart", function(self)
            self:StartMoving()
        end)
        self.frame:SetScript("OnDragStop", function(self)
            self:StopMovingOrSizing()
        end)
    end,
    Recalculate = function(self)
        for _, frame in pairs(self.frame:GetChildren()) do
            if frame.colspan then
                frame:SetWidth(self.cellWidth * frame.colspan)
            end
            if frame.rowspan then
                frame:SetHeight(self.cellHeight * frame.rowspan)
            end
        end
    end,
    SetWidth = function(self, width)
        self.frame:SetWidth(width)
        self.cellWidth = self.frame:GetWidth() / self.columns
        self:Recalculate()
    end,
    SetHeight = function(self, height)
        self.frame:SetHeight(height)
        print("Setting height", height)
        self.cellHeight = self.frame:GetHeight() / self.rows
        print("Cell height", self.cellHeight)
        self:Recalculate()
    end

}

local configFrame = StaticGridFrame.new("HeimdallConfig",
    UIParent,
    40, 12,
    { w = 1024 + 512, h = 1024 })
configFrame:MakeMovable()
--configFrame.frame:SetScript("OnKeyUp", function(self, key)
--    if key == "ESCAPE" then
--        self:Hide()
--    end
--end)

local colors      = {
    { 1, 0, 0, 1 },
    { 0, 1, 0, 1 },
    { 0, 0, 1, 1 },
    { 1, 1, 0, 1 },
    { 1, 0, 1, 1 },
    { 0, 1, 1, 1 },
    { 1, 1, 1, 1 },
}
HeimdallTestFrame = GridFrame.new("HeimdallPartyFrame", UIParent, 12, 20, { w = 1024, h = 1024 })
for i = 1, 10 do
    local frame = CreateFrame("Frame", "HeimdallPartyFrame" .. i, UIParent)
    frame:SetBackdrop({
        bgFile = "Interface/Tooltips/UI-Tooltip-Background",
        tileSize = 64,
        tile = true
    })
    frame:SetBackdropColor(unpack(colors[i % #colors + 1]))
    frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
    HeimdallTestFrame:Add(frame, 4, 2)
end
HeimdallTestFrame:SetHeight(128)
HeimdallTestFrame:SetWidth(512)
---@diagnostic disable-next-line: missing-fields
shared.Config = {}
function shared.Config.Init()
    local buttonColors = {
        enabled = { 1, 0, 0, 1 },
        disabled = { 0, 1, 0, 1 }
    }
    ---@param name string
    ---@param parent Frame
    ---@param onClick fun(): boolean
    local function BasicButton(name, parent, text, onClick)
        local button = CreateFrame("Frame", name, parent)
        button:SetScript("OnMouseDown", function()
            local res = onClick()
            local color = res and buttonColors.enabled or buttonColors.disabled
            button:SetBackdropColor(unpack(color))
        end)
        local color = Heimdall_Data.config.spotter.enabled and buttonColors.enabled or buttonColors.disabled
        button:SetBackdrop({
            bgFile = "Interface/Tooltips/UI-Tooltip-Background",
            edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
            tile = true,
            tileSize = 2,
            edgeSize = 12,
            insets = {
                left = 2,
                right = 2,
                top = 2,
                bottom = 2
            }
        })
        button:SetBackdropColor(unpack(color))
        --spotterEnableButton:SetChecked(Heimdall_Data.config.spotter.enabled)
        local spotterEnableButtonLabel = button:CreateFontString(nil, "OVERLAY", "GameFontNormal")
        spotterEnableButtonLabel:SetText(text)
        spotterEnableButtonLabel:SetAllPoints(button)
        return button
    end
    ---@param name string
    ---@param parent Frame
    ---@param text string
    ---@param onDone fun(text: string)
    local function CreateBasicSmallEditBox(name, parent, text, onDone)
        local container = GridFrame.new(name, parent, 1, 1)
        local editBox = CreateFrame("EditBox", name .. "EditBox", container.frame)
        local editBoxtext = editBox:CreateFontString(nil, "OVERLAY", "GameFontNormal")
        editBoxtext:SetText(text)
        editBoxtext:SetPoint("TOPLEFT", container.frame, "TOPLEFT", 0, 0)

        editBox:SetPoint("TOPLEFT", container.frame, "TOPLEFT", 0, -8)
        editBox:SetAutoFocus(false)
        editBox:SetFontObject("GameFontNormal")
        editBox:SetText(Heimdall_Data.config.spotter.throttleTime)
        editBox:SetBackdrop({
            bgFile = "Interface/Tooltips/UI-Tooltip-Background",
            edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
            tile = true,
            tileSize = 2,
            edgeSize = 2,
            insets = {
                left = 2,
                right = 2,
                top = 2,
                bottom = 2
            }
        })
        editBox:SetBackdropColor(0.8, 0.8, 0.8, 1)
        editBox:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
        editBox:SetScript("OnEnterPressed", function()
            onDone(editBox:GetText())
        end)
        editBox:SetScript("OnEscapePressed", function()
            editBox:ClearFocus()
        end)
        editBox:SetScript("OnEditFocusLost", function()
            onDone(editBox:GetText())
        end)
        return container
    end

    --
    local title = configFrame.frame:CreateFontString(nil, "ARTWORK", "GameFontNormal")
    title:SetText("Heimdall Config")
    configFrame:Add(title, 1, 12)

    local spotterConfigFrame = GridFrame.new("HeimdallSpotterConfig",
        configFrame.frame, 12, 20)
    configFrame:Add(spotterConfigFrame.frame, 6, 3)
    local spotterTitle = spotterConfigFrame.frame:CreateFontString(nil, "ARTWORK", "GameFontNormal")
    spotterTitle:SetText("Spotter")
    spotterConfigFrame:Add(spotterTitle, 1, 12)

    local spotterEnableButton = BasicButton("HeimdallSpotterConfigEnableButton",
        spotterConfigFrame.frame, "Enable Spotter", function()
            Heimdall_Data.config.spotter.enabled = not Heimdall_Data.config.spotter.enabled
            return Heimdall_Data.config.spotter.enabled
        end)
    spotterConfigFrame:Add(spotterEnableButton, 1, 3)

    configFrame.frame:Hide()
    --    local testEditBox = CreateBasicSmallEditBox("HeimdallSpotterConfigTestEditBox",
    --       UIParent, "Test", function(text)
    --            print(text)
    --        end)
    --    testEditBox:SetHeight(200)
    --    spotterConfigFrame:Add(testEditBox.frame, 2, 6)

    --local spotterEveryoneButton = BasicButton("HeimdallSpotterEveryone", spotterConfigFrame, "Everyone", function(state)
    --    Heimdall_Data.config.spotter.everyone = state
    --end)
    --spotterEveryoneButton:PutRight(spotterEnableButton)
    --spotterEveryoneButton:SetChecked(Heimdall_Data.config.spotter.everyone)

    --local spotterHostileButton = BasicButton("HeimdallSpotterHostile", spotterConfigFrame, "Hostile", function(state)
    --    Heimdall_Data.config.spotter.hostile = state
    --end)
    --spotterHostileButton:PutBelow(spotterEnableButton)
    --spotterHostileButton:SetChecked(Heimdall_Data.config.spotter.hostile)

    --local spotterAllianceButton = BasicButton("HeimdallSpotterAlliance", spotterConfigFrame, "Alliance", function(state)
    --    Heimdall_Data.config.spotter.alliance = state
    --end)
    --spotterAllianceButton:PutRight(spotterHostileButton)
    --spotterAllianceButton:SetChecked(Heimdall_Data.config.spotter.alliance)

    --local spotterStinkyButton = BasicButton("HeimdallSpotterStinky", spotterConfigFrame, "Stinky", function(state)
    --    Heimdall_Data.config.spotter.stinky = state
    --end)
    --spotterStinkyButton:PutBelow(spotterHostileButton)
    --spotterStinkyButton:SetChecked(Heimdall_Data.config.spotter.stinky)

    --local spotterThrottleBox = CreateBasicSmallEditBox("HeimdallSpotterThrottle", spotterConfigFrame, "Throttle Time",
    --    function(text)
    --        Heimdall_Data.config.spotter.throttleTime = tonumber(text)
    --    end)
    --spotterThrottleBox:PutRight(spotterStinkyButton)

    --	---@type table
    --	local spotterEnableButton = CreateFrame("Button", "HeimdallSpotterEnable", configFrame, "UIPanelButtonTemplate")
    --	spotterEnableButton:SetText("Enable Spotter")
    --	spotterEnableButton:SetSize(100, 30)
    --	spotterEnableButton:SetPoint("TOPLEFT", configFrame, "TOPLEFT", 10, -40)
    --	spotterEnableButton:SetScript("OnClick", function()
    --		print("Button was clicked!")
    --	end)
    --
    --	-- Create a text element
    --	local text = configFrame:CreateFontString(nil, "ARTWORK", "GameFontHighlight")
    --	text:SetText("This is some text in the frame.")
    --	text:SetPoint("TOPLEFT", configFrame, "TOPLEFT", 10, -80)
    --
    --	-- Create a small edit box
    --	local smallEditBox = CreateFrame("EditBox", nil, configFrame)
    --	smallEditBox:SetSize(200, 20)
    --	smallEditBox:SetPoint("TOPLEFT", configFrame, "TOPLEFT", 10, -110)
    --	smallEditBox:SetAutoFocus(false)
    --	smallEditBox:SetFontObject("GameFontNormal")
    --	smallEditBox:SetScript("OnEnterPressed", function()
    --		print("Entered text: " .. smallEditBox:GetText())
    --	end)
    --
    --	-- Create a large edit box
    --	local largeEditBox = CreateFrame("EditBox", nil, configFrame)
    --	largeEditBox:SetSize(280, 100)
    --	largeEditBox:SetPoint("TOP", configFrame, "TOP", 0, -150)
    --	largeEditBox:SetAutoFocus(false)
    --	largeEditBox:SetFontObject("GameFontNormal")
    --	largeEditBox:SetMultiLine(true)
    --	largeEditBox:EnableMouse(true)
    --	largeEditBox:SetMaxLetters(0)
    --	largeEditBox:SetScript("OnEscapePressed", function()
    --		largeEditBox:ClearFocus()
    --	end)

    --configFrame:Hide()
    print("Heimdall - Config loaded")
end

SlashCmdList["HEIMDALL_CONFIG"] = function()
    configFrame:Show()
end
SLASH_HEIMDALL_CONFIG1 = "/heimdall_config"
SLASH_HEIMDALL_CONFIG2 = "/hc"