--!strict
--[[
	SimpleAdmin v4 — compact shell + live theme engine
	Client script. Run in an executor, or as a LocalScript under StarterPlayerScripts.

	Window is 280x356 by default. Header drags. Minimize drops to a 46px orb.
	The Theme page re-colours everything live: accent RGB, background RGB,
	window opacity, row opacity, corner radius, UI scale, blur.

	Server commands are not here on purpose — this build is client-side only.
]]

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Lighting = game:GetService("Lighting")
local TweenService = game:GetService("TweenService")
local HttpService = game:GetService("HttpService")
local TeleportService = game:GetService("TeleportService")

local player = Players.LocalPlayer
local setOpen
local refreshTabHighlight
local playerGui = player:WaitForChild("PlayerGui")

local W, H = 280, 356

-- ─────────────────────────────────────────────────────────────── theme
local DEFAULTS = {
	Accent = Color3.fromRGB(107, 139, 255),
	Panel = Color3.fromRGB(20, 24, 33),
	Row = Color3.fromRGB(32, 38, 52),
	Stroke = Color3.fromRGB(255, 255, 255),
	Text = Color3.fromRGB(232, 238, 250),
	Dim = Color3.fromRGB(132, 144, 168),
	PanelTransparency = 0.06,
	RowTransparency = 0.55,
	Corner = 8,
	Scale = 1,
}

local Theme = {}
for k, v in pairs(DEFAULTS) do
	Theme[k] = v
end

local themeRegistry = {}
local switchRedraw = {}
local uiScale = nil

local function applyKind(obj, kind)
	if kind == "window" then
		obj.BackgroundColor3 = Theme.Panel
		obj.BackgroundTransparency = Theme.PanelTransparency
	elseif kind == "row" then
		obj.BackgroundColor3 = Theme.Row
		obj.BackgroundTransparency = Theme.RowTransparency
	elseif kind == "button" then
		obj.BackgroundColor3 = Theme.Row
		obj.BackgroundTransparency = math.clamp(Theme.RowTransparency + 0.25, 0, 0.98)
	elseif kind == "text" then
		obj.TextColor3 = Theme.Text
	elseif kind == "dim" then
		obj.TextColor3 = Theme.Dim
	elseif kind == "accent" then
		obj.TextColor3 = Theme.Accent
	elseif kind == "accentFill" then
		obj.BackgroundColor3 = Theme.Accent
		obj.BackgroundTransparency = 0
	elseif kind == "accentSoft" then
		obj.BackgroundColor3 = Theme.Accent
		obj.BackgroundTransparency = 0.72
	elseif kind == "track" then
		obj.BackgroundColor3 = Theme.Text
		obj.BackgroundTransparency = 0.86
	elseif kind == "scroll" then
		obj.ScrollBarImageColor3 = Theme.Accent
	end
end

local function applyTheme()
	for _, entry in ipairs(themeRegistry) do
		pcall(applyKind, entry.obj, entry.kind)

		local cornerInst = entry.obj:FindFirstChildOfClass("UICorner")
		if cornerInst then
			cornerInst.CornerRadius = UDim.new(0, Theme.Corner)
		end

		local strokeInst = entry.obj:FindFirstChildOfClass("UIStroke")
		if strokeInst then
			strokeInst.Color = Theme.Stroke
			strokeInst.Transparency = 0.82
		end
	end

	for _, redraw in ipairs(switchRedraw) do
		pcall(redraw)
	end

	if uiScale then
		uiScale.Scale = Theme.Scale
	end

	if refreshTabHighlight then
		refreshTabHighlight()
	end
end

