client.lua

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

-- ============================================================================
-- LOCAL STATE
-- ============================================================================

local BusinessState = {}   -- [businessName] = { playing, trackIndex, volume, shuffle, shuffleOrder }
local SpawnedProps = {}     -- [businessName] = propEntity
local ActiveSounds = {}    -- [businessName] = true/false
local OpenJukebox = nil    -- Currently open jukebox business name

-- ============================================================================
-- HELPERS
-- ============================================================================

local function DebugPrint(...)
    if Config.Debug then
        print('[dynamic-jukebox]', ...)
    end
end

local function GetBusinessByName(name)
    for _, biz in ipairs(Config.Businesses) do
        if biz.name == name then
            return biz
        end
    end
    return nil
end

local function GetSoundId(businessName)
    return 'djb_' .. businessName
end

local function GetSongUrl(filename)
    return 'nui://dynamic-jukebox/music/' .. filename
end

local function GetPlaylistForBusiness(biz)
    return biz.playlist or {}
end

-- ============================================================================
-- XSOUND PLAYBACK
-- ============================================================================

local function StopSound(businessName)
    local soundId = GetSoundId(businessName)
    if ActiveSounds[businessName] then
        pcall(function()
            exports.xsound:Destroy(soundId)
        end)
        ActiveSounds[businessName] = false
        DebugPrint('Stopped sound for', businessName)
    end
end

local function PlaySound(businessName)
    local biz = GetBusinessByName(businessName)
    if not biz then return end

    local state = BusinessState[businessName]
    if not state or not state.playing then return end

    local playlist = GetPlaylistForBusiness(biz)
    if #playlist == 0 then return end

    local trackIndex = state.trackIndex or 1
    if trackIndex > #playlist then trackIndex = 1 end

    local soundId = GetSoundId(businessName)
    local url = GetSongUrl(playlist[trackIndex])
    local volume = state.volume or Config.DefaultVolume
    local maxDist = biz.maxDistance or Config.MaxSoundDistance
    local coords = biz.soundCoords

    -- Destroy existing sound first
    StopSound(businessName)

    -- Play positional sound (not looped — we handle advancement ourselves)
    exports.xsound:PlayUrlPos(soundId, url, volume, coords, false)

    -- Wait for xsound to register the sound before setting distance
    Wait(200)
    exports.xsound:Distance(soundId, maxDist)

    ActiveSounds[businessName] = true
    DebugPrint('Playing track', trackIndex, '(' .. playlist[trackIndex] .. ') for', businessName)

    -- Update NUI if this jukebox is open
    if OpenJukebox == businessName then
        SendNUIMessage({
            action = 'updateState',
            playing = state.playing,
            trackIndex = trackIndex,
            trackName = playlist[trackIndex],
            volume = volume,
            totalTracks = #playlist,
            shuffle = state.shuffle or false,
        })
    end
end

local function SetVolume(businessName, volume)
    local soundId = GetSoundId(businessName)
    if ActiveSounds[businessName] then
        pcall(function()
            exports.xsound:setVolume(soundId, volume)
        end)
    end
end

-- ============================================================================
-- SONG END DETECTION & AUTO-ADVANCE
-- ============================================================================
-- xsound fires 'xsound:Finish' when a sound finishes playing.
-- If your xsound version uses a different event, change the name below.
-- Common alternatives: 'xsound:onPlayEnd', 'xsound:soundEnd'
-- ============================================================================

RegisterNetEvent('xsound:Finish', function(soundId)
    for _, biz in ipairs(Config.Businesses) do
        if GetSoundId(biz.name) == soundId then
            local state = BusinessState[biz.name]
            if state and state.playing then
                DebugPrint('Sound finished for', biz.name, '- requesting advance')
                ActiveSounds[biz.name] = false
                TriggerServerEvent('djb:server:AdvanceTrack', biz.name)
            end
            break
        end
    end
end)

-- ============================================================================
-- SERVER SYNC EVENTS
-- ============================================================================

