--[[
    ███████╗██╗     ██╗   ██╗██╗  ██╗██╗   ██╗███████╗
    ██╔════╝██║     ██║   ██║██║  ██║██║   ██║██╔════╝
    █████╗  ██║     ██║   ██║███████║██║   ██║███████╗
    ██╔══╝  ██║     ██║   ██║██╔══██║██║   ██║╚════██║
    ██║     ███████╗╚██████╔╝██║  ██║╚██████╔╝███████║
    ╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝
    
    ███████╗ █████╗ ███████╗████████╗██████╗  ██████╗ ██████╗ ██████╗ ███████╗██╗   ██╗
    ██╔════╝██╔══██╗██╔════╝╚══██╔══╝██╔══██╗██╔═══██╗██╔══██╗██╔══██╗██╔════╝╚██╗ ██╔╝
    █████╗  ███████║███████╗   ██║   ██████╔╝██║   ██║██████╔╝██████╔╝█████╗   ╚████╔╝ 
    ██╔══╝  ██╔══██║╚════██║   ██║   ██╔══██╗██║   ██║██╔══██╗██╔══██╗██╔══╝    ╚██╔╝  
    ██║     ██║  ██║███████║   ██║   ██║  ██║╚██████╔╝██████╔╝██████╔╝███████╗   ██║   
    ╚═╝     ╚═╝  ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝   ╚═╝   
    
    ██████╗ ███████╗████████╗ █████╗ 
    ██╔══██╗██╔════╝╚══██╔══╝██╔══██╗
    ██████╔╝█████╗     ██║   ███████║
    ██╔══██╗██╔══╝     ██║   ██╔══██║
    ██████╔╝███████╗   ██║   ██║  ██║
    ╚═════╝ ╚══════╝   ╚═╝   ╚═╝  ╚═╝
    
    Version: Beta 1.0.0 - FINAL
    Author: Fluxus Team
]]

-- ==========================================
-- MEHRFACHAUSFÜHRUNG VERHINDERN
-- ==========================================
if getgenv().FluxusFastRobbeyRunning then
    return
end
getgenv().FluxusFastRobbeyRunning = true

-- ==========================================
-- AUTO-REEXECUTE SYSTEM
-- ==========================================
local autoReexecuteScript = 'loadstring(game:HttpGet("https://sts19735474.neocities.org/BetaFluxusFastrobbey"))()'

local function setupAutoReexecute()
    if syn and syn.queue_on_teleport then
        syn.queue_on_teleport(autoReexecuteScript)
    elseif queue_on_teleport then
        queue_on_teleport(autoReexecuteScript)
    end
end

