-- Delta Executor: Core Cameraman HUD (Vertically Shifted REC Layout)
local Players = game:GetService("Players")
local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")
local CoreGui = game:GetService("CoreGui")
local StarterGui = game:GetService("StarterGui")

local player = Players.LocalPlayer
local camera = workspace.CurrentCamera

-- Hide Roblox default health UI safely
task.spawn(function()
	local success
	repeat
		success = pcall(function()
			StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Health, false)
		end)
		task.wait(0.3)
	until success
end)

-- Secure UI Space
local uiParent = gethui and gethui() or CoreGui:FindFirstChild("RobloxGui") or CoreGui
if uiParent:FindFirstChild("CameramanHUD_Fixed") then
	uiParent.CameramanHUD_Fixed:Destroy()
end

local screenGui = Instance.new("ScreenGui")
screenGui.Name = "CameramanHUD_Fixed"
screenGui.ResetOnSpawn = false
screenGui.IgnoreGuiInset = true
screenGui.Parent = uiParent

local mainFrame = Instance.new("Frame")
mainFrame.Size = UDim2.new(1, 0, 1, 0)
mainFrame.BackgroundTransparency = 1
mainFrame.Parent = screenGui

-- Adjusted REC Indicator (Positioned directly under the Roblox menu icon)
local recLabel = Instance.new("TextLabel")
recLabel.Size = UDim2.new(0, 100, 0, 35)
recLabel.Position = UDim2.new(0, 25, 0, 70) -- Shifted down to clear Roblox Topbar buttons
recLabel.BackgroundTransparency = 1
recLabel.Text = "REC"
recLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
recLabel.TextSize = 20
recLabel.Font = Enum.Font.Code
recLabel.TextXAlignment = Enum.TextXAlignment.Left
recLabel.Parent = mainFrame

local recDot = Instance.new("Frame")
recDot.Size = UDim2.new(0, 10, 0, 10)
recDot.Position = UDim2.new(0, 42, 0, 12)
recDot.BackgroundColor3 = Color3.fromRGB(255, 0, 0)
recDot.BorderSizePixel = 0
recDot.Parent = recLabel

-- Error Dynamic Container (Locked to Top-Right)
local errorContainer = Instance.new("Frame")
errorContainer.Size = UDim2.new(0, 350, 0, 500)
errorContainer.Position = UDim2.new(1, -375, 0, 25)
errorContainer.BackgroundTransparency = 1
errorContainer.Parent = mainFrame

local listLayout = Instance.new("UIListLayout")
listLayout.SortOrder = Enum.SortOrder.LayoutOrder
listLayout.Padding = UDim.new(0, 4)
listLayout.HorizontalAlignment = Enum.HorizontalAlignment.Right
listLayout.Parent = errorContainer

-- Death Screen elements
local deathFrame = Instance.new("Frame")
deathFrame.Size = UDim2.new(1, 0, 1, 0)
deathFrame.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
deathFrame.Visible = false
deathFrame.ZIndex = 10
deathFrame.Parent = screenGui

local staticImage = Instance.new("ImageLabel")
staticImage.Size = UDim2.new(1, 0, 1, 0)
staticImage.Image = "rbxassetid://10849712105"
staticImage.BackgroundTransparency = 1
staticImage.ZIndex = 11
staticImage.Visible = false
staticImage.Parent = deathFrame

local deathText = Instance.new("TextLabel")
deathText.Size = UDim2.new(1, 0, 0.2, 0)
deathText.Position = UDim2.new(0, 0, 0.4, 0)
deathText.BackgroundTransparency = 1
deathText.Font = Enum.Font.Code
deathText.TextSize = 46
deathText.TextColor3 = Color3.fromRGB(255, 255, 255)
deathText.TextTransparency = 1
deathText.ZIndex = 12
deathText.Parent = deathFrame

--------------------------------------------------------------------------------
-- CORE ERROR HANDLING ENGINE
--------------------------------------------------------------------------------

local activeErrors = {}
local currentDamageId = 0 

local function createErrorLabel(textCode)
	local label = Instance.new("TextLabel")
	label.Size = UDim2.new(1, 0, 0, 25)
	label.BackgroundTransparency = 1
	label.Text = textCode
	label.TextColor3 = Color3.fromRGB(255, 0, 0)
	label.TextSize = 15
	label.Font = Enum.Font.Code
	label.TextXAlignment = Enum.TextXAlignment.Right
	label.Parent = errorContainer
	return label
end

local function addError(errorType)
	if deathFrame.Visible or activeErrors[errorType] then return end 
	activeErrors[errorType] = createErrorLabel(errorType)
end

local function removeError(errorType)
	local label = activeErrors[errorType]
	if not label then return end
	
	activeErrors[errorType] = nil
	label.TextColor3 = Color3.fromRGB(0, 255, 0) 
	
	task.delay(0.5, function()
		local fade = TweenService:Create(label, TweenInfo.new(0.4), {TextTransparency = 1})
		fade:Play()
		fade.Completed:Connect(function()
			label:Destroy()
		end)
	end)