RegisterNetEvent('djb:client:SyncState', function(allStates)
    DebugPrint('Received full state sync')
    if type(allStates) ~= 'table' then return end

    for businessName, state in pairs(allStates) do
        BusinessState[businessName] = state
        if state.playing then
            CreateThread(function()
                PlaySound(businessName)
            end)
        else
            StopSound(businessName)
        end
    end
end)

RegisterNetEvent('djb:client:UpdateBusiness', function(businessName, state)
    if type(businessName) ~= 'string' or type(state) ~= 'table' then return end

    DebugPrint('Received update for', businessName, '| playing:', state.playing, '| track:', state.trackIndex)
    local oldState = BusinessState[businessName]
    BusinessState[businessName] = state

    if state.playing then
        if not oldState or not oldState.playing or oldState.trackIndex ~= state.trackIndex then
            CreateThread(function()
                PlaySound(businessName)
            end)
        else
            SetVolume(businessName, state.volume)
        end
    else
        StopSound(businessName)
    end

    -- Update NUI if open
    if OpenJukebox == businessName then
        local biz = GetBusinessByName(businessName)
        if not biz then return end
        local playlist = GetPlaylistForBusiness(biz)
        local trackIndex = state.trackIndex or 1
        SendNUIMessage({
            action = 'updateState',
            playing = state.playing,
            trackIndex = trackIndex,
            trackName = playlist[trackIndex] or 'Unknown',
            volume = state.volume or Config.DefaultVolume,
            totalTracks = #playlist,
            shuffle = state.shuffle or false,
        })
    end
end)

-- ============================================================================
-- JUKEBOX INTERACTION
-- ============================================================================

local function OpenJukeboxUI(businessName)
    local biz = GetBusinessByName(businessName)
    if not biz then return end

    -- Prevent opening if already open
    if OpenJukebox then return end

    -- Job lock check
    if biz.jobLock then
        local PlayerData = QBCore.Functions.GetPlayerData()
        if not PlayerData or not PlayerData.job or PlayerData.job.name ~= biz.jobLock then
            QBCore.Functions.Notify('You don\'t have access to this jukebox.', 'error')
            return
        end
    end

    local state = BusinessState[businessName] or {
        playing = false,
        trackIndex = 1,
        volume = biz.defaultVolume or Config.DefaultVolume,
        shuffle = Config.ShuffleMode,
    }

    local playlist = GetPlaylistForBusiness(biz)
    local trackIndex = state.trackIndex or 1

    OpenJukebox = businessName

    SetNuiFocus(true, true)
    SendNUIMessage({
        action = 'open',
        businessLabel = biz.label,
        playing = state.playing,
        trackIndex = trackIndex,
        trackName = playlist[trackIndex] or 'No tracks loaded',
        volume = state.volume or Config.DefaultVolume,
        totalTracks = #playlist,
        playlist = playlist,
        shuffle = state.shuffle or false,
    })

    DebugPrint('Opened jukebox UI for', businessName)
end

local function CloseJukeboxUI()
    if not OpenJukebox then return end
    SetNuiFocus(false, false)
    SendNUIMessage({ action = 'close' })
    OpenJukebox = nil
end

-- ============================================================================
-- NUI CALLBACKS
-- ============================================================================

RegisterNUICallback('close', function(_, cb)
    CloseJukeboxUI()
    cb('ok')
end)

RegisterNUICallback('togglePlay', function(_, cb)
    if OpenJukebox then
        TriggerServerEvent('djb:server:TogglePlay', OpenJukebox)
    end
    cb('ok')
end)

RegisterNUICallback('skip', function(_, cb)
    if OpenJukebox then
        TriggerServerEvent('djb:server:SkipTrack', OpenJukebox)
    end
    cb('ok')
end)

RegisterNUICallback('previous', function(_, cb)
    if OpenJukebox then
        TriggerServerEvent('djb:server:PrevTrack', OpenJukebox)
    end
    cb('ok')
end)