-- ─────────────────────────────────────────────────────────────── helpers
local function reg(obj, kind)
	themeRegistry[#themeRegistry + 1] = { obj = obj, kind = kind }
	if kind then
		applyKind(obj, kind)
	end
	return obj
end

local function corner(obj, r)
	local c = Instance.new("UICorner")
	c.CornerRadius = UDim.new(0, r or Theme.Corner)
	c.Parent = obj
	return c
end

local function stroke(obj, thickness, transparency)
	local s = Instance.new("UIStroke")
	s.Thickness = thickness or 1
	s.Transparency = transparency or 0.82
	s.Color = Theme.Stroke
	s.Parent = obj
	return s
end

local function new(class, props, parent)
	local obj = Instance.new(class)
	for key, value in pairs(props) do
		obj[key] = value
	end
	obj.Parent = parent
	return obj
end

local function round(x)
	return math.floor(x + 0.5)
end

-- ─────────────────────────────────────────────────────────────── root
local screen = Instance.new("ScreenGui")
screen.Name = "SimpleAdminV4"
screen.ResetOnSpawn = false
screen.IgnoreGuiInset = true
screen.ZIndexBehavior = Enum.ZIndexBehavior.Sibling

do
	local parentOk, parent = pcall(function()
		if gethui then
			return gethui()
		end
		return nil
	end)
	if parentOk and parent then
		screen.Parent = parent
	else
		screen.Parent = playerGui
	end
end

-- window
local main = new("Frame", {
	Name = "Window",
	AnchorPoint = Vector2.new(0, 0),
	Position = UDim2.fromOffset(240, 160),
	Size = UDim2.fromOffset(W, H),
	BackgroundColor3 = Theme.Panel,
	BackgroundTransparency = Theme.PanelTransparency,
	BorderSizePixel = 0,
	ClipsDescendants = false,
	Active = true,
}, screen)
corner(main, Theme.Corner)
stroke(main, 1, 0.8)
reg(main, "window")

uiScale = Instance.new("UIScale")
uiScale.Scale = 1
uiScale.Parent = main

-- header
local header = new("Frame", {
	Name = "Header",
	Size = UDim2.new(1, 0, 0, 34),
	BackgroundTransparency = 1,
}, main)

local dot = new("Frame", {
	Size = UDim2.fromOffset(7, 7),
	Position = UDim2.fromOffset(12, 14),
	BackgroundColor3 = Theme.Accent,
	BorderSizePixel = 0,
}, header)
corner(dot, 999)
reg(dot, "accentFill")

local title = new("TextLabel", {
	Size = UDim2.new(1, -80, 1, 0),
	Position = UDim2.fromOffset(26, 0),
	BackgroundTransparency = 1,
	Font = Enum.Font.GothamBold,
	Text = "SIMPLE ADMIN",
	TextSize = 10,
	TextXAlignment = Enum.TextXAlignment.Left,
	TextColor3 = Theme.Text,
}, header)
reg(title, "text")

local function headerButton(text, xOffset)
	local btn = new("TextButton", {
		Size = UDim2.fromOffset(22, 22),
		Position = UDim2.new(1, xOffset, 0, 6),
		BackgroundColor3 = Theme.Row,
		BackgroundTransparency = 0.7,
		BorderSizePixel = 0,
		Font = Enum.Font.GothamBold,
		Text = text,
		TextSize = 11,
		TextColor3 = Theme.Dim,
		AutoButtonColor = false,
	}, header)
	corner(btn, 5)
	reg(btn, "button")
	reg(btn, "dim")
	return btn
end

local minBtn = headerButton("–", -56)
local closeBtn = headerButton("×", -30)

-- tabs
local tabBar = new("Frame", {
	Name = "Tabs",
	Size = UDim2.new(1, 0, 0, 26),
	Position = UDim2.fromOffset(0, 34),
	BackgroundTransparency = 1,
}, main)

local tabs = {}
local tabNames = { "Home", "Theme", "Config" }

for index, name in ipairs(tabNames) do
	local btn = new("TextButton", {
		Name = name,
		Size = UDim2.new(1 / 3, -8, 1, -6),
		Position = UDim2.new((index - 1) / 3, 4, 0, 3),
		BackgroundColor3 = Theme.Row,
		BackgroundTransparency = 0.75,
		BorderSizePixel = 0,
		Font = Enum.Font.Gotham,
		Text = name,
		TextSize = 10,
		TextColor3 = Theme.Dim,
		AutoButtonColor = false,
	}, tabBar)
	corner(btn, 5)
	reg(btn, "button")
	tabs[index] = btn
end

-- page containers
local pageArea = new("Frame", {
	Name = "Pages",
	Size = UDim2.new(1, 0, 1, -60),
	Position = UDim2.fromOffset(0, 60),
	BackgroundTransparency = 1,
	ClipsDescendants = true,
}, main)

local function makePage()
	local scroll = new("ScrollingFrame", {
		Size = UDim2.fromScale(1, 1),
		BackgroundTransparency = 1,
		BorderSizePixel = 0,
		ScrollBarThickness = 2,
		ScrollBarImageColor3 = Theme.Accent,
		CanvasSize = UDim2.new(0, 0, 0, 0),
		AutomaticCanvasSize = Enum.AutomaticSize.Y,
		ScrollingDirection = Enum.ScrollingDirection.Y,
		Visible = false,
	}, pageArea)
	reg(scroll, "scroll")

	new("UIPadding", {
		PaddingLeft = UDim.new(0, 9),
		PaddingRight = UDim.new(0, 9),
		PaddingTop = UDim.new(0, 4),
		PaddingBottom = UDim.new(0, 10),
	}, scroll)

	new("UIListLayout", {
		Padding = UDim.new(0, 5),
		SortOrder = Enum.SortOrder.LayoutOrder,
	}, scroll)

	return scroll
end

local pageHome = makePage()
local pageTheme = makePage()
local pageConfig = makePage()

local pages = { pageHome, pageTheme, pageConfig }

local activeTab = 1
local function selectTab(index)
	activeTab = index
	for i, page in ipairs(pages) do
		page.Visible = (i == index)
	end
	for i, btn in ipairs(tabs) do
		btn.TextColor3 = (i == index) and Theme.Accent or Theme.Dim
		btn.BackgroundTransparency = (i == index) and 0.78 or 0.9
	end
end

for index, btn in ipairs(tabs) do
	btn.MouseButton1Click:Connect(function()
		selectTab(index)
	end)
end

refreshTabHighlight = function()
	selectTab(activeTab)
end

-- ─────────────────────────────────────────────────────────────── widgets
local function section(parent, text)
	local label = new("TextLabel", {
		Size = UDim2.new(1, 0, 0, 16),
		BackgroundTransparency = 1,
		Font = Enum.Font.GothamBold,
		Text = text,
		TextSize = 8,
		TextXAlignment = Enum.TextXAlignment.Left,
		TextColor3 = Theme.Dim,
	}, parent)
	reg(label, "dim")
	return label
end

local function makeSlider(parent, text, minValue, maxValue, initial, step, onChange)
	local row = new("Frame", {
		Size = UDim2.new(1, 0, 0, 26),
		BackgroundTransparency = 1,
	}, parent)

	local label = new("TextLabel", {
		Size = UDim2.new(1, -46, 0, 12),
		BackgroundTransparency = 1,
		Font = Enum.Font.Gotham,
		Text = text,
		TextSize = 10,
		TextXAlignment = Enum.TextXAlignment.Left,
		TextColor3 = Theme.Dim,
	}, row)
	reg(label, "dim")

	local valueLabel = new("TextLabel", {
		Size = UDim2.fromOffset(46, 12),
		Position = UDim2.new(1, -46, 0, 0),
		BackgroundTransparency = 1,
		Font = Enum.Font.Code,
		Text = tostring(initial),
		TextSize = 10,
		TextXAlignment = Enum.TextXAlignment.Right,
		TextColor3 = Theme.Accent,
	}, row)
	reg(valueLabel, "accent")

	local bar = new("Frame", {
		Size = UDim2.new(1, 0, 0, 4),
		Position = UDim2.new(0, 0, 1, -8),
		BackgroundColor3 = Theme.Text,
		BackgroundTransparency = 0.86,
		BorderSizePixel = 0,
	}, row)
	corner(bar, 2)
	reg(bar, "track")

	local fill = new("Frame", {
		Size = UDim2.fromScale(0, 1),
		BackgroundColor3 = Theme.Accent,
		BorderSizePixel = 0,
	}, bar)
	corner(fill, 2)
	reg(fill, "accentFill")

	local knob = new("Frame", {
		AnchorPoint = Vector2.new(0.5, 0.5),
		Size = UDim2.fromOffset(9, 9),
		Position = UDim2.new(0, 0, 0.5, 0),
		BackgroundColor3 = Theme.Accent,
		BorderSizePixel = 0,
		ZIndex = 3,
	}, bar)
	corner(knob, 999)
	reg(knob, "accentFill")

	local value = initial

	local function render()
		local alpha = (maxValue > minValue) and ((value - minValue) / (maxValue - minValue)) or 0
		fill.Size = UDim2.fromScale(alpha, 1)
		knob.Position = UDim2.new(alpha, 0, 0.5, 0)
		if step >= 1 then
			valueLabel.Text = tostring(round(value))
		else
			valueLabel.Text = string.format("%.2f", value)
		end
	end

	local dragging = false

	local function setFromX(absX)
		local width = math.max(bar.AbsoluteSize.X, 1)
		local alpha = math.clamp((absX - bar.AbsolutePosition.X) / width, 0, 1)
		local raw = minValue + alpha * (maxValue - minValue)
		if step >= 1 then
			raw = round(raw / step) * step
		end
		value = math.clamp(raw, minValue, maxValue)
		render()
		if onChange then
			onChange(value)
		end
	end

	bar.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch then
			dragging = true
			setFromX(input.Position.X)
		end
	end)

	UserInputService.InputChanged:Connect(function(input)
		if not dragging then
			return
		end
		if input.UserInputType == Enum.UserInputType.MouseMovement
			or input.UserInputType == Enum.UserInputType.Touch then
			setFromX(input.Position.X)
		end
	end)

	UserInputService.InputEnded:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch then
			dragging = false
		end
	end)

	render()

	return {
		get = function()
			return value
		end,
		set = function(nextValue)
			value = math.clamp(nextValue, minValue, maxValue)
			render()
		end,
	}
