local QBCore = exports['qb-core']:GetCoreObject()

-- Debug-Funktion
local function Debug(msg)
    print("^2[Grill Debug] ^7" .. msg)
end

-- Cache system for item checks
local itemCheckCache = {}
local lastCheckTime = {}
local checkCooldown = 1000 -- 1 second cooldown between checks for the same item

-- Function to check if player has an item
local function HasItem(itemName, amount, callback)
    -- Check cache first (to avoid spamming the server)
    local cacheKey = itemName .. "_" .. amount
    local currentTime = GetGameTimer()
    if itemCheckCache[cacheKey] ~= nil and lastCheckTime[cacheKey] and 
       (currentTime - lastCheckTime[cacheKey]) < checkCooldown then
        callback(itemCheckCache[cacheKey])
        return
    end
    
    -- Create a unique event name for this check
    local uniqueEventName = 'nordi_bbq:itemCheckResult:' .. math.random(100000, 999999)
    
    -- Register the event handler
    local eventHandler = RegisterNetEvent(uniqueEventName)
    AddEventHandler(uniqueEventName, function(hasItem)
        itemCheckCache[cacheKey] = hasItem
        lastCheckTime[cacheKey] = GetGameTimer()
        callback(hasItem)
    end)
    
    -- Request the check from server with our unique event name
    TriggerServerEvent('nordi_bbq:checkItem', itemName, amount, uniqueEventName)
    
    -- Set a timeout to prevent hanging if something goes wrong
    SetTimeout(1000, function()
        if not lastCheckTime[cacheKey] or (currentTime - lastCheckTime[cacheKey]) >= checkCooldown then
            callback(false)
        end
    end)
end

-- Warte auf vollständige Initialisierung von QBCore
CreateThread(function()
    if not QBCore then
        Debug("QBCore nicht gefunden, warte...")
        while not QBCore do
            QBCore = exports['qb-core']:GetCoreObject()
            Wait(100)
        end
    end
    
    Debug("QBCore initialisiert")
    
    -- Registriere Grill-Props für qb-target
    for _, prop in pairs(Config.GrillProps) do
        Debug("Registriere Target für Prop: " .. tostring(prop))
        exports['qb-target']:AddTargetModel(prop, {
            options = {
                {
                    type = "client",
                    event = "nordi_bbq:OpenGrillMenu",
                    icon = "fas fa-fire",
                    label = "Grillen",
                }
            },
            distance = 2.0
        })
    end
    
    Debug("Target-Optionen registriert")
end)

-- Event zum Öffnen des Grill-Menüs
RegisterNetEvent('nordi_bbq:OpenGrillMenu', function()
    Debug("Öffne Grill-Menü")
    OpenGrillMenu()
end)

-- Funktion zum Überprüfen der Zutaten
function CheckIngredients(recipe, callback)
    local hasItems = true
    local missingItems = {}
    local checkedItems = 0
    local totalItems = 0
    
    if not recipe or not recipe.requires then
        Debug("Rezept oder Anforderungen fehlen")
        callback(false, {})
        return
    end
    
    for _, _ in pairs(recipe.requires) do
        totalItems = totalItems + 1
    end
    
    if totalItems == 0 then
        callback(true, {})
        return
    end
    
    for _, item in pairs(recipe.requires) do
        HasItem(item.item, item.amount, function(hasItem)
            checkedItems = checkedItems + 1
            
            if not hasItem then
                hasItems = false
                table.insert(missingItems, {
                    item = item.item,
                    amount = item.amount
                })
            end
            
            if checkedItems == totalItems then
                callback(hasItems, missingItems)
            end
        end)
    end
end

-- Funktion zum Anzeigen fehlender Zutaten
function ShowMissingIngredients(missingItems)
    local text = "Fehlende Zutaten:\n"
    
    for _, item in pairs(missingItems) do
        local itemLabel = QBCore.Shared.Items[item.item] and QBCore.Shared.Items[item.item].label or item.item
        text = text .. "- " .. itemLabel .. " (" .. item.amount .. "x)\n"
    end
    
    QBCore.Functions.Notify(text, "error", 5000)
end

-- Funktion zum Öffnen des Grill-Menüs
function OpenGrillMenu()
    Debug("Erstelle Grill-Menü")
    
    local menuOptions = {}
    local recipesChecked = 0
    local totalRecipes = 0
    
    -- Count total recipes
    for _, _ in pairs(Config.GrillRecipes) do
        totalRecipes = totalRecipes + 1
    end
    
    -- Check each recipe
    for _, recipe in pairs(Config.GrillRecipes) do
        CheckIngredients(recipe, function(hasIngredients, missingItems)
            recipesChecked = recipesChecked + 1
            
            -- Create menu option for this recipe
            local status = hasIngredients and "~g~✓" or "~r~✗"
            
            -- Erstelle Beschreibung mit Zutaten
            local description = recipe.description .. "\n\nZutaten:"
            for _, item in pairs(recipe.requires) do
                local itemLabel = QBCore.Shared.Items[item.item] and QBCore.Shared.Items[item.item].label or item.item
                local hasItem = not table.find(missingItems, function(missingItem) return missingItem.item == item.item end)
                local itemStatus = hasItem and "~g~✓" or "~r~✗"
                description = description .. "\n- " .. item.amount .. "x " .. itemLabel .. " " .. itemStatus
            end
            
            table.insert(menuOptions, {
                title = recipe.label,
                description = description,
                icon = recipe.icon or "fas fa-drumstick-bite",
                onSelect = function()
                    StartGrilling(recipe)
                end
            })
            
            -- If all recipes checked, show the menu
            if recipesChecked == totalRecipes then
                ShowGrillMenu(menuOptions)
            end
        end)
    end
end

-- Helper function to find in table
function table.find(t, cb)
    for _, v in pairs(t) do
        if cb(v) then
            return true
        end
    end
    return false
end

-- Function to show the menu
function ShowGrillMenu(menuOptions)
    -- Registriere und zeige das Menü mit ox_lib
    if lib and lib.registerContext then
        lib.registerContext({
            id = 'grill_menu',
            title = 'Grill',
            options = menuOptions
        })
        
        lib.showContext('grill_menu')
    else
        Debug("FEHLER: ox_lib nicht verfügbar")
        QBCore.Functions.Notify("Fehler beim Laden des Menüs", "error")
    end
end

-- Funktion zum Starten des Grillvorgangs
function StartGrilling(recipe)
    Debug("Starte Grillvorgang für: " .. recipe.label)
    
    -- Überprüfe Zutaten erneut
    CheckIngredients(recipe, function(hasIngredients, missingItems)
        if not hasIngredients then
            ShowMissingIngredients(missingItems)
            return
        end
        
        -- Animation und Progressbar
        local animDict = "amb@prop_human_bbq@male@base"
        local anim = "base"
        
        RequestAnimDict(animDict)
        while not HasAnimDictLoaded(animDict) do
            Wait(10)
        end
        
        QBCore.Functions.Progressbar("grill_food", "Grille " .. recipe.label .. "...", Config.GrillTime, false, true, {
            disableMovement = true,
            disableCarMovement = true,
            disableMouse = false,
            disableCombat = true,
        }, {
            animDict = animDict,
            anim = anim,
            flags = 49,
        }, {}, {}, function() -- Success
            Debug("Grillvorgang abgeschlossen")
            TriggerServerEvent('nordi_bbq:server:GiveGrilledFood', recipe.item, recipe.requires)
        end, function() -- Cancel
            Debug("Grillvorgang abgebrochen")
            QBCore.Functions.Notify("Grillvorgang abgebrochen", "error")
        end)
    end)
end