local QBCore = exports['qb-core']:GetCoreObject()
local trackedVehicles = {}
local playerVehicles = {}

-- Funktion um zu prüfen ob Fahrzeugklasse erlaubt ist
local function IsVehicleClassAllowed(vehicle)
    local vehicleClass = GetVehicleClass(vehicle)
    for _, allowedClass in pairs(Config.AllowedVehicleClasses) do
        if vehicleClass == allowedClass then
            return true
        end
    end
    return false
end

-- Funktion um Fahrzeugmods zu erhalten
local function GetVehicleMods(vehicle)
    local mods = {}
    
    -- Basis Mods
    for i = 0, 49 do
        mods[tostring(i)] = GetVehicleMod(vehicle, i)
    end
    
    -- Extras
    mods.extras = {}
    for i = 1, 12 do
        if DoesExtraExist(vehicle, i) then
            mods.extras[tostring(i)] = IsVehicleExtraTurnedOn(vehicle, i)
        end
    end
    
    -- Farben
    local primaryColor, secondaryColor = GetVehicleColours(vehicle)
    local pearlescentColor, wheelColor = GetVehicleExtraColours(vehicle)
    
    mods.colors = {
        primary = primaryColor,
        secondary = secondaryColor,
        pearlescent = pearlescentColor,
        wheels = wheelColor
    }
    
    -- Neon
    mods.neon = {
        left = IsVehicleNeonLightEnabled(vehicle, 0),
        right = IsVehicleNeonLightEnabled(vehicle, 1),
        front = IsVehicleNeonLightEnabled(vehicle, 2),
        back = IsVehicleNeonLightEnabled(vehicle, 3)
    }
    
    local r, g, b = GetVehicleNeonLightsColour(vehicle)
    mods.neonColor = {r = r, g = g, b = b}
    
    return mods
end

-- Funktion um Fahrzeugmods zu setzen
local function SetVehicleMods(vehicle, mods)
    if not mods then return end
    
    -- Basis Mods
    for i = 0, 49 do
        if mods[tostring(i)] then
            SetVehicleMod(vehicle, i, mods[tostring(i)], false)
        end
    end
    
    -- Extras
    if mods.extras then
        for i = 1, 12 do
            if mods.extras[tostring(i)] ~= nil then
                SetVehicleExtra(vehicle, i, not mods.extras[tostring(i)])
            end
        end
    end
    
    -- Farben
    if mods.colors then
        SetVehicleColours(vehicle, mods.colors.primary or 0, mods.colors.secondary or 0)
        SetVehicleExtraColours(vehicle, mods.colors.pearlescent or 0, mods.colors.wheels or 0)
    end
    
    -- Neon
    if mods.neon then
        SetVehicleNeonLightEnabled(vehicle, 0, mods.neon.left or false)
        SetVehicleNeonLightEnabled(vehicle, 1, mods.neon.right or false)
        SetVehicleNeonLightEnabled(vehicle, 2, mods.neon.front or false)
        SetVehicleNeonLightEnabled(vehicle, 3, mods.neon.back or false)
    end
    
    if mods.neonColor then
        SetVehicleNeonLightsColour(vehicle, mods.neonColor.r, mods.neonColor.g, mods.neonColor.b)
    end
end

-- Prüfe ob Fahrzeug einem Spieler gehört
local function DoesVehicleBelongToPlayer(plate)
    -- Verwende jg-advanced-garage Export
    local vehicleData = exports['jg-advancedgarages']:GetVehicleByPlate(plate)
    return vehicleData ~= nil
end

-- Hauptloop für Fahrzeugtracking
CreateThread(function()
    while true do
        Wait(Config.SaveInterval)
        
        local playerPed = PlayerPedId()
        local playerCoords = GetEntityCoords(playerPed)
        
        -- Finde alle Fahrzeuge in der Nähe
        local vehicles = GetGamePool('CVehicle')
        
        for _, vehicle in pairs(vehicles) do
            if DoesEntityExist(vehicle) and IsVehicleClassAllowed(vehicle) then
                local plate = QBCore.Functions.GetPlate(vehicle)
                local vehicleCoords = GetEntityCoords(vehicle)
                local distance = #(playerCoords - vehicleCoords)
                
                -- Prüfe ob Fahrzeug einem Spieler gehört
                if DoesVehicleBelongToPlayer(plate) then
                    -- Prüfe ob Fahrzeug nicht zu nah an einer Garage ist
                    local nearGarage = exports['jg-advancedgarages']:IsNearGarage(vehicleCoords, Config.MinGarageDistance)
                    
                    if not nearGarage then
                        -- Speichere Fahrzeugdaten
                        local vehicleData = {
                            plate = plate,
                            model = GetDisplayNameFromVehicleModel(GetEntityModel(vehicle)),
                            position = {x = vehicleCoords.x, y = vehicleCoords.y, z = vehicleCoords.z},
                            rotation = {x = 0.0, y = 0.0, z = GetEntityHeading(vehicle)},
                            engineHealth = GetVehicleEngineHealth(vehicle),
                            bodyHealth = GetVehicleBodyHealth(vehicle),
                            fuel = exports['LegacyFuel']:GetFuel(vehicle) or 100, -- Anpassen je nach Fuel System
                            mods = GetVehicleMods(vehicle)
                        }
                        
                        TriggerServerEvent('vehicle-persistence:server:saveVehiclePosition', vehicleData)
                        trackedVehicles[plate] = vehicle
                        
                        -- Verhindere Despawn
                        SetEntityAsMissionEntity(vehicle, true, true)
                        SetVehicleHasBeenOwnedByPlayer(vehicle, true)
                        
                        if Config.Debug then
                            print(string.format("Tracking vehicle: %s at distance: %.2f", plate, distance))
                        end
                    end
                end
            end
        end
    end
end)

