-- ============================================================
-- Valentino Stealer - Steal a Brainrot
-- ============================================================

local Players = game:GetService("Players")
local Workspace = game:GetService("Workspace")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ProximityPromptService = game:GetService("ProximityPromptService")
local RunService = game:GetService("RunService")

local LocalPlayer = Players.LocalPlayer
local Packages = ReplicatedStorage:WaitForChild("Packages")
local Datas = ReplicatedStorage:WaitForChild("Datas")
local Shared = ReplicatedStorage:WaitForChild("Shared")

local Synchronizer = require(Packages:WaitForChild("Synchronizer"))
local AnimalsData = require(Datas:WaitForChild("Animals"))
local AnimalsShared = require(Shared:WaitForChild("Animals"))

local TARGET_NAME = "Valentino"   -- Exact display name of the animal
local AUTO_STEAL_PROX_RADIUS = 25 -- Distance to trigger steal

-- ===== Cache for prompts =====
local PromptMemoryCache = {}

-- ===== Helper: Find a ProximityPrompt for an animal =====
local function findProximityPromptForAnimal(animalData)
    if not animalData then return nil end

    local cachedPrompt = PromptMemoryCache[animalData.uid]
    if cachedPrompt and cachedPrompt.Parent then
        return cachedPrompt
    end

    local plot = Workspace.Plots:FindFirstChild(animalData.plot)
    if not plot then return nil end

    local podiums = plot:FindFirstChild("AnimalPodiums")
    if not podiums then return nil end

    local podium = podiums:FindFirstChild(animalData.slot)
    if not podium then return nil end

    local base = podium:FindFirstChild("Base")
    if not base then return nil end

    local spawn = base:FindFirstChild("Spawn")
    if not spawn then return nil end

    local attach = spawn:FindFirstChild("PromptAttachment")
    if not attach then return nil end

    for _, p in ipairs(attach:GetChildren()) do
        if p:IsA("ProximityPrompt") then
            PromptMemoryCache[animalData.uid] = p
            return p
        end
    end

    return nil
end

-- ===== Helper: Get animal world position =====
local function getAnimalPosition(animalData)
    local plot = Workspace.Plots:FindFirstChild(animalData.plot)
    if not plot then return nil end

    local podiums = plot:FindFirstChild("AnimalPodiums")
    if not podiums then return nil end

    local podium = podiums:FindFirstChild(animalData.slot)
    if not podium then return nil end

    return podium:GetPivot().Position
end

-- ===== Helper: Check if animal belongs to you =====
local function isMyBaseAnimal(animalData)
    if not animalData or not animalData.plot then return false end

    local plot = Workspace.Plots:FindFirstChild(animalData.plot)
    if not plot then return false end

    local channel = Synchronizer:Get(plot.Name)
    if channel then
        local owner = channel:Get("Owner")
        if owner then
            if typeof(owner) == "Instance" and owner:IsA("Player") then
                return owner.UserId == LocalPlayer.UserId
            elseif typeof(owner) == "table" and owner.UserId then
                return owner.UserId == LocalPlayer.UserId
            elseif typeof(owner) == "Instance" then
                return owner == LocalPlayer
            end
        end
    end

    return false
end

-- ===== Helper: Build and cache steal callbacks =====
local InternalStealCache = {}

local function buildStealCallbacks(prompt)
    if InternalStealCache[prompt] then return end

    local data = {
        holdCallbacks = {},
        triggerCallbacks = {},
        ready = true,
    }

    local ok, conns = pcall(getconnections, prompt.PromptButtonHoldBegan)
    if ok and type(conns) == "table" then
        for _, conn in ipairs(conns) do
            if type(conn.Function) == "function" then
                table.insert(data.holdCallbacks, conn.Function)
            end
        end
    end

    local ok2, conns2 = pcall(getconnections, prompt.Triggered)
    if ok2 and type(conns2) == "table" then
        for _, conn in ipairs(conns2) do
            if type(conn.Function) == "function" then
                table.insert(data.triggerCallbacks, conn.Function)
            end
        end
    end

    if #data.holdCallbacks > 0 or #data.triggerCallbacks > 0 then
        InternalStealCache[prompt] = data
    end
end

-- ===== Execute steal (non‑blocking) =====
local function executeStealAsync(prompt)
    local data = InternalStealCache[prompt]
    if not data or not data.ready then return false end

    data.ready = false

    task.spawn(function()
        if #data.holdCallbacks > 0 then
            for _, fn in ipairs(data.holdCallbacks) do
                task.spawn(fn)
            end
        end

        task.wait(1.3)

        if #data.triggerCallbacks > 0 then
            for _, fn in ipairs(data.triggerCallbacks) do
                task.spawn(fn)
            end
        end

        task.wait(0.1)
        data.ready = true
    end)

    return true
end

-- ===== Attempt to steal =====
local function attemptSteal(prompt)
    if not prompt or not prompt.Parent then return false end

    buildStealCallbacks(prompt)
    if not InternalStealCache[prompt] then return false end

    return executeStealAsync(prompt)
end

-- ===== Scan all plots for Valentino =====
local function findValentino()
    local plots = Workspace:FindFirstChild("Plots")
    if not plots then return nil end

    for _, plot in ipairs(plots:GetChildren()) do
        local channel = Synchronizer:Get(plot.Name)
        if not channel then continue end

        local animalList = channel:Get("AnimalList")
        if not animalList then continue end

        for slot, animalData in pairs(animalList) do
            if type(animalData) == "table" then
                local animalName = animalData.Index
                local animalInfo = AnimalsData[animalName]
                if not animalInfo then continue end

                local displayName = animalInfo.DisplayName or animalName
                if displayName == TARGET_NAME then
                    return {
                        name = displayName,
                        plot = plot.Name,
                        slot = tostring(slot),
                        uid = plot.Name .. "_" .. tostring(slot),
                        animalData = animalData,
                    }
                end
            end
        end
    end

    return nil
end

-- ===== Teleport to animal =====
local function teleportToAnimal(animal)
    local character = LocalPlayer.Character
    if not character then return false end

    local hrp = character:FindFirstChild("HumanoidRootPart")
    if not hrp then return false end

    local pos = getAnimalPosition(animal)
    if not pos then return false end

    hrp.CFrame = CFrame.new(pos + Vector3.new(0, 2, 0)) -- lift slightly
    return true
end

-- ===== Main steal loop =====
local function stealValentino()
    local target = findValentino()
    if not target then
        warn("[Valentino Stealer] No Valentino found.")
        return false
    end

    -- Skip if it's your own base
    if isMyBaseAnimal(target) then
        warn("[Valentino Stealer] Valentino is on your base, skipping.")
        return false
    end

    -- Teleport
    if not teleportToAnimal(target) then
        warn("[Valentino Stealer] Failed to teleport.")
        return false
    end

    -- Wait a moment to arrive
    task.wait(0.3)

    -- Find and fire prompt
    local prompt = findProximityPromptForAnimal(target)
    if not prompt then
        warn("[Valentino Stealer] Could not find proximity prompt.")
        return false
    end

    -- Execute steal
    local success = attemptSteal(prompt)
    if success then
        print("[Valentino Stealer] Successfully stole Valentino!")
    else
        warn("[Valentino Stealer] Steal execution failed.")
    end

    return success
end

-- ===== Execute =====
stealValentino()