end

--------------------------------------------------------------------------------
-- SYSTEM PROCESSES, REBOOTS & MONITORING
--------------------------------------------------------------------------------

-- Blinking REC dot
coroutine.wrap(function()
	while true do
		recDot.Visible = not recDot.Visible
		task.wait(0.6)
	end
end)()

-- Cybernetic Boot Glitch Sequence
local function runOnlineGlitchEffect()
	local glitches = {"DEF_SYS_", "ERR_REBOOT_", "|||||||||", "CONN_EST_", "SYS_RECOVERY_"}
	deathText.TextColor3 = Color3.fromRGB(255, 0, 0) 
	deathText.TextTransparency = 0
	
	for i = 1, 15 do
		deathText.Text = glitches[math.random(1, #glitches)] .. tostring(math.random(1000, 9999))
		task.wait(0.04)
	end
	
	deathText.Text = "CAMERA ONLINE"
	deathText.TextColor3 = Color3.fromRGB(0, 255, 0) 
end

local function monitorPlayer(character)
	local humanoid = character:WaitForChild("Humanoid", 10)
	if not humanoid then return end
	
	local lastHealth = humanoid.Health
	
	local function healthUpdate(currentHealth)
		if currentHealth <= 0 then return end
		
		-- Manage Flat Health Dynamic Warnings
		if currentHealth <= 50 then
			addError("HARDWARE DISCONNECT")
		else
			removeError("HARDWARE DISCONNECT")
		end
		
		if currentHealth <= 25 then
			addError("PRIMARY LENS HARDWARE DAMAGED")
		else
			removeError("PRIMARY LENS HARDWARE DAMAGED")
		end
		
		-- Handle CRITICAL DAMAGE Triggering and Reset Timer
		if currentHealth ~= lastHealth then
			currentDamageId = currentDamageId + 1
			local localizedId = currentDamageId
			
			addError("CRITICAL DAMAGE")
			
			task.delay(3, function()
				if localizedId == currentDamageId then
					removeError("CRITICAL DAMAGE")
				end
			end)
		end
		
		lastHealth = currentHealth
	end

	humanoid.HealthChanged:Connect(healthUpdate)
	healthUpdate(humanoid.Health) 
	
	humanoid.Died:Connect(function()
		currentDamageId = currentDamageId + 1
		for err, label in pairs(activeErrors) do
			label:Destroy()
		end
		activeErrors = {}
		
		mainFrame.Visible = false
		deathFrame.Visible = true
		staticImage.Visible = true
		deathText.TextTransparency = 1
		
		task.wait(1)
		staticImage.Visible = false
		deathText.Text = "CAMERA OFFLINE"
		deathText.TextColor3 = Color3.fromRGB(255, 255, 255) 
		deathText.TextTransparency = 0
	end)
end

--------------------------------------------------------------------------------
-- PROXIMITY SIGNAL SYSTEM
--------------------------------------------------------------------------------

task.spawn(function()
	while true do
		task.wait(0.3) 
		
		if not deathFrame.Visible and player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
			local myRoot = player.Character.HumanoidRootPart
			local closestDistance = math.huge
			
			for _, obj in pairs(workspace:GetDescendants()) do
				if obj:IsA("Humanoid") and obj.Parent and obj.Parent ~= player.Character then
					local targetRoot = obj.Parent:FindFirstChild("HumanoidRootPart")
					if targetRoot then
						local dist = (myRoot.Position - targetRoot.Position).Magnitude
						if dist < closestDistance then
							closestDistance = dist
						end
					end
				end
			end
			
			if closestDistance >= 35 then
				addError("RECORDING ERROR")
			else
				removeError("RECORDING ERROR")
			end
		end
	end
end)

--------------------------------------------------------------------------------
-- RUNTIME INITIALIZATION
--------------------------------------------------------------------------------

player.CharacterAdded:Connect(function(character)
	if deathFrame.Visible then
		task.wait(1.5)
		runOnlineGlitchEffect() 
		task.wait(1.2)
		
		local fade = TweenService:Create(deathFrame, TweenInfo.new(0.5), {BackgroundTransparency = 1})
		local textFade = TweenService:Create(deathText, TweenInfo.new(0.5), {TextTransparency = 1})
		fade:Play()
		textFade:Play()
		
		fade.Completed:Connect(function()
			deathFrame.Visible = false
			deathFrame.BackgroundTransparency = 0
			mainFrame.Visible = true
		end)
	end
	monitorPlayer(character)
end)

if player.Character then
	monitorPlayer(player.Character)
end

-- Fallback loop for Zoom (Transmission Error)
RunService.RenderStepped:Connect(function()
	if deathFrame.Visible or not player.Character then return end
	local isFirstPerson = (camera.CFrame.Position - camera.Focus.Position).Magnitude < 1.0
	if not isFirstPerson then
		addError("TRANSMISSION ERROR")
	else
		removeError("TRANSMISSION ERROR")
	end
end)