--------------------------------------------------
-- SERVICES
--------------------------------------------------
local Players = game:GetService("Players")
local Workspace = game:GetService("Workspace")

local LOCAL_PLAYER = Players.LocalPlayer

--------------------------------------------------
-- CONFIG COLORS
--------------------------------------------------
local COLORS = {
    Radar = Color3.fromRGB(255, 90, 90),
    Police = Color3.fromRGB(90, 160, 255),
    None = Color3.fromRGB(120, 245, 170),
    Loot = Color3.fromRGB(255, 230, 80)
}

--------------------------------------------------
-- STORAGE
--------------------------------------------------
local ESP_TRACKER = {}
local HEALTH_TRACKER = {}

--------------------------------------------------
-- ROLE SYSTEM
--------------------------------------------------
local function getRole(player, character)
    local function check(container)
        if not container then return nil end
        if container:FindFirstChild("Radar") then
            return "Radar"
        elseif container:FindFirstChild("PoliceBadge") then
            return "Police"
        end
    end

    local role = check(character)

    local backpack = player:FindFirstChild("Backpack")
    if not role then
        role = check(backpack)
    end

    return role or "None"
end

--------------------------------------------------
-- HIGHLIGHT (PLAYER SYSTEM)
--------------------------------------------------
local function createHighlight(target, color)
    if not target then return end

    local h = Instance.new("Highlight")
    h.FillTransparency = 0.85
    h.OutlineTransparency = 0.2
    h.FillColor = color
    h.OutlineColor = color
    h.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    h.Parent = target

    return h
end

--------------------------------------------------
-- HEALTH BILLBOARD
--------------------------------------------------
local function createBillboard(head)
    local billboard = Instance.new("BillboardGui")
    billboard.Name = "HealthDisplay"
    billboard.Size = UDim2.new(4, 0, 1, 0)
    billboard.StudsOffset = Vector3.new(0, 3, 0)
    billboard.AlwaysOnTop = true
    billboard.Parent = head

    local label = Instance.new("TextLabel")
    label.Size = UDim2.new(1, 0, 1, 0)
    label.BackgroundTransparency = 1
    label.TextScaled = true
    label.TextStrokeTransparency = 0.3
    label.Font = Enum.Font.SourceSansBold
    label.TextColor3 = Color3.fromRGB(0, 255, 90)
    label.Parent = billboard

    return billboard, label
end

--------------------------------------------------
-- CLEANUP HEALTH
--------------------------------------------------
local function cleanupHealth(player)
    local data = HEALTH_TRACKER[player]
    if not data then return end

    if data.Billboard then
        data.Billboard:Destroy()
    end

    if data.Connection then
        data.Connection:Disconnect()
    end

    HEALTH_TRACKER[player] = nil
end

--------------------------------------------------
-- HEALTH SETUP
--------------------------------------------------
local function setupHealth(player, character)
    if player == LOCAL_PLAYER then return end
    if HEALTH_TRACKER[player] then return end

    local head = character:FindFirstChild("Head") or character:WaitForChild("Head", 5)
    local hum = character:FindFirstChildOfClass("Humanoid") or character:WaitForChild("Humanoid", 5)
    if not head or not hum then return end

    local billboard, label = createBillboard(head)

    local function update()
        if not hum or hum.Health <= 0 then return end
        label.Text = "❤️ " .. math.floor(hum.Health)
    end

    update()

    local conn = hum.HealthChanged:Connect(update)

    hum.Died:Connect(function()
        cleanupHealth(player)
    end)

    character.AncestryChanged:Connect(function(_, parent)
        if not parent then
            cleanupHealth(player)
        end
    end)

    local ragdolls = Workspace:FindFirstChild("Ragdolls")
    if ragdolls then
        ragdolls.ChildAdded:Connect(function(model)
            if model == character then
                cleanupHealth(player)
            end
        end)
    end

    HEALTH_TRACKER[player] = {
        Billboard = billboard,
        Connection = conn
    }
