-- Housing Item Tracker - Integrations for Bag Addons
-- Unterstützung für Baganator, Bagnon, AdiBags, etc.

local addonName = "HousingItemTracker"

if not HousingItemTrackerSettings then
    print("HousingItemTrackerSettings not found, creating default settings")
    HousingItemTrackerSettings = {}
end

-- WICHTIG: Verwende die globale Variable direkt, nicht eine lokale Referenz
-- Die lokale Referenz wird beim Laden der Datei erstellt, bevor SavedVariables geladen sind
local function GetSettings()
    return HousingItemTrackerSettings
end

-- Helper function: Check if an itemId is in the database (materials, manualMaterials, or decorItems)
local function IsItemInDatabase(itemId)
    if not HousingItemTrackerDB or not HousingItemTrackerDB.items then return false end
    
    -- Check materials
    if HousingItemTrackerDB.items.materials and HousingItemTrackerDB.items.materials[itemId] == true then
        return true
    end
    
    -- Check manual materials
    if HousingItemTrackerDB.items.manualMaterials and HousingItemTrackerDB.items.manualMaterials[itemId] == true then
        return true
    end
    
    -- Check decor items
    if HousingItemTrackerDB.items.decorItems and HousingItemTrackerDB.items.decorItems[itemId] ~= nil then
        return true
    end
    
    -- Check if used in crafting
    if HousingItemTrackerDB.items.decorItems then
        for decorId, decorInfo in pairs(HousingItemTrackerDB.items.decorItems) do
            if decorInfo.materials then
                for _, material in ipairs(decorInfo.materials) do
                    if material.id == itemId then
                        return true
                    end
                end
            end
        end
    end
    
    return false
end

-- Warte bis HousingItemTracker geladen ist
local function IsHousingItem(itemId)
    if not itemId then return false end
    if not HousingItemTrackerDB or not HousingItemTrackerDB.items then return false end
    
    -- Check the item itself
    if IsItemInDatabase(itemId) then
        return true
    end
    
    -- Check for quality variants (itemId-1, itemId-2)
    -- Items with quality tiers have consecutive IDs (e.g., 222417, 222418, 222419)
    -- If the base item is in DB, the higher quality variants should also be recognized
    for offset = 1, 2 do
        if IsItemInDatabase(itemId - offset) then
            return true
        end
    end
    
    return false
end

-- Prüft ob ein Item ein manuell hinzugefügtes Material ist
local function IsManualMaterial(itemId)
    if not itemId or not HousingItemTrackerDB or not HousingItemTrackerDB.items then return false end
    return HousingItemTrackerDB.items.manualMaterials and HousingItemTrackerDB.items.manualMaterials[itemId] == true
end

-- Gibt die Icon-Farbe basierend auf dem Item-Typ zurück
local function GetHousingIconColor(itemId)
    if not itemId then return 1, 1, 1, 1 end
    
    -- Hole Settings direkt aus der globalen Variable (immer aktuell)
    local Settings = GetSettings()

    return Settings.iconColorR, Settings.iconColorG, Settings.iconColorB, 1

    -- -- Prüfe ob es ein manuell hinzugefügtes Material ist (höchste Priorität)
    -- if IsManualMaterial(itemId) then
    --     -- Blau für manuell hinzugefügte Material-Items
    --     local r, g, b = 0.2, 0.6, 1
    --     -- Wende Farb-Multiplikatoren an
    --     local colorR = Settings.iconColorR or 1.0
    --     local colorG = Settings.iconColorG or 1.0
    --     local colorB = Settings.iconColorB or 1.0
    --     return r * colorR, g * colorG, b * colorB, 1
    -- end
    
    -- -- Prüfe ob es ein Decor-Item ist
    -- local isDecor = HousingItemTrackerDB.items.decorItems and HousingItemTrackerDB.items.decorItems[itemId] ~= nil
    -- if isDecor then
    --     -- Prüfe Collection-Status
    --     local isCollected = false
    --     if C_HouseDecor and C_HouseDecor.IsPlayerDecorCollected then
    --         isCollected = C_HouseDecor.IsPlayerDecorCollected(itemId)
    --     end
        
    --     local r, g, b
    --     if isCollected then
    --         -- Grün für bereits gesammelte Decor-Items
    --         r, g, b = 0.2, 1, 0.2
    --     else
    --         -- Orange für noch nicht gesammelte Decor-Items
    --         r, g, b = 1, 0.4, 0
    --     end
    --     -- Wende Farb-Multiplikatoren an
    --     local colorR = Settings.iconColorR or 1.0
    --     local colorG = Settings.iconColorG or 1.0
    --     local colorB = Settings.iconColorB or 1.0
    --     return r * colorR, g * colorG, b * colorB, 1
    -- else
    --     -- Gold für Material-Items (Standard)
    --     local r, g, b = 1, 0.82, 0
    --     -- Wende Farb-Multiplikatoren an
    --     local colorR = Settings.iconColorR or 1.0
    --     local colorG = Settings.iconColorG or 1.0
    --     local colorB = Settings.iconColorB or 1.0
    --     return r * colorR, g * colorG, b * colorB, 1
    -- end