RegisterNUICallback('setVolume', function(data, cb)
    if OpenJukebox then
        local vol = tonumber(data.volume) or Config.DefaultVolume
        vol = math.max(0.0, math.min(1.0, vol))
        TriggerServerEvent('djb:server:SetVolume', OpenJukebox, vol)
    end
    cb('ok')
end)

RegisterNUICallback('selectTrack', function(data, cb)
    if OpenJukebox then
        local trackIndex = tonumber(data.trackIndex)
        if trackIndex then
            TriggerServerEvent('djb:server:SelectTrack', OpenJukebox, trackIndex)
        end
    end
    cb('ok')
end)

RegisterNUICallback('toggleShuffle', function(_, cb)
    if OpenJukebox then
        TriggerServerEvent('djb:server:ToggleShuffle', OpenJukebox)
    end
    cb('ok')
end)

-- ============================================================================
-- PROP SPAWNING
-- ============================================================================

local function SpawnJukeboxProps()
    if not Config.JukeboxProp then return end

    local propHash = GetHashKey(Config.JukeboxProp)

    for _, biz in ipairs(Config.Businesses) do
        local coords = biz.jukeboxCoords
        local heading = biz.jukeboxHeading or Config.JukeboxHeading or 0.0

        if type(coords) == 'vector4' then
            heading = coords.w
            coords = vector3(coords.x, coords.y, coords.z)
        end

        RequestModel(propHash)
        local timeout = 0
        while not HasModelLoaded(propHash) and timeout < 50 do
            Wait(100)
            timeout = timeout + 1
        end

        if HasModelLoaded(propHash) then
            local prop = CreateObject(propHash, coords.x, coords.y, coords.z, false, false, false)
            SetEntityHeading(prop, heading)
            FreezeEntityPosition(prop, true)
            SetEntityAsMissionEntity(prop, true, true)
            SpawnedProps[biz.name] = prop
            DebugPrint('Spawned jukebox prop for', biz.name)
        else
            DebugPrint('ERROR: Failed to load jukebox model for', biz.name)
        end
    end
end

local function DeleteJukeboxProps()
    for name, prop in pairs(SpawnedProps) do
        if DoesEntityExist(prop) then
            DeleteEntity(prop)
        end
        SpawnedProps[name] = nil
    end
end

-- ============================================================================
-- TARGET / INTERACTION ZONES
-- ============================================================================

local function SetupTargets()
    for _, biz in ipairs(Config.Businesses) do
        local coords = biz.jukeboxCoords
        if type(coords) == 'vector4' then
            coords = vector3(coords.x, coords.y, coords.z)
        end

        if Config.UseTarget then
            if Config.TargetResource == 'ox_target' then
                exports.ox_target:addSphereZone({
                    coords = coords,
                    radius = Config.InteractionDistance,
                    debug = Config.Debug,
                    options = {
                        {
                            label = '🎵 ' .. biz.label .. ' Jukebox',
                            icon = 'fas fa-music',
                            onSelect = function()
                                OpenJukeboxUI(biz.name)
                            end,
                        }
                    }
                })
            else
                exports['qb-target']:AddCircleZone(
                    'djb_' .. biz.name,
                    coords,
                    Config.InteractionDistance,
                    {
                        name = 'djb_' .. biz.name,
                        debugPoly = Config.Debug,
                    },
                    {
                        options = {
                            {
                                type = 'client',
                                icon = 'fas fa-music',
                                label = biz.label .. ' Jukebox',
                                action = function()
                                    OpenJukeboxUI(biz.name)
                                end,
                            }
                        },
                        distance = Config.InteractionDistance + 1.0,
                    }
                )
            end
        end
    end
end

-- ============================================================================
-- DRAWTEXT FALLBACK (if not using target)
-- ============================================================================