end

--------------------------------------------------
-- PLAYER SETUP
--------------------------------------------------
local function setupPlayer(player, character)
    if player == LOCAL_PLAYER then return end

    local role = getRole(player, character)
    local color = COLORS[role]

    createHighlight(character, color)
    setupHealth(player, character)
end

--------------------------------------------------
-- TRACK PLAYERS
--------------------------------------------------
local function trackPlayer(player)
    player.CharacterAdded:Connect(function(char)
        task.wait(0.2)
        setupPlayer(player, char)
    end)

    if player.Character then
        task.spawn(function()
            task.wait(0.2)
            setupPlayer(player, player.Character)
        end)
    end
end

--------------------------------------------------
-- 🔥 RECODED LOOT SYSTEM (REPLACEMENT)
--------------------------------------------------
local ROOT = Workspace:WaitForChild("Game"):WaitForChild("Loot"):WaitForChild("drops")
local HIGHLIGHT_NAME = "ESP_Highlight"
local STATIC_NAME = "static_base"

local function applyLootESP(model)
    if not model or not model:IsA("Model") then return end
    if model:FindFirstChild(HIGHLIGHT_NAME) then return end

    local highlight = Instance.new("Highlight")
    highlight.Name = HIGHLIGHT_NAME
    highlight.Adornee = model

    highlight.FillColor = COLORS.Loot
    highlight.OutlineColor = COLORS.Loot

    highlight.FillTransparency = 0.5
    highlight.OutlineTransparency = 0
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.Parent = model
end

local function removeLootESP(model)
    local esp = model:FindFirstChild(HIGHLIGHT_NAME)
    if esp then esp:Destroy() end
end

local function isPhys(model)
    return model:IsA("Model") and model.Name:sub(1,5) == "phys_"
end

local function isStaticChild(model)
    return model:IsA("Model") and model.Parent and model.Parent.Name == STATIC_NAME
end

local function handleLoot(obj)
    if isPhys(obj) then
        applyLootESP(obj)
    elseif isStaticChild(obj) then
        applyLootESP(obj)
    end
end

local function watchStatic(static)
    for _, obj in ipairs(static:GetDescendants()) do
        if obj:IsA("Model") then
            handleLoot(obj)
        end
    end

    static.DescendantAdded:Connect(function(obj)
        if obj:IsA("Model") then
            handleLoot(obj)
        end
    end)
end

local function hookLoot()
    for _, obj in ipairs(ROOT:GetChildren()) do
        if obj:IsA("Model") then
            handleLoot(obj)
        end

        if obj.Name == STATIC_NAME then
            watchStatic(obj)
        end
    end

    ROOT.ChildAdded:Connect(function(obj)
        if obj:IsA("Model") then
            handleLoot(obj)

            if obj.Name == STATIC_NAME then
                watchStatic(obj)
            end
        end
    end)

    ROOT.ChildRemoved:Connect(function(obj)
        if obj:IsA("Model") then
            removeLootESP(obj)
        end
    end)

    task.spawn(function()
        while task.wait(1) do
            for _, obj in ipairs(ROOT:GetDescendants()) do
                if obj:IsA("Model") then
                    handleLoot(obj)
                end
            end
        end
    end)
end

--------------------------------------------------
-- RAGDOLL CLEANUP
--------------------------------------------------
local function hookRagdolls()
    local ragdolls = Workspace:FindFirstChild("Ragdolls")
    if not ragdolls then return end

    ragdolls.ChildAdded:Connect(function(model)
        task.wait(0.05)

        local h = model:FindFirstChildWhichIsA("Highlight", true)
        if h then
            h:Destroy()
        end
    end)
end

--------------------------------------------------
-- INIT
--------------------------------------------------
for _, p in ipairs(Players:GetPlayers()) do
    trackPlayer(p)
end

Players.PlayerAdded:Connect(trackPlayer)

hookLoot()
hookRagdolls()

print("[ESP + Health + Loot] Loaded successfully")