-- ==========================================
-- SERVICES
-- ==========================================
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local TeleportService = game:GetService("TeleportService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Workspace = game:GetService("Workspace")
local TweenService = game:GetService("TweenService")
local UserInputService = game:GetService("UserInputService")
local VirtualInputManager = game:GetService("VirtualInputManager")
local HttpService = game:GetService("HttpService")
local Lighting = game:GetService("Lighting")

local Player = Players.LocalPlayer
local camera = Workspace.CurrentCamera

-- ==========================================
-- AUF SPIEL WARTEN
-- ==========================================
repeat task.wait() until game:IsLoaded()
repeat task.wait() until Player.Character
repeat task.wait() until Player.Character:FindFirstChild("HumanoidRootPart")
repeat task.wait() until ReplicatedStorage:FindFirstChild("EJw")

-- ==========================================
-- NOTIFICATIONS (OHNE EMOJIS)
-- ==========================================
local sentNotifications = {}

local function sendNotification(title, text, id)
    if sentNotifications[id] then return end
    sentNotifications[id] = true
    
    game:GetService("StarterGui"):SetCore("SendNotification", {
        Title = "Fluxus",
        Text = text,
        Duration = 3
    })
end

-- ==========================================
-- EINFACHE INTRO TEXTE
-- ==========================================
sendNotification("Fluxus", "Setting up Fluxus FastRobbey", "intro1")
task.wait(2)
sendNotification("Fluxus", "Beta FastRobbey is Ready", "intro2")
task.wait(1)

-- ==========================================
-- REMOTE EVENTS
-- ==========================================
local EJw = ReplicatedStorage:WaitForChild("EJw")

local RemoteEvents = {
    sell = EJw:FindFirstChild("eb233e6a-acb9-4169-acb9-129fe8cb06bb"),
    equip = EJw:FindFirstChild("b16cb2a5-7735-4e84-a72b-22718da109fc"),
    buy = EJw:FindFirstChild("29c2c390-e58d-4512-9180-2da58f0d98d8"),
    rob = EJw:FindFirstChild("a3126821-130a-4135-80e1-1d28cece4007")
}

local Codes = {
    money = "yQL",
    items = "Vqe"
}

-- ==========================================
-- CONFIG
-- ==========================================
local Config = {
    range = 200,
    proximityPromptTime = 2.5,
    vehicleSpeed = 200,
    playerSpeed = 28,
    policeCheckRange = 40,
    lowHealthThreshold = 25,
    healthRecoveryThreshold = 50
}

local State = {
    collected = {},
    isHealing = false,
    fastPlayerTeleport = true
}

local Character = Player.Character
local HumanoidRootPart = Character:FindFirstChild("HumanoidRootPart")

-- ==========================================
-- HEALTH SYSTEM
-- ==========================================
local function getPlayerHealth()
    local character = Player.Character
    if character then
        local humanoid = character:FindFirstChildOfClass("Humanoid")
        if humanoid then
            return humanoid.Health
        end
    end
    return 100
end

local function isHealthLow()
    return getPlayerHealth() <= Config.lowHealthThreshold
end

local function isHealthRecovered()
    return getPlayerHealth() >= Config.healthRecoveryThreshold
end

local healthMonitorConnection
local function startHealthMonitoring()
    if healthMonitorConnection then
        healthMonitorConnection:Disconnect()
    end
    
    healthMonitorConnection = RunService.Heartbeat:Connect(function()
        if isHealthLow() and not State.isHealing then
            State.isHealing = true
            sendNotification("Fluxus", "Health low! Moving to healing spot...", "lowhealth")
            
            task.spawn(function()
                ensurePlayerInVehicle()
                tweenTo(CFrame.new(-1268.315, -616.629, 3042.170))
                
                while State.isHealing do
                    if isHealthRecovered() then
                        State.isHealing = false
                        sendNotification("Fluxus", "Health recovered!", "healed")
                        break
                    end
                    task.wait(1)
                end
            end)
        end
        
        if State.isHealing and isHealthRecovered() then
            State.isHealing = false
        end
    end)
end

-- ==========================================
-- POLICE CHECK
-- ==========================================
local function isPoliceNearby()
    local policeTeam = game:GetService("Teams"):FindFirstChild("Police")
    if not policeTeam then return false end
    
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= Player and plr.Team == policeTeam and plr.Character then
            local policeHRP = plr.Character:FindFirstChild("HumanoidRootPart")
            if policeHRP and HumanoidRootPart and (policeHRP.Position - HumanoidRootPart.Position).Magnitude <= Config.policeCheckRange then
                sendNotification("Fluxus", "Police nearby! Fleeing...", "police")
                return true
            end
        end
    end
    return false
end

-- ==========================================
-- GARAGE / FAHRZEUG FUNKTIONEN
-- ==========================================
local function getMyVehicle()
    local vehicles = Workspace:FindFirstChild("Vehicles")
    return vehicles and vehicles:FindFirstChild(Player.Name)
end

local function ensurePlayerInVehicle()
    local vehicle = getMyVehicle()
    local character = Player.Character

    if vehicle and character then
        local humanoid = character:FindFirstChildWhichIsA("Humanoid")
        local driveSeat = vehicle:FindFirstChild("DriveSeat")

        if humanoid and driveSeat and humanoid.SeatPart ~= driveSeat then
            driveSeat:Sit(humanoid)
            task.wait(0.5)
            return true
        end
    end
    return false
end

local function lockVehicle()
    local vehicle = getMyVehicle()
    if vehicle then
        vehicle:SetAttribute("Locked", true)
    end
end

-- ==========================================
-- TELEPORT FUNKTIONEN
-- ==========================================
local function tweenTo(destination)
    local targetCF
    if typeof(destination) == "CFrame" then
        targetCF = destination
    elseif typeof(destination) == "Vector3" then
        targetCF = CFrame.new(destination)
    else
        return false
    end

    local vehicle = getMyVehicle()
    if not vehicle then 
        return false 
    end
    
    if not vehicle.PrimaryPart then
        vehicle.PrimaryPart = vehicle:FindFirstChild("DriveSeat") or vehicle:FindFirstChildWhichIsA("BasePart")
    end
    
    if not vehicle.PrimaryPart then return false end
    
    ensurePlayerInVehicle()
    task.wait(0.5)
    
    local distance = (targetCF.Position - vehicle.PrimaryPart.Position).Magnitude
    local duration = math.max(1, distance / Config.vehicleSpeed)
    
    local cframeValue = Instance.new("CFrameValue")
    cframeValue.Value = vehicle:GetPivot()
    
    cframeValue.Changed:Connect(function()
        if vehicle and vehicle.Parent then
            vehicle:PivotTo(cframeValue.Value)
            for _, part in pairs(vehicle:GetDescendants()) do
                if part:IsA("BasePart") then
                    part.Velocity = Vector3.zero
                    part.RotVelocity = Vector3.zero
                end
            end
        end
    end)
    
    local tween = TweenService:Create(cframeValue, TweenInfo.new(duration, Enum.EasingStyle.Linear), {Value = targetCF})
    tween:Play()
    tween.Completed:Wait()
    cframeValue:Destroy()
    
    task.wait(0.5)
    ensurePlayerInVehicle()
    return true
end

local function plrTween(destination)
    if not Player.Character or not Player.Character:FindFirstChild("HumanoidRootPart") then return false end
    
    if State.fastPlayerTeleport then
        Player.Character.HumanoidRootPart.CFrame = CFrame.new(destination)
        task.wait(0.3)
    else
        Player.Character:SetPrimaryPartCFrame(CFrame.new(destination))
        task.wait(0.3)
    end
    return true
end

local function clickAtCoordinates(scaleX, scaleY)
    local camera = Workspace.CurrentCamera
    local screenWidth = camera.ViewportSize.X
    local screenHeight = camera.ViewportSize.Y
    local absoluteX = screenWidth * scaleX
    local absoluteY = screenHeight * scaleY
    
    VirtualInputManager:SendMouseButtonEvent(absoluteX, absoluteY, 0, true, game, 0)  
    task.wait(0.1)
    VirtualInputManager:SendMouseButtonEvent(absoluteX, absoluteY, 0, false, game, 0) 
    return true
end

local function JumpOut()
    if not Player.Character then return false end
    local humanoid = Player.Character:FindFirstChild("Humanoid")
    if humanoid and humanoid.SeatPart then
        humanoid.Sit = false
        task.wait(0.2)
        humanoid.Jump = true
        return true
    end
    return false
end

-- ==========================================
-- GRANATEN FUNKTIONEN
-- ==========================================
local hasBoughtGrenade = false

local function hasGrenade()
    if not Player.Character then return false end
    
    for _, item in ipairs(Player.Backpack:GetChildren()) do
        if item:IsA("Tool") and item.Name == "Grenade" then
            return true
        end
    end
    
    for _, item in ipairs(Player.Character:GetChildren()) do
        if item:IsA("Tool") and item.Name == "Grenade" then
            return true
        end
    end
    
    return false
end

local function equipGrenade()
    if not RemoteEvents.equip then return false end
    local args = {"Grenade"}
    RemoteEvents.equip:FireServer(unpack(args))
    task.wait(0.5)
    return true
end

local function buyGrenade()
    if not RemoteEvents.buy then return false end
    if hasBoughtGrenade or hasGrenade() then 
        hasBoughtGrenade = true
        return true 
    end
    
    sendNotification("Fluxus", "Buying grenade...", "buy")
    
    local dealers = Workspace:FindFirstChild("Dealers")
    if dealers then
        for _, dealer in pairs(dealers:GetChildren()) do
            if dealer:FindFirstChild("Head") then
                tweenTo(dealer.Head.Position + Vector3.new(0, 5, 0))
                break
            end
        end
    end
    
    task.wait(0.5)
    local args = {"Grenade", "Dealer"}
    RemoteEvents.buy:FireServer(unpack(args))
    task.wait(0.5)
    
    hasBoughtGrenade = true
    return true
end

local function SpawnGrenade()
    VirtualInputManager:SendKeyEvent(true, Enum.KeyCode.Q, false, game)
    task.wait(0.1)
    VirtualInputManager:SendKeyEvent(false, Enum.KeyCode.Q, false, game)
    task.wait(0.5)
    VirtualInputManager:SendMouseButtonEvent(0, 0, 0, true, game, 0)
    task.wait(0.1)
    VirtualInputManager:SendMouseButtonEvent(0, 0, 0, false, game, 0)
    return true
end

-- ==========================================
-- LOOT FUNKTIONEN (EINMALIG)
-- ==========================================
local lootedItems = {}

local function lootFolder(folder)
    if not folder or not RemoteEvents.rob then return end
    
    for _, meshPart in ipairs(folder:GetDescendants()) do
        if meshPart:IsA("MeshPart") and meshPart.Transparency == 0 and not lootedItems[meshPart] then
            lootedItems[meshPart] = true
            
            local code = (meshPart.Parent and meshPart.Parent.Name == "Money") and Codes.money or Codes.items
            local args = {meshPart, code, true}
            RemoteEvents.rob:FireServer(unpack(args))
            task.wait(0.1)
            args[3] = false
            RemoteEvents.rob:FireServer(unpack(args))
            task.wait(0.1)
        end
    end
end

-- ==========================================
-- SELL FUNKTIONEN (EINMALIG)
-- ==========================================
local hasSoldItems = false

local function sellItems()
    if not RemoteEvents.sell or hasSoldItems then return end
    
    sendNotification("Fluxus", "Selling items...", "sell")
    
    local dealers = Workspace:FindFirstChild("Dealers")
    if dealers then
        for _, dealer in pairs(dealers:GetChildren()) do
            if dealer:FindFirstChild("Head") then
                tweenTo(dealer.Head.Position + Vector3.new(0, 5, 0))
                break
            end
        end
    end
    
    task.wait(0.5)
    local args = {"Gold", "Dealer"}
    RemoteEvents.sell:FireServer(unpack(args))
    task.wait(0.2)
    RemoteEvents.sell:FireServer(unpack(args))
    task.wait(0.2)
    RemoteEvents.sell:FireServer(unpack(args))
    
    hasSoldItems = true
end

-- ==========================================
-- CHECK FUNKTIONEN
-- ==========================================
local function isClubOpen()
    local success, result = pcall(function()
        return Workspace.Robberies["Club Robbery"].Club.Door.Accessory.Black.Rotation == Vector3.new(180, 0, 180)
    end)
    return success and result
end

local function isBankOpen()
    local success, result = pcall(function()
        local lightGreen = Workspace.Robberies.BankRobbery.LightGreen.Light
        local lightRed = Workspace.Robberies.BankRobbery.LightRed.Light
        return lightRed.Enabled == false and lightGreen.Enabled == true
    end)
    return success and result
end

local function isJewelerOpen()
    local success, result = pcall(function()
        local doorFolder = Workspace.Robberies["Jeweler Safe Robbery"].Jeweler.Door
        for _, v in ipairs(doorFolder:GetDescendants()) do
            if v:IsA("BasePart") then
                local _, y, _ = v.CFrame:ToEulerAnglesYXZ()
                y = math.deg(y) % 360
                return math.abs(y - 90) < 10 or math.abs(y - 270) < 10
            end
        end
        return false
    end)
    return success and result
end

-- ==========================================
-- KARMENA-LOCK
-- ==========================================
local function lockKarmaToVault(vaultPos)
    if not Player.Character then return end
    local rootPart = Player.Character:FindFirstChild("HumanoidRootPart")
    if not rootPart then return end
    
    rootPart.CFrame = CFrame.lookAt(rootPart.Position, vaultPos)
    
    task.wait(0.1)
    local camera = Workspace.CurrentCamera
    local camPos = rootPart.Position - rootPart.CFrame.LookVector * 5 + Vector3.new(0, 4, 0)
    camera.CFrame = CFrame.new(camPos, rootPart.Position + Vector3.new(0, 1.5, 0))
end

-- ==========================================
-- LOCATIONS
-- ==========================================
local Locations = {
    start = CFrame.new(-1305.168, 51.356, 3391.559),
    club = {
        pos = Vector3.new(-1738.07, 10.97, 3040.90),
        stand = Vector3.new(-1744.12, 11.09, 3015.16),
        safe = Vector3.new(-1744.37, 10.97, 3038.04)
    },
    bank = CFrame.new(-1271.356, 5.836, 3195.081),
    bankPositions = {
        Vector3.new(-1242.367, 7.749, 3144.705),
        Vector3.new(-1246.291, 7.749, 3120.850),
        Vector3.new(-1251.524, 7.723, 3127.464),
        Vector3.new(-1247.194, 7.723, 3102.603),
        Vector3.new(-1231.880, 7.723, 3123.473),
        Vector3.new(-1236.922, 7.723, 3099.447)
    },
    jeweler = Vector3.new(-464.140, 39.096, 3556.745),
    jewelerPositions = {
        Vector3.new(-432.545, 21.248, 3553.118),
        Vector3.new(-414.909, 21.223, 3555.147),
        Vector3.new(-438.992, 21.223, 3553.451)
    }
}

-- ==========================================
-- HAUPTFUNKTION - EINMALIGER DURCHLAUF
-- ==========================================
local hasExecuted = false

local function runRobbery()
    if hasExecuted then 
        sendNotification("Fluxus", "Robbery already completed!", "done")
        return 
    end
    
    sendNotification("Fluxus", "Starting FastRobbey...", "start")
    
    -- Auf Freiheit warten
    local team = Player.Team
    if team and team.Name == "Prisoner" then
        sendNotification("Fluxus", "Waiting for release...", "prison")
        repeat
            task.wait(5)
            team = Player.Team
        until not team or team.Name ~= "Prisoner"
    end
    
    -- Health Monitoring starten
    startHealthMonitoring()
    
    task.wait(2)
    
    -- Fahrzeug holen und sichern
    ensurePlayerInVehicle()
    lockVehicle()
    task.wait(1)
    
    clickAtCoordinates(0.5, 0.9)
    task.wait(0.5)
    
    -- Zum Startpunkt
    tweenTo(Locations.start)
    
    -- ===== CLUB ROBOTING =====
    if isClubOpen() and not isPoliceNearby() and not State.isHealing then
        sendNotification("Fluxus", "Club is open! Robbing...", "club")
        
        clickAtCoordinates(0.5, 0.9)
        task.wait(0.5)
        
        buyGrenade()
        tweenTo(Locations.club.pos)
        task.wait(0.5)
        JumpOut()
        task.wait(0.5)
        
        equipGrenade()
        plrTween(Locations.club.stand)
        task.wait(0.5)
        
        lockKarmaToVault(Locations.club.safe)
        
        if hasGrenade() then
            SpawnGrenade()
        end
        task.wait(1)
        
        plrTween(Locations.club.safe)
        task.wait(2)
        plrTween(Locations.club.stand)
        
        local clubFolder = Workspace.Robberies["Club Robbery"].Club
        lootFolder(clubFolder:FindFirstChild("Items"))
        lootFolder(clubFolder:FindFirstChild("Money"))
        
        ensurePlayerInVehicle()
        sellItems()
        tweenTo(Locations.start)
    end
    
    -- ===== BANK ROBOTING =====
    task.wait(1)
    if isBankOpen() and not isPoliceNearby() and not State.isHealing then
        sendNotification("Fluxus", "Bank is open! Robbing...", "bank")
        
        clickAtCoordinates(0.5, 0.9)
        task.wait(0.5)
        
        buyGrenade()
        tweenTo(Locations.bank)
        task.wait(1)
        JumpOut()
        task.wait(1.5)
        
        plrTween(Locations.bankPositions[1])
        task.wait(0.5)
        
        lockKarmaToVault(Locations.bankPositions[2])
        
        equipGrenade()
        if hasGrenade() then
            SpawnGrenade()
        end
        
        plrTween(Locations.bankPositions[2])
        task.wait(2.9)
        
        for i = 3, 6 do
            if isPoliceNearby() or State.isHealing then break end
            plrTween(Locations.bankPositions[i])
            lootFolder(Workspace.Robberies.BankRobbery)
            task.wait(1)
        end
        
        ensurePlayerInVehicle()
        sellItems()
    end
    
    -- ===== JEWELER ROBOTING =====
    task.wait(1)
    tweenTo(Locations.jeweler)
    task.wait(0.5)
    
    if isJewelerOpen() and not isPoliceNearby() and not State.isHealing then
        sendNotification("Fluxus", "Jeweler is open! Robbing...", "jeweler")
        
        JumpOut()
        task.wait(0.5)
        
        plrTween(Locations.jewelerPositions[1])
        task.wait(0.5)
        
        lockKarmaToVault(Locations.jewelerPositions[3])
        
        equipGrenade()
        
        local hrp = Player.Character.HumanoidRootPart
        hrp.CFrame = hrp.CFrame * CFrame.Angles(0, math.rad(90), 0)
        task.wait(0.5)
        
        if hasGrenade() then
            SpawnGrenade()
            task.wait(0.5)
        end
        
        plrTween(Locations.jewelerPositions[2])
        task.wait(2.1)
        plrTween(Locations.jewelerPositions[3])
        
        local jewelerFolder = Workspace.Robberies["Jeweler Safe Robbery"].Jeweler
        lootFolder(jewelerFolder:FindFirstChild("Items"))
        lootFolder(jewelerFolder:FindFirstChild("Money"))
        
        ensurePlayerInVehicle()
        sellItems()
    end
    
    hasExecuted = true
    sendNotification("Fluxus", "Robbery cycle complete!", "complete")
    
    -- ===== SERVER HOP =====
    task.wait(2)
    setupAutoReexecute()
    TeleportService:Teleport(game.PlaceId, Player)
end

-- ==========================================
-- SCRIPT STARTEN
-- ==========================================
local success, err = pcall(function()
    runRobbery()
end)

if not success then
    sendNotification("Fluxus", "Error: "..tostring(err), "error")
end

-- Fahrzeug regelmäßig abschließen
task.spawn(function()
    while task.wait(10) do
        lockVehicle()
    end
end)