local function DrawTextInteraction()
    if Config.UseTarget then return end

    CreateThread(function()
        while true do
            local sleep = 1000
            local playerCoords = GetEntityCoords(PlayerPedId())

            for _, biz in ipairs(Config.Businesses) do
                local coords = biz.jukeboxCoords
                if type(coords) == 'vector4' then
                    coords = vector3(coords.x, coords.y, coords.z)
                end

                local dist = #(playerCoords - coords)

                if dist < Config.InteractionDistance + 2.0 then
                    sleep = 0
                    if dist < Config.InteractionDistance then
                        DrawText3D(coords.x, coords.y, coords.z + 1.0, '~g~[E]~w~ ' .. biz.label .. ' Jukebox')
                        if IsControlJustPressed(0, 38) then
                            OpenJukeboxUI(biz.name)
                        end
                    end
                end
            end

            Wait(sleep)
        end
    end)
end

function DrawText3D(x, y, z, text)
    SetTextScale(0.35, 0.35)
    SetTextFont(4)
    SetTextProportional(true)
    SetTextColour(255, 255, 255, 215)
    BeginTextCommandDisplayText('STRING')
    SetTextCentre(true)
    AddTextComponentSubstringPlayerName(text)
    SetDrawOrigin(x, y, z, 0)
    EndTextCommandDisplayText(0.0, 0.0)
    ClearDrawOrigin()
end

-- ============================================================================
-- ESCAPE KEY TO CLOSE NUI
-- ============================================================================

CreateThread(function()
    while true do
        Wait(0)
        if OpenJukebox then
            DisableControlAction(0, 1, true)
            DisableControlAction(0, 2, true)
            DisableControlAction(0, 142, true)
            DisableControlAction(0, 18, true)
            DisableControlAction(0, 322, true)
            DisableControlAction(0, 106, true)
            if IsDisabledControlJustPressed(0, 177) then
                CloseJukeboxUI()
            end
        else
            Wait(500)
        end
    end
end)

-- ============================================================================
-- INITIALIZATION
-- ============================================================================

CreateThread(function()
    while not LocalPlayer.state.isLoggedIn do
        Wait(500)
    end

    Wait(2000)

    SpawnJukeboxProps()
    SetupTargets()
    DrawTextInteraction()

    TriggerServerEvent('djb:server:RequestState')
    DebugPrint('Client initialized')
end)

AddEventHandler('onResourceStop', function(resource)
    if resource ~= GetCurrentResourceName() then return end
    DeleteJukeboxProps()
    for _, biz in ipairs(Config.Businesses) do
        StopSound(biz.name)
    end
    if OpenJukebox then
        SetNuiFocus(false, false)
        OpenJukebox = nil
    end
end)

-- ============================================================================
-- COMMANDS
-- ============================================================================

RegisterCommand('jukeboxreload', function()
    for _, biz in ipairs(Config.Businesses) do
        StopSound(biz.name)
    end
    TriggerServerEvent('djb:server:RequestState')
    QBCore.Functions.Notify('Jukebox state reloaded', 'success')
end, false)

RegisterCommand('jukeboxhelp', function()
    TriggerEvent('chat:addMessage', { color = {83, 167, 234}, args = {'Jukebox', '--- Dynamic Jukebox Commands ---'}})
    TriggerEvent('chat:addMessage', { color = {200, 200, 200}, args = {'Jukebox', '/jukeboxreload — Re-sync jukebox state from server'}})
    TriggerEvent('chat:addMessage', { color = {200, 200, 200}, args = {'Jukebox', '/jukeboxhelp — Show this help message'}})
    TriggerEvent('chat:addMessage', { color = {255, 200, 100}, args = {'Jukebox', 'Admin: /jukeboxstop — Stop all jukeboxes'}})
    TriggerEvent('chat:addMessage', { color = {255, 200, 100}, args = {'Jukebox', 'Admin: /jukeboxstart — Start all jukeboxes'}})
    TriggerEvent('chat:addMessage', { color = {255, 200, 100}, args = {'Jukebox', 'Admin: /jukeboxvol [business] [0-100] — Set volume'}})
end, false)