end

------------------------------------------------------------
-- Baganator Integration
------------------------------------------------------------

-- Cache für Item-IDs pro Button (Button-Referenz als Key)
local baganatorItemIdCache = setmetatable({}, {__mode = "v"})

local function SetupBaganatorIntegration()
    if not Baganator then
        return
    end
    
    
    if not Baganator.API then
        return
    end
    
    if not Baganator.API.RegisterCornerWidget then
        return
    end
    
    -- Registriere Corner Widget (Icon in der Ecke)
    Baganator.API.RegisterCornerWidget(
        "Housing Item Tracker",  -- Name
        "housingitemtracker",    -- ID
        function(Arrow, details)     -- onUpdate Funktion (erhält cornerFrame und details!)
            if not details or not details.itemLink then return false end
            local itemId = tonumber(details.itemLink:match("item:(%d+)"))
            
            if not itemId then
                -- Fallback: Versuche itemID direkt aus details
                itemId = details.itemID
            end
            
            if not itemId or not IsHousingItem(itemId) then
                return false
            end
            
            -- Aktualisiere Größe falls sich geändert hat
            local Settings = GetSettings()
            local iconSize = Settings.iconSize or 20
            Arrow:SetSize(iconSize, iconSize)
            
            -- Setze Farbe basierend auf Item-Typ
            local r, g, b, a = GetHousingIconColor(itemId)
            Arrow:SetVertexColor(r, g, b, a)
            
            return true
        end,
        function(itemButton)     -- onInit Funktion (erstellt das Widget)
            local Arrow = itemButton:CreateTexture(nil, "OVERLAY")
            Arrow:SetTexture("Interface\\AddOns\\HousingItemTracker\\textures\\decorCost")
            local Settings = GetSettings()
            local iconSize = Settings.iconSize or 20
            Arrow:SetSize(iconSize, iconSize)
            Arrow:SetBlendMode("BLEND")
            -- Standard-Gold als Fallback (wird in onUpdate überschrieben)
            Arrow:SetVertexColor(1, 0.82, 0, 1)
            return Arrow
        end,
        {corner = "top_right", priority = 2}  -- Position und Priorität
    )
    
    -- Registriere als Upgrade-Plugin (für Suche/Filter)
    Baganator.API.RegisterUpgradePlugin(
        "Housing Item Tracker",
        "housingitemtracker",
        function(itemLink)
            if not itemLink then return false end
            local itemId = tonumber(itemLink:match("item:(%d+)"))
            return itemId and IsHousingItem(itemId)
        end
    )
end

------------------------------------------------------------
-- Bagnon Integration
------------------------------------------------------------

