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

-- Event wenn ein Item konsumiert wird
RegisterNetEvent('qb-pfandsystem:server:itemConsumed', function(itemName)
    local src = source
    local Player = QBCore.Functions.GetPlayer(src)
    
    if not Player then return end
    
    -- Prüfe ob das konsumierte Item Pfand generiert
    if Config.ConsumableItems[itemName] then
        local consumableConfig = Config.ConsumableItems[itemName]
        local pfandItem = consumableConfig.pfandItem
        local chance = consumableConfig.chance or 100
        
        -- Würfle ob Pfand erhalten wird
        local randomChance = math.random(1, 100)
        
        if randomChance <= chance then
            -- Gebe Pfanditem mit korrektem tgiann-inventory Export
            local success = exports['tgiann-inventory']:AddItem(src, pfandItem, 1, nil, nil, function(success, reason)
                if success then
                    if Config.ShowPfandNotification then
                        local pfandLabel = Config.PfandItems[pfandItem] and Config.PfandItems[pfandItem].label or pfandItem
                        
                        TriggerClientEvent('ox_lib:notify', src, {
                            title = 'Pfandsystem',
                            description = string.format(Config.Locale['pfand_received'], pfandLabel),
                            type = 'success',
                            duration = 3000
                        })
                    end
                    
                    if Config.Debug then
                        print(string.format('[Pfandsystem] Spieler %s hat %s konsumiert und %s erhalten', 
                            Player.PlayerData.name, itemName, pfandItem))
                    end
                else
                    if Config.Debug then
                        print(string.format('[Pfandsystem] Fehler beim Hinzufügen von %s: %s', pfandItem, reason or 'Unbekannt'))
                    end
                end
            end)
        else
            -- Pfand nicht erhalten (z.B. Flasche zerbrochen)
            if Config.ShowPfandNotification and chance < 100 then
                TriggerClientEvent('ox_lib:notify', src, {
                    title = 'Pfandsystem',
                    description = Config.Locale['pfand_bottle_broken'],
                    type = 'error',
                    duration = 3000
                })
            end
            
            if Config.Debug then
                print(string.format('[Pfandsystem] Spieler %s hat %s konsumiert aber kein Pfand erhalten (%d%% Chance)', 
                    Player.PlayerData.name, itemName, chance))
            end
        end
    end
end)

-- Pfand einlösen
RegisterNetEvent('qb-pfandsystem:server:redeemPfand', function(selectedItems)
    local src = source
    local Player = QBCore.Functions.GetPlayer(src)
    
    if not Player then return end
    
    local totalPfand = 0
    local totalItems = 0
    local itemsToRemove = {}
    
    -- Überprüfe ob Spieler die Items hat und berechne Gesamtpfand
    for itemName, quantity in pairs(selectedItems) do
        if Config.PfandItems[itemName] then
            -- Verwende tgiann-inventory Export um Item zu prüfen
            exports['tgiann-inventory']:GetItem(src, itemName, function(item)
                if item and item.count >= quantity then
                    local pfandWert = Config.PfandItems[itemName].pfandwert * quantity
                    totalPfand = totalPfand + pfandWert
                    totalItems = totalItems + quantity
                    itemsToRemove[itemName] = quantity
                else
                    TriggerClientEvent('ox_lib:notify', src, {
                        title = 'Pfandsystem',
                        description = 'Du hast nicht genug ' .. (Config.PfandItems[itemName].label or itemName),
                        type = 'error'
                    })
                    return
                end
            end)
        end
    end
    
    -- Warte kurz damit alle Callbacks verarbeitet werden
    SetTimeout(500, function()
        if totalPfand <= 0 then
            TriggerClientEvent('ox_lib:notify', src, {
                title = 'Pfandsystem',
                description = Config.Locale['no_pfand_items'],
                type = 'error'
            })
            return
        end
        
        -- Entferne Items aus dem Inventar
        local removedSuccessfully = true
        for itemName, quantity in pairs(itemsToRemove) do
            exports['tgiann-inventory']:RemoveItem(src, itemName, quantity, nil, function(success, reason)
                if not success then
                    removedSuccessfully = false
                    if Config.Debug then
                        print(string.format('[Pfandsystem] Fehler beim Entfernen von %s: %s', itemName, reason or 'Unbekannt'))
                    end
                end
            end)
        end
        
        if removedSuccessfully then
            -- Gebe Geld
            if Config.Currency == 'cash' then
                Player.Functions.AddMoney('cash', totalPfand)
            else
                Player.Functions.AddMoney('bank', totalPfand)
            end
            
            -- Formatiere Geld für Anzeige
            local moneyString = string.format("€%.2f", totalPfand / 100)
            
            TriggerClientEvent('ox_lib:notify', src, {
                title = 'Pfandsystem',
                description = string.format(Config.Locale['pfand_success'], moneyString, totalItems),
                type = 'success'
            })
            
            if Config.Debug then
                print(string.format('[Pfandsystem] Spieler %s hat %d Items für €%.2f eingelöst', 
                    Player.PlayerData.name, totalItems, totalPfand / 100))
            end
        else
            TriggerClientEvent('ox_lib:notify', src, {
                title = 'Pfandsystem',
                description = Config.Locale['pfand_error'],
                type = 'error'
            })
        end
    end)
end)

-- Hole verfügbare Pfand Items des Spielers
QBCore.Functions.CreateCallback('qb-pfandsystem:server:getPfandItems', function(source, cb)
    local src = source
    local pfandItems = {}
    local itemsChecked = 0
    local totalItems = 0
    
    -- Zähle wie viele Items wir prüfen müssen
    for _ in pairs(Config.PfandItems) do
        totalItems = totalItems + 1
    end
    
    if totalItems == 0 then
        cb(pfandItems)
        return
    end
    
    for itemName, itemConfig in pairs(Config.PfandItems) do
        exports['tgiann-inventory']:GetItem(src, itemName, function(item)
            itemsChecked = itemsChecked + 1
            
            if item and item.count > 0 then
                pfandItems[itemName] = {
                    count = item.count,
                    label = itemConfig.label,
                    pfandwert = itemConfig.pfandwert,
                    totalWert = itemConfig.pfandwert * item.count
                }
            end
            
            -- Wenn alle Items geprüft wurden, sende Ergebnis zurück
            if itemsChecked >= totalItems then
                cb(pfandItems)
            end
        end)
    end
end)

-- Event-Handler für tgiann-inventory item usage
-- Basierend auf der Dokumentation
RegisterNetEvent('tgiann-inventory:itemUsed')
AddEventHandler('tgiann-inventory:itemUsed', function(source, itemName, itemData)
    if Config.ConsumableItems[itemName] then
        SetTimeout(100, function()
            TriggerEvent('qb-pfandsystem:server:itemConsumed', itemName)
        end)
    end
end)

-- Alternative Event (falls der obere nicht funktioniert)
RegisterNetEvent('inventory:server:UseItem')
AddEventHandler('inventory:server:UseItem', function(itemName, itemData)
    local src = source
    if Config.ConsumableItems[itemName] then
        SetTimeout(100, function()
            TriggerEvent('qb-pfandsystem:server:itemConsumed', itemName)
        end)
    end
end)

-- Export für andere Scripts
exports('ConsumePfandItem', function(source, itemName)
    TriggerEvent('qb-pfandsystem:server:itemConsumed', itemName)
end)