end

local function makeToggle(parent, text, initial, onChange)
	local row = new("Frame", {
		Size = UDim2.new(1, 0, 0, 24),
		BackgroundTransparency = 1,
	}, parent)

	local label = new("TextLabel", {
		Size = UDim2.new(1, -42, 1, 0),
		BackgroundTransparency = 1,
		Font = Enum.Font.Gotham,
		Text = text,
		TextSize = 10,
		TextXAlignment = Enum.TextXAlignment.Left,
		TextColor3 = Theme.Text,
	}, row)
	reg(label, "text")

	local track = new("Frame", {
		Size = UDim2.fromOffset(26, 13),
		Position = UDim2.new(1, -26, 0.5, -6.5),
		BackgroundColor3 = Theme.Row,
		BorderSizePixel = 0,
	}, row)
	corner(track, 999)

	local knob = new("Frame", {
		Size = UDim2.fromOffset(9, 9),
		Position = UDim2.new(0, 2, 0.5, -4.5),
		BackgroundColor3 = Theme.Dim,
		BorderSizePixel = 0,
	}, track)
	corner(knob, 999)

	local hit = new("TextButton", {
		Size = UDim2.fromScale(1, 1),
		BackgroundTransparency = 1,
		Text = "",
		AutoButtonColor = false,
		ZIndex = 4,
	}, row)

	local state = initial

	local function redraw()
		if state then
			track.BackgroundColor3 = Theme.Accent
			track.BackgroundTransparency = 0
			knob.Position = UDim2.new(1, -11, 0.5, -4.5)
			knob.BackgroundColor3 = Color3.new(1, 1, 1)
			label.TextColor3 = Theme.Text
		else
			track.BackgroundColor3 = Theme.Row
			track.BackgroundTransparency = math.clamp(Theme.RowTransparency - 0.1, 0, 1)
			knob.Position = UDim2.new(0, 2, 0.5, -4.5)
			knob.BackgroundColor3 = Theme.Dim
			label.TextColor3 = Theme.Dim
		end
	end

	switchRedraw[#switchRedraw + 1] = redraw
	redraw()

	hit.MouseButton1Click:Connect(function()
		state = not state
		redraw()
		if onChange then
			onChange(state)
		end
	end)

	return {
		get = function()
			return state
		end,
		set = function(nextState)
			state = nextState
			redraw()
		end,
	}
end

local function makeButton(parent, text, onClick, accent)
	local btn = new("TextButton", {
		Size = UDim2.new(1, 0, 0, 24),
		BackgroundColor3 = Theme.Row,
		BackgroundTransparency = accent and 0 or (Theme.RowTransparency + 0.25),
		BorderSizePixel = 0,
		Font = Enum.Font.Gotham,
		Text = text,
		TextSize = 10,
		TextColor3 = accent and Theme.Accent or Theme.Text,
		AutoButtonColor = false,
	}, parent)
	corner(btn, 5)
	if accent then
		reg(btn, "accentSoft")
		reg(btn, "accent")
	else
		reg(btn, "button")
		reg(btn, "text")
	end
	btn.MouseButton1Click:Connect(function()
		if onClick then
			onClick()
		end
	end)
	return btn
end

-- ─────────────────────────────────────────────────────────────── behavior
local State = {
	Speed = 32,
	JumpPower = 100,
	Fly = false,
	Noclip = false,
	InfiniteJump = false,
	AntiAfk = false,
	Freeze = false,
	FullBright = false,
	NoFog = false,
}

local connections = {}

local function track(name, connection)
	if connections[name] then
		connections[name]:Disconnect()
	end
	connections[name] = connection
end

local function untrack(name)
	if connections[name] then
		connections[name]:Disconnect()
		connections[name] = nil
	end
end

local function humanoid()
	local character = player.Character
	if not character then
		return nil
	end
	return character:FindFirstChildOfClass("Humanoid")
end

local function rootPart()
	local character = player.Character
	if not character then
		return nil
	end
	return character:FindFirstChild("HumanoidRootPart")
end

local function applyMovement()
	local hum = humanoid()
	if not hum then
		return
	end
	if State.Freeze then
		hum.WalkSpeed = 0
		hum.UseJumpPower = true
		hum.JumpPower = 0
	else
		hum.WalkSpeed = State.Speed
		hum.UseJumpPower = true
		hum.JumpPower = State.JumpPower
	end
end

-- fly
local flyBody, flyGyro, flyConnection

local function stopFly()
	if flyConnection then
		flyConnection:Disconnect()
		flyConnection = nil
	end
	if flyBody then
		flyBody:Destroy()
		flyBody = nil
	end
	if flyGyro then
		flyGyro:Destroy()
		flyGyro = nil
	end
	local hum = humanoid()
	if hum then
		hum.PlatformStand = false
	end
end

local function startFly()
	stopFly()
	local hum = humanoid()
	local hrp = rootPart()
	if not (hum and hrp) then
		return false
	end

	hum.PlatformStand = true

	local body = Instance.new("BodyVelocity")
	body.Name = "SA_Fly"
	body.MaxForce = Vector3.new(1e5, 1e5, 1e5)
	body.Velocity = Vector3.zero
	body.Parent = hrp

	local gyro = Instance.new("BodyGyro")
	gyro.Name = "SA_FlyGyro"
	gyro.MaxTorque = Vector3.new(1e5, 1e5, 1e5)
	gyro.P = 8000
	gyro.D = 500
	gyro.CFrame = hrp.CFrame
	gyro.Parent = hrp

	flyBody, flyGyro = body, gyro

	flyConnection = RunService.RenderStepped:Connect(function(dt)
		if not (flyBody and flyGyro) then
			return
		end
		local camera = workspace.CurrentCamera
		if not camera then
			return
		end

		local direction = Vector3.zero
		if UserInputService:IsKeyDown(Enum.KeyCode.W) then
			direction += camera.CFrame.LookVector
		end
		if UserInputService:IsKeyDown(Enum.KeyCode.S) then
			direction -= camera.CFrame.LookVector
		end
		if UserInputService:IsKeyDown(Enum.KeyCode.D) then
			direction += camera.CFrame.RightVector
		end
		if UserInputService:IsKeyDown(Enum.KeyCode.A) then
			direction -= camera.CFrame.RightVector
		end
		if UserInputService:IsKeyDown(Enum.KeyCode.Space) then
			direction += Vector3.yAxis
		end
		if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then
			direction -= Vector3.yAxis
		end
		if direction.Magnitude > 0 then
			direction = direction.Unit
		end

		local target = direction * (State.Speed * 2)
		local alpha = 1 - math.exp(-dt * 14)
		flyBody.Velocity = flyBody.Velocity:Lerp(target, alpha)
		flyGyro.CFrame = camera.CFrame
	end)

	return true
end

-- noclip
local function setNoclip(enabled)
	untrack("noclip")
	if not enabled then
		local character = player.Character
		if character then
			for _, part in ipairs(character:GetDescendants()) do
				if part:IsA("BasePart") then
					part.CanCollide = true
				end
			end
		end
		return
	end

	local function sweep()
		local character = player.Character
		if not character then
			return
		end
		for _, part in ipairs(character:GetDescendants()) do
			if part:IsA("BasePart") and part.CanCollide then
				part.CanCollide = false
			end
		end
	end

	sweep()
	track("noclip", RunService.Stepped:Connect(sweep))
end

-- infinite jump
local function setInfiniteJump(enabled)
	untrack("infjump")
	if not enabled then
		return
	end
	track("infjump", UserInputService.JumpRequest:Connect(function()
		local hum = humanoid()
		if hum and hum:GetState() ~= Enum.HumanoidStateType.Dead then
			hum:ChangeState(Enum.HumanoidStateType.Jumping)
		end
	end))
end

-- anti-afk
local function setAntiAfk(enabled)
	if not enabled then
		untrack("afk")
		return
	end
	untrack("afk")
	local ok = pcall(function()
		local virtualUser = game:GetService("VirtualUser")
		track("afk", player.Idled:Connect(function()
			pcall(function()
				virtualUser:CaptureController()
				virtualUser:ClickButton2(Vector2.new())
			end)
		end))
	end)
	if not ok then
		State.AntiAfk = false
	end
end

-- lighting
local lightingBackup = {
	FullBright = nil,
	NoFog = nil,
}

local function setFullBright(enabled)
	if enabled then
		if not lightingBackup.FullBright then
			lightingBackup.FullBright = {
				Brightness = Lighting.Brightness,
				Ambient = Lighting.Ambient,
				OutdoorAmbient = Lighting.OutdoorAmbient,
				ClockTime = Lighting.ClockTime,
				GlobalShadows = Lighting.GlobalShadows,
			}
		end
		Lighting.Brightness = 2
		Lighting.Ambient = Color3.new(1, 1, 1)
		Lighting.OutdoorAmbient = Color3.new(1, 1, 1)
		Lighting.ClockTime = 14
		Lighting.GlobalShadows = false
	else
		local backup = lightingBackup.FullBright
		if backup then
			Lighting.Brightness = backup.Brightness
			Lighting.Ambient = backup.Ambient
			Lighting.OutdoorAmbient = backup.OutdoorAmbient
			Lighting.ClockTime = backup.ClockTime
			Lighting.GlobalShadows = backup.GlobalShadows
			lightingBackup.FullBright = nil
		end
	end
end

local function setNoFog(enabled)
	if enabled then
		if not lightingBackup.NoFog then
			lightingBackup.NoFog = {
				FogStart = Lighting.FogStart,
				FogEnd = Lighting.FogEnd,
				FogColor = Lighting.FogColor,
			}
		end
		Lighting.FogStart = 1e8
		Lighting.FogEnd = 1e8
	else
		local backup = lightingBackup.NoFog
		if backup then
			Lighting.FogStart = backup.FogStart
			Lighting.FogEnd = backup.FogEnd
			Lighting.FogColor = backup.FogColor
			lightingBackup.NoFog = nil
		end
	end
end

-- actions
local function teleportToMouse()
	local camera = workspace.CurrentCamera
	local hrp = rootPart()
	if not (camera and hrp) then
		return
	end
	local mouse = UserInputService:GetMouseLocation()
	local ray = camera:ViewportPointToRay(mouse.X, mouse.Y)
	local params = RaycastParams.new()
	params.FilterType = Enum.RaycastFilterType.Exclude
	params.FilterDescendantsInstances = { player.Character }
	local result = workspace:Raycast(ray.Origin, ray.Direction * 1500, params)
	if result then
		hrp.CFrame = CFrame.new(result.Position + Vector3.new(0, 3, 0))
	end
end

local function resetCharacter()
	local hum = humanoid()
	if hum then
		hum.Health = 0
	end
end

local function rejoin()
	pcall(function()
		TeleportService:Teleport(game.PlaceId, player)
	end)
end

local function applyAll()
	applyMovement()
	setNoclip(State.Noclip)
	setInfiniteJump(State.InfiniteJump)
	setAntiAfk(State.AntiAfk)
	setFullBright(State.FullBright)
	setNoFog(State.NoFog)
	if State.Fly then
		startFly()
	end
end

-- ─────────────────────────────────────────────────────────────── home page
section(pageHome, "MOVEMENT")

makeToggle(pageHome, "Fly", false, function(value)
	State.Fly = value
	if value then
		if not startFly() then
			State.Fly = false
			return
		end
		State.Noclip = true
		setNoclip(true)
	else
		stopFly()
	end
end)

makeToggle(pageHome, "Noclip", false, function(value)
	State.Noclip = value
	setNoclip(value)
end)

makeToggle(pageHome, "Infinite Jump", false, function(value)
	State.InfiniteJump = value
	setInfiniteJump(value)
end)

makeSlider(pageHome, "Walk Speed", 16, 220, State.Speed, 1, function(value)
	State.Speed = value
	applyMovement()
end)

makeSlider(pageHome, "Jump Power", 50, 320, State.JumpPower, 1, function(value)
	State.JumpPower = value
	applyMovement()
end)

section(pageHome, "UTILITY")

makeToggle(pageHome, "Anti-AFK", false, function(value)
	State.AntiAfk = value
	setAntiAfk(value)
end)

makeToggle(pageHome, "Freeze Self", false, function(value)
	State.Freeze = value
	applyMovement()
end)

makeToggle(pageHome, "Full Bright", false, function(value)
	State.FullBright = value
	setFullBright(value)
end)

makeToggle(pageHome, "No Fog", false, function(value)
	State.NoFog = value
	setNoFog(value)
end)

makeButton(pageHome, "Teleport to Mouse", teleportToMouse)
makeButton(pageHome, "Reset Character", resetCharacter)
makeButton(pageHome, "Rejoin Server", rejoin)

-- ─────────────────────────────────────────────────────────────── theme page
local accentR, accentG, accentB
local bgR, bgG, bgB

local function channelOf(color)
	return round(color.R * 255), round(color.G * 255), round(color.B * 255)
end

local function pushAccent()
	if accentR and accentG and accentB then
		Theme.Accent = Color3.fromRGB(round(accentR.get()), round(accentG.get()), round(accentB.get()))
		applyTheme()
	end
end

local function pushBackground()
	if bgR and bgG and bgB then
		local base = Color3.fromRGB(round(bgR.get()), round(bgG.get()), round(bgB.get()))
		Theme.Panel = base
		Theme.Row = Color3.new(
			math.min(base.R * 1.35 + 0.045, 1),
			math.min(base.G * 1.35 + 0.045, 1),
			math.min(base.B * 1.35 + 0.045, 1)
		)
		applyTheme()
	end
end

local PRESETS = {
	{ "Neon", Color3.fromRGB(107, 139, 255) },
	{ "Cyber", Color3.fromRGB(23, 255, 159) },
	{ "Violet", Color3.fromRGB(177, 74, 237) },
	{ "Amber", Color3.fromRGB(255, 179, 0) },
	{ "Candy", Color3.fromRGB(255, 92, 138) },
	{ "Mono", Color3.fromRGB(150, 170, 200) },
}

section(pageTheme, "ACCENT")

local swatchRow = new("Frame", {
	Size = UDim2.new(1, 0, 0, 22),
	BackgroundTransparency = 1,
}, pageTheme)

for index, preset in ipairs(PRESETS) do
	local swatch = new("TextButton", {
		Size = UDim2.fromOffset(22, 22),
		Position = UDim2.fromOffset((index - 1) * 28, 0),
		BackgroundColor3 = preset[2],
		BorderSizePixel = 0,
		Text = "",
		AutoButtonColor = false,
	}, swatchRow)
	corner(swatch, 999)

	local rim = Instance.new("UIStroke")
	rim.Thickness = 1
	rim.Color = Color3.new(1, 1, 1)
	rim.Transparency = 0.75
	rim.Parent = swatch

	swatch.MouseButton1Click:Connect(function()
		Theme.Accent = preset[2]
		local r, g, b = channelOf(preset[2])
		accentR.set(r)
		accentG.set(g)
		accentB.set(b)
		applyTheme()
	end)
end

local r0, g0, b0 = channelOf(Theme.Accent)

accentR = makeSlider(pageTheme, "Red", 0, 255, r0, 1, pushAccent)
accentG = makeSlider(pageTheme, "Green", 0, 255, g0, 1, pushAccent)
accentB = makeSlider(pageTheme, "Blue", 0, 255, b0, 1, pushAccent)

section(pageTheme, "BACKGROUND")

local pr, pg, pb = channelOf(Theme.Panel)

bgR = makeSlider(pageTheme, "Red", 0, 255, pr, 1, pushBackground)
bgG = makeSlider(pageTheme, "Green", 0, 255, pg, 1, pushBackground)
bgB = makeSlider(pageTheme, "Blue", 0, 255, pb, 1, pushBackground)

section(pageTheme, "OPACITY")

makeSlider(pageTheme, "Window Opacity", 10, 100, round((1 - Theme.PanelTransparency) * 100), 1, function(value)
	Theme.PanelTransparency = 1 - value / 100
	applyTheme()
end)

makeSlider(pageTheme, "Row Opacity", 0, 100, round((1 - Theme.RowTransparency) * 100), 1, function(value)
	Theme.RowTransparency = 1 - value / 100
	applyTheme()
end)

section(pageTheme, "SHAPE")

makeSlider(pageTheme, "Corner Radius", 0, 16, Theme.Corner, 1, function(value)
	Theme.Corner = value
	applyTheme()
end)

makeSlider(pageTheme, "UI Scale", 70, 150, round(Theme.Scale * 100), 1, function(value)
	Theme.Scale = value / 100
	applyTheme()
end)

section(pageTheme, "EFFECTS")

local blurEffect = nil

makeToggle(pageTheme, "Backdrop Blur", false, function(value)
	if value then
		if not blurEffect then
			blurEffect = Instance.new("BlurEffect")
			blurEffect.Size = 12
			blurEffect.Parent = Lighting
		end
	else
		if blurEffect then
			blurEffect:Destroy()
			blurEffect = nil
		end
	end
end)

makeButton(pageTheme, "Reset Theme", function()
	for key, value in pairs(DEFAULTS) do
		Theme[key] = value
	end
	local ar, ag, ab = channelOf(Theme.Accent)
	accentR.set(ar)
	accentG.set(ag)
	accentB.set(ab)
	local br, bg, bb = channelOf(Theme.Panel)
	bgR.set(br)
	bgG.set(bg)
	bgB.set(bb)
	applyTheme()
end)

-- ─────────────────────────────────────────────────────────────── config page
section(pageConfig, "INPUT")

local toggleKey = Enum.KeyCode.RightShift
local awaitingKey = false

local keyButton = makeButton(pageConfig, "Toggle Key: RightShift", function() end, true)

local function refreshKeyLabel()
	local ok, name = pcall(function()
		return toggleKey.Name
	end)
	keyButton.Text = "Toggle Key: " .. (ok and name or "?")
end

keyButton.MouseButton1Click:Connect(function()
	awaitingKey = true
	keyButton.Text = "Press a key…"
end)

UserInputService.InputBegan:Connect(function(input, processed)
	if processed then
		return
	end
	if awaitingKey and input.UserInputType == Enum.UserInputType.Keyboard then
		toggleKey = input.KeyCode
		awaitingKey = false
		refreshKeyLabel()
		return
	end
	if input.KeyCode == toggleKey then
		setOpen(not main.Visible)
	end
end)

section(pageConfig, "THEME DATA")

local THEME_FILE = "SimpleAdminTheme.json"

local function serializeTheme()
	local data = {}
	for key, value in pairs(Theme) do
		if typeof(value) == "Color3" then
			local r, g, b = channelOf(value)
			data[key] = { r, g, b }
		else
			data[key] = value
		end
	end
	return HttpService:JSONEncode(data)
end

local function deserializeTheme(encoded)
	local ok, data = pcall(function()
		return HttpService:JSONDecode(encoded)
	end)
	if not ok or type(data) ~= "table" then
		return false
	end
	for key, value in pairs(data) do
		if DEFAULTS[key] ~= nil then
			if type(value) == "table" and #value == 3 then
				Theme[key] = Color3.fromRGB(value[1], value[2], value[3])
			elseif type(value) == type(DEFAULTS[key]) then
				Theme[key] = value
			end
		end
	end
	return true
end

makeButton(pageConfig, "Save Theme", function()
	local encoded = serializeTheme()
	shared.SimpleAdminTheme = encoded
	if writefile then
		pcall(writefile, THEME_FILE, encoded)
	end
end)

makeButton(pageConfig, "Load Theme", function()
	local encoded = nil
	if isfile and isfile(THEME_FILE) then
		local ok, content = pcall(readfile, THEME_FILE)
		if ok then
			encoded = content
		end
	end
	if not encoded and type(shared.SimpleAdminTheme) == "string" then
		encoded = shared.SimpleAdminTheme
	end
	if not encoded or not deserializeTheme(encoded) then
		return
	end
	local ar, ag, ab = channelOf(Theme.Accent)
	accentR.set(ar)
	accentG.set(ag)
	accentB.set(ab)
	local br, bg, bb = channelOf(Theme.Panel)
	bgR.set(br)
	bgG.set(bg)
	bgB.set(bb)
	applyTheme()
end)

makeButton(pageConfig, "Copy Theme String", function()
	local encoded = serializeTheme()
	if setclipboard then
		pcall(setclipboard, encoded)
	end
end)

section(pageConfig, "ABOUT")

local about = new("TextLabel", {
	Size = UDim2.new(1, 0, 0, 44),
	BackgroundTransparency = 1,
	Font = Enum.Font.Code,
	Text = "SimpleAdmin v4\ncompact shell · live theme engine\nclient-side only",
	TextSize = 9,
	TextXAlignment = Enum.TextXAlignment.Left,
	TextYAlignment = Enum.TextYAlignment.Top,
	TextColor3 = Theme.Dim,
}, pageConfig)
reg(about, "dim")

-- ─────────────────────────────────────────────────────────────── window control
local orb

function setOpen(open)
	if open then
		main.Visible = true
		if orb then
			orb.Visible = false
		end
	else
		main.Visible = false
		if orb then
			orb.Visible = true
		end
	end
end

-- drag
do
	local dragging = false
	local dragStart, startPosition

	header.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch then
			dragging = true
			dragStart = input.Position
			startPosition = main.Position
		end
	end)

	UserInputService.InputChanged:Connect(function(input)
		if not dragging then
			return
		end
		if input.UserInputType == Enum.UserInputType.MouseMovement
			or input.UserInputType == Enum.UserInputType.Touch then
			local delta = input.Position - dragStart
			main.Position = UDim2.new(
				startPosition.X.Scale,
				startPosition.X.Offset + delta.X,
				startPosition.Y.Scale,
				startPosition.Y.Offset + delta.Y
			)
		end
	end)

	UserInputService.InputEnded:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch then
			dragging = false
		end
	end)