local function SetupBagnonIntegration()
    if not Bagnon then
        return
    end
    
    -- Hook Bagnon's Item Update
    hooksecurefunc(Bagnon.Item, "Update", function(self)
        -- WICHTIG: Prüfe IMMER den aktuellen Slot-Inhalt, auch wenn hasItem false ist
        -- Das stellt sicher, dass Icons beim Verschieben korrekt aktualisiert werden
        local bagID = self:GetBag()
        local slotID = self:GetID()
        
        if not bagID or not slotID then return end
        
        local itemId = C_Container.GetContainerItemID(bagID, slotID)
        
        -- Prüfe ob Settings aktiviert sind
        local Settings = GetSettings()
        if not Settings or not Settings.showBagIcons then
            if self.housingIcon then
                self.housingIcon:Hide()
            end
            return
        end
        
        if itemId and IsHousingItem(itemId) then
            if not self.housingIcon then
                self.housingIcon = self:CreateTexture(nil, "OVERLAY")
                self.housingIcon:SetTexture("Interface\\AddOns\\HousingItemTracker\\textures\\decorCost")
                local Settings = GetSettings()
                local iconSize = Settings.iconSize or 20
                self.housingIcon:SetSize(iconSize, iconSize)
                self.housingIcon:SetPoint("TOPRIGHT", self, "TOPRIGHT", 0, 0)
                self.housingIcon:SetDrawLayer("OVERLAY", 7)
                -- WICHTIG: SetBlendMode muss auf BLEND gesetzt sein, damit SetVertexColor funktioniert
                self.housingIcon:SetBlendMode("BLEND")
            end
            -- Aktualisiere Größe falls sich geändert hat
            local Settings = GetSettings()
            local iconSize = Settings.iconSize or 20
            self.housingIcon:SetSize(iconSize, iconSize)
            -- Setze Farbe basierend auf Item-Typ
            local r, g, b, a = GetHousingIconColor(itemId)
            -- WICHTIG: SetVertexColor funktioniert nur, wenn die TGA weiß/grau ist
            self.housingIcon:SetVertexColor(r, g, b, a)
            self.housingIcon:Show()
        else
            -- Verstecke Icon wenn kein Housing-Item im Slot ist
            if self.housingIcon then
                self.housingIcon:Hide()
            end
        end
    end)
    
    -- Zusätzlicher Hook für Bagnon's Refresh-Methode (falls vorhanden)
    if Bagnon.Item.Refresh then
        hooksecurefunc(Bagnon.Item, "Refresh", function(self)
            -- Trigger Update um Icons zu aktualisieren
            if self.Update then
                self:Update()
            end
        end)
    end
    
    -- Hook für Bagnon's Frame Refresh (wenn alle Items aktualisiert werden)
    if Bagnon.Frame and Bagnon.Frame.UpdateItems then
        hooksecurefunc(Bagnon.Frame, "UpdateItems", function(self)
            -- Update alle Items im Frame
            C_Timer.After(0.05, function()
                if self.items then
                    for _, item in pairs(self.items) do
                        if item and item.Update then
                            item:Update()
                        end
                    end
                end
            end)
        end)
    end
end

------------------------------------------------------------
-- AdiBags Integration
------------------------------------------------------------

local function SetupAdiBagsIntegration()
    if not AdiBags then
        return
    end
    
    -- Registriere einen Filter für Housing Items
    local filter = AdiBags:RegisterFilter("Housing Items", 90, "ABEvent-1.0")
    filter.uiName = "Housing Items"
    filter.uiDesc = "Zeigt Housing-Crafting Materialien an"
    
    function filter:OnInitialize()
        self.db = AdiBags.db:RegisterNamespace("HousingItemTracker", {
            profile = { enable = true }
        })
    end
    
    function filter:Update()
        self:SendMessage("AdiBags_FiltersChanged")
    end
    
    function filter:OnEnable()
        AdiBags:UpdateFilters()
    end
    
    function filter:OnDisable()
        AdiBags:UpdateFilters()
    end
    
    function filter:Filter(slotData)
        if not self.db.profile.enable then return end
        if not slotData.itemId then return end
        
        if IsHousingItem(slotData.itemId) then
            return "Housing Materials"
        end
    end
    
    -- Hook für Icon-Anzeige
    hooksecurefunc(AdiBags, "UpdateButton", function(self, button)
        if not button then return end
        
        local bagId = button:GetParent():GetID()
        local slotId = button:GetID()
        local itemId = C_Container.GetContainerItemID(bagId, slotId)
        
        if itemId and IsHousingItem(itemId) then
            if not button.housingIcon then
                button.housingIcon = button:CreateTexture(nil, "OVERLAY")
                button.housingIcon:SetTexture("Interface\\AddOns\\HousingItemTracker\\textures\\decorCost")
                local Settings = GetSettings()
                local iconSize = Settings.iconSize or 20
                button.housingIcon:SetSize(iconSize, iconSize)
                button.housingIcon:SetPoint("TOPRIGHT", button, "TOPRIGHT", 0, 0)
                button.housingIcon:SetDrawLayer("OVERLAY", 7)
                -- WICHTIG: SetBlendMode muss auf BLEND gesetzt sein, damit SetVertexColor funktioniert
                button.housingIcon:SetBlendMode("BLEND")
            end
            -- Aktualisiere Größe falls sich geändert hat
            local Settings = GetSettings()
            local iconSize = Settings.iconSize or 20
            button.housingIcon:SetSize(iconSize, iconSize)
            -- Setze Farbe basierend auf Item-Typ
            local r, g, b, a = GetHousingIconColor(itemId)
            -- WICHTIG: SetVertexColor funktioniert nur, wenn die TGA weiß/grau ist
            button.housingIcon:SetVertexColor(r, g, b, a)
            button.housingIcon:Show()
        else
            if button.housingIcon then
                button.housingIcon:Hide()
            end
        end
    end)