-- Spawne gespeicherte Fahrzeuge
RegisterNetEvent('vehicle-persistence:client:spawnSavedVehicles', function(vehicles)
    for _, vehicleData in pairs(vehicles) do
        local position = json.decode(vehicleData.position)
        local rotation = json.decode(vehicleData.rotation)
        
        -- Prüfe ob Fahrzeug bereits existiert
        local existingVehicle = GetVehicleByPlate(vehicleData.plate)
        if not existingVehicle then
            -- Prüfe ob Position nicht in einer Garage ist
            local nearGarage = exports['jg-advancedgarages']:IsNearGarage(vector3(position.x, position.y, position.z), Config.MinGarageDistance)
            
            if not nearGarage then
                -- Spawne Fahrzeug
                local modelHash = GetHashKey(vehicleData.model)
                
                RequestModel(modelHash)
                while not HasModelLoaded(modelHash) do
                    Wait(100)
                end
                
                local vehicle = CreateVehicle(modelHash, position.x, position.y, position.z, rotation.z, true, false)
                
                if DoesEntityExist(vehicle) then
                    -- Setze Fahrzeugdaten
                    SetVehicleNumberPlateText(vehicle, vehicleData.plate)
                    SetVehicleEngineHealth(vehicle, vehicleData.engine_health)
                    SetVehicleBodyHealth(vehicle, vehicleData.body_health)
                    
                    -- Setze Fuel (anpassen je nach System)
                    if exports['LegacyFuel'] then
                        exports['LegacyFuel']:SetFuel(vehicle, vehicleData.fuel)
                    end
                    
                    -- Setze Mods
                    if vehicleData.mods then
                        local mods = json.decode(vehicleData.mods)
                        SetVehicleMods(vehicle, mods)
                    end
                    
                    -- Verhindere Despawn
                    SetEntityAsMissionEntity(vehicle, true, true)
                    SetVehicleHasBeenOwnedByPlayer(vehicle, true)
                    
                    trackedVehicles[vehicleData.plate] = vehicle
                    
                    if Config.Debug then
                        print(string.format("Spawned saved vehicle: %s", vehicleData.plate))
                    end
                end
                
                SetModelAsNoLongerNeeded(modelHash)
            else
                -- Entferne aus Datenbank da es zu nah an einer Garage ist
                TriggerServerEvent('vehicle-persistence:server:removeVehicle', vehicleData.plate)
            end
        end
    end
end)

-- Hilfsfunktion um Fahrzeug anhand Kennzeichen zu finden
function GetVehicleByPlate(plate)
    local vehicles = GetGamePool('CVehicle')
    for _, vehicle in pairs(vehicles) do
        if QBCore.Functions.GetPlate(vehicle) == plate then
            return vehicle
        end
    end
    return nil
end

-- Lade Fahrzeuge beim Spawn
RegisterNetEvent('QBCore:Client:OnPlayerLoaded', function()
    Wait(5000) -- Warte bis alles geladen ist
    TriggerServerEvent('vehicle-persistence:server:loadVehicles')
end)

-- jg-advanced-garage Events
RegisterNetEvent('jg-advancedgarages:client:vehicle-stored', function(data)
    -- Entferne aus Tracking wenn Fahrzeug gespeichert wird
    if data and data.plate and trackedVehicles[data.plate] then
        trackedVehicles[data.plate] = nil
        if Config.Debug then
            print(string.format("Vehicle stored, removed from tracking: %s", data.plate))
        end
    end
end)

RegisterNetEvent('jg-advancedgarages:client:vehicle-spawned', function(data)
    -- Entferne aus Tracking da Fahrzeug jetzt über Garage gespawnt wurde
    if data and data.plate and trackedVehicles[data.plate] then
        trackedVehicles[data.plate] = nil
        if Config.Debug then
            print(string.format("Vehicle spawned from garage, removed from tracking: %s", data.plate))
        end
    end
end)

-- Cleanup beim Disconnect
AddEventHandler('onResourceStop', function(resourceName)
    if resourceName == GetCurrentResourceName() then
        -- Cleanup Code hier falls nötig
        trackedVehicles = {}
    end
end)