end

-- orb
orb = new("TextButton", {
	Name = "Orb",
	Size = UDim2.fromOffset(46, 46),
	Position = UDim2.new(0, 20, 0.5, -23),
	BackgroundColor3 = Theme.Accent,
	BackgroundTransparency = 0,
	BorderSizePixel = 0,
	Font = Enum.Font.GothamBold,
	Text = "SA",
	TextSize = 13,
	TextColor3 = Color3.new(1, 1, 1),
	AutoButtonColor = false,
	Visible = false,
}, screen)
corner(orb, 999)
reg(orb, "accentFill")

local orbStroke = Instance.new("UIStroke")
orbStroke.Thickness = 2
orbStroke.Color = Theme.Stroke
orbStroke.Transparency = 0.7
orbStroke.Parent = orb

orb.MouseButton1Click:Connect(function()
	setOpen(true)
end)

minBtn.MouseButton1Click:Connect(function()
	setOpen(false)
end)

closeBtn.MouseButton1Click:Connect(function()
	screen:Destroy()
end)

-- orb drag
do
	local dragging = false
	local dragStart, startPosition

	orb.InputBegan:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch then
			dragging = true
			dragStart = input.Position
			startPosition = orb.Position
		end
	end)

	UserInputService.InputChanged:Connect(function(input)
		if not dragging then
			return
		end
		local delta = input.Position - dragStart
		if math.abs(delta.X) > 3 or math.abs(delta.Y) > 3 then
			orb.Position = UDim2.new(
				startPosition.X.Scale,
				startPosition.X.Offset + delta.X,
				startPosition.Y.Scale,
				startPosition.Y.Offset + delta.Y
			)
		end
	end)

	UserInputService.InputEnded:Connect(function(input)
		if input.UserInputType == Enum.UserInputType.MouseButton1
			or input.UserInputType == Enum.UserInputType.Touch then
			dragging = false
		end
	end)
end

-- ─────────────────────────────────────────────────────────────── init
player.CharacterAdded:Connect(function()
	task.wait(0.35)
	applyAll()
	State.Fly = false
	stopFly()
end)

applyTheme()
refreshKeyLabel()
selectTab(1)
setOpen(true)

print("[SimpleAdmin v4] ready — toggle key:", toggleKey.Name)