end

------------------------------------------------------------
-- ArkInventory Integration
------------------------------------------------------------

local function SetupArkInventoryIntegration()
    if not ArkInventory or not ArkInventory.API then
        return
    end
    
    -- Verwende die offizielle ArkInventory API
    hooksecurefunc(ArkInventory.API, "ItemFrameUpdated", function(frame, loc_id, bag_id, slot_id)
        if not frame or not frame.ARK_Data then return end
        
        -- Hole die Item-Daten über die offizielle API
        local itemData = ArkInventory.API.ItemFrameItemTableGet(frame)
        if not itemData then return end
        
        local itemId = nil
        
        -- itemData.h kann entweder eine itemID (number) oder ein Hyperlink (string) sein
        if itemData.h then
            if type(itemData.h) == "number" then
                itemId = itemData.h
            elseif type(itemData.h) == "string" then
                -- Extrahiere die itemID aus dem Hyperlink
                itemId = tonumber(itemData.h:match("item:(%d+)"))
            end
        end
        
        -- Überprüfe, ob es ein Housing-Item ist
        if itemId and IsHousingItem(itemId) then
            -- Erstelle das Icon nur einmal
            if not frame.housingIcon then
                frame.housingIcon = frame:CreateTexture(nil, "OVERLAY")
                frame.housingIcon:SetTexture("Interface\\AddOns\\HousingItemTracker\\textures\\decorCost")
                local Settings = GetSettings()
                local iconSize = Settings.iconSize or 20
                frame.housingIcon:SetSize(iconSize, iconSize)
                frame.housingIcon:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -2, -2)
                frame.housingIcon:SetDrawLayer("OVERLAY", 7)
                -- WICHTIG: SetBlendMode muss auf BLEND gesetzt sein, damit SetVertexColor funktioniert
                frame.housingIcon:SetBlendMode("BLEND")
            end
            -- Aktualisiere Größe falls sich geändert hat
            local Settings = GetSettings()
            local iconSize = Settings.iconSize or 20
            frame.housingIcon:SetSize(iconSize, iconSize)
            -- Setze Farbe basierend auf Item-Typ
            local r, g, b, a = GetHousingIconColor(itemId)
            -- WICHTIG: SetVertexColor funktioniert nur, wenn die TGA weiß/grau ist
            frame.housingIcon:SetVertexColor(r, g, b, a)
            frame.housingIcon:Show()
        else
            -- Verstecke das Icon, wenn es kein Housing-Item ist
            if frame.housingIcon then
                frame.housingIcon:Hide()
            end
        end
    end)
end

------------------------------------------------------------
-- Update-Funktionen für alle Integrations
------------------------------------------------------------

local function UpdateAllIntegrationIcons()
    -- Bagnon Update - aktualisiere alle Items in allen Frames
    if Bagnon then
        -- Methode 1: Über Bagnon.Frame.frames
        if Bagnon.Frame and Bagnon.Frame.frames then
            for _, frame in pairs(Bagnon.Frame.frames) do
                if frame and frame.items then
                    for _, item in pairs(frame.items) do
                        if item and item.Update then
                            item:Update()
                        end
                    end
                end
            end
        end
        -- Methode 2: Über Bagnon.API falls verfügbar
        if Bagnon.API then
            if Bagnon.API.GetFrames then
                local frames = Bagnon.API.GetFrames()
                if frames then
                    for _, frame in pairs(frames) do
                        if frame and frame.items then
                            for _, item in pairs(frame.items) do
                                if item and item.Update then
                                    item:Update()
                                end
                            end
                        end
                    end
                end
            end
            -- Versuche auch UpdateItems auf allen Frames
            if Bagnon.API.GetAllFrames then
                local allFrames = Bagnon.API.GetAllFrames()
                if allFrames then
                    for _, frame in pairs(allFrames) do
                        if frame and frame.UpdateItems then
                            frame:UpdateItems()
                        end
                    end
                end
            end
        end
        -- Methode 3: Direkt über Bagnon.Item.Update für alle bekannten Items
        -- Trigger ein BAG_UPDATE_DELAYED Event um alle Items zu aktualisieren
        C_Timer.After(0.1, function()
            if Bagnon.Frame and Bagnon.Frame.frames then
                for _, frame in pairs(Bagnon.Frame.frames) do
                    if frame and frame.UpdateItems then
                        frame:UpdateItems()
                    end
                end
            end
        end)
    end
    
    -- AdiBags Update - aktualisiere alle Buttons
    if AdiBags then
        -- Aktualisiere Filter
        if AdiBags.UpdateFilters then
            AdiBags:UpdateFilters()
        end
        -- Versuche alle Buttons zu aktualisieren
        if AdiBags.buttons then
            for button in pairs(AdiBags.buttons) do
                if button and AdiBags.UpdateButton then
                    AdiBags:UpdateButton(button)
                end
            end
        end
        -- Versuche auch über AdiBags.buttonsBySlot
        if AdiBags.buttonsBySlot then
            for _, button in pairs(AdiBags.buttonsBySlot) do
                if button and AdiBags.UpdateButton then
                    AdiBags:UpdateButton(button)
                end
            end
        end
        -- Versuche auch über AdiBags:UpdateAllButtons falls verfügbar
        if AdiBags.UpdateAllButtons then
            AdiBags:UpdateAllButtons()
        end
    end
    
    -- ArkInventory Update
    if ArkInventory then
        -- ArkInventory aktualisiert sich automatisch über Hook
        -- Aber wir können auch manuell aktualisieren
        if ArkInventory.Frame_Main_Generate then
            ArkInventory.Frame_Main_Generate()
        end
        -- Versuche auch über ArkInventory.API
        if ArkInventory.API and ArkInventory.API.Refresh then
            ArkInventory.API.Refresh()
        end
    end
    
    -- Baganator wird automatisch über onUpdate aktualisiert
    -- Die Corner Widgets werden bei jedem Item-Update automatisch aktualisiert
    -- Aber wir können auch manuell aktualisieren falls nötig
    if Baganator and Baganator.API then
        -- Baganator aktualisiert sich automatisch, aber wir können die Frames refreshen
        if Baganator.API.RefreshAllFrames then
            Baganator.API.RefreshAllFrames()
        end
    end
end

------------------------------------------------------------
-- Initialisierung
------------------------------------------------------------

local IntegrationFrame = CreateFrame("Frame")
IntegrationFrame:RegisterEvent("ADDON_LOADED")
IntegrationFrame:SetScript("OnEvent", function(self, event, loadedAddon)
    if loadedAddon == addonName then
        -- Warte einen Moment, damit andere Addons laden können
        C_Timer.After(2, function()
            -- Versuche alle bekannten Bag-Addons zu integrieren
            if Baganator then
                pcall(SetupBaganatorIntegration)
            end
            
            if Bagnon then
                pcall(SetupBagnonIntegration)
            end
            
            if AdiBags then
                pcall(SetupAdiBagsIntegration)
            end
            
            if ArkInventory then
                pcall(SetupArkInventoryIntegration)
            end
        end)
    end
end)

-- Exportiere Update-Funktion für HousingItemTracker
_G.HousingItemTrackerUpdateIntegrationIcons = UpdateAllIntegrationIcons


