-- init
if not game:IsLoaded() then
    game.Loaded:Wait()
end

if not syn or not protectgui then
    getgenv().protectgui = function() end
end

local SilentAimSettings = {
    Enabled = false,

    ClassName = "Universal Silent Aim - Averiias, Stefanuk12, xaxa",
    ToggleKey = "RightAlt",

    TeamCheck = false,
    VisibleCheck = false,
    TargetPart = "HumanoidRootPart",
    SilentAimMethod = "Raycast",

    FOVRadius = 130,
    FOVVisible = false,
    ShowSilentAimTarget = false,

    MouseHitPrediction = false,
    MouseHitPredictionAmount = 0.165,
    HitChance = 100
}

-- CORREÇÃO CRÍTICA: Era "Settings" agora é "SilentAimSettings"
getgenv().SilentAimSettings = SilentAimSettings

local MainFileName = "UniversalSilentAim"
local SelectedFile, FileToSave = "", ""

local Camera = workspace.CurrentCamera
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
local HttpService = game:GetService("HttpService")

local LocalPlayer = Players.LocalPlayer
local Mouse = LocalPlayer:GetMouse()

local GetChildren = game.GetChildren
local GetPlayers = Players.GetPlayers
local WorldToScreen = Camera.WorldToScreenPoint
local WorldToViewportPoint = Camera.WorldToViewportPoint
local GetPartsObscuringTarget = Camera.GetPartsObscuringTarget
local FindFirstChild = game.FindFirstChild
local RenderStepped = RunService.RenderStepped
local GuiInset = GuiService.GetGuiInset
local GetMouseLocation = UserInputService.GetMouseLocation

local resume = coroutine.resume
local create = coroutine.create

local ValidTargetParts = {"Head", "HumanoidRootPart"}
local PredictionAmount = 0.165

-- Detectar se é mobile
local IsMobile = UserInputService.TouchEnabled and not UserInputService.MouseEnabled

local mouse_box = Drawing.new("Square")
mouse_box.Visible = false  -- CORRIGIDO: Inicia como false
mouse_box.ZIndex = 999
mouse_box.Color = Color3.fromRGB(54, 57, 241)
mouse_box.Thickness = 20
mouse_box.Size = Vector2.new(20, 20)
mouse_box.Filled = true

local fov_circle = Drawing.new("Circle")
fov_circle.Thickness = 1
fov_circle.NumSides = 100
fov_circle.Radius = 180
fov_circle.Filled = false
fov_circle.Visible = false
fov_circle.ZIndex = 999
fov_circle.Transparency = 1
fov_circle.Color = Color3.fromRGB(54, 57, 241)

local ExpectedArguments = {
    FindPartOnRayWithIgnoreList = {
        ArgCountRequired = 3,
        Args = {
            "Instance", "Ray", "table", "boolean", "boolean"
        }
    },
    FindPartOnRayWithWhitelist = {
        ArgCountRequired = 3,
        Args = {
            "Instance", "Ray", "table", "boolean"
        }
    },
    FindPartOnRay = {
        ArgCountRequired = 2,
        Args = {
            "Instance", "Ray", "Instance", "boolean", "boolean"
        }
    },
    Raycast = {
        ArgCountRequired = 3,
        Args = {
            "Instance", "Vector3", "Vector3", "RaycastParams"
        }
    }
}

function CalculateChance(Percentage)
    Percentage = math.floor(Percentage)
    local chance = math.floor(Random.new().NextNumber(Random.new(), 0, 1) * 100) / 100
    return chance <= Percentage / 100
end

--[[file handling]] do
    if not isfolder(MainFileName) then
        makefolder(MainFileName)
    end

    if not isfolder(string.format("%s/%s", MainFileName, tostring(game.PlaceId))) then
        makefolder(string.format("%s/%s", MainFileName, tostring(game.PlaceId)))
    end
end

-- CORRIGIDO: Proteção contra erro se não houver arquivos
local Files = {}
pcall(function()
    Files = listfiles(string.format("%s/%s", "UniversalSilentAim", tostring(game.PlaceId)))
end)

-- functions
local function GetFiles()
    local out = {}
    for i = 1, #Files do
        local file = Files[i]
        if file:sub(-4) == '.lua' then
            local pos = file:find('.lua', 1, true)
            local start = pos

            local char = file:sub(pos, pos)
            while char ~= '/' and char ~= '\\' and char ~= '' do
                pos = pos - 1
                char = file:sub(pos, pos)
            end

            if char == '/' or char == '\\' then
                table.insert(out, file:sub(pos + 1, start - 1))
            end
        end
    end

    return out
end

local function UpdateFile(FileName)
    if not FileName or type(FileName) ~= "string" or FileName == "" then
        return warn("Nome de arquivo inválido")
    end
    writefile(string.format("%s/%s/%s.lua", MainFileName, tostring(game.PlaceId), FileName), HttpService:JSONEncode(SilentAimSettings))
end

local function LoadFile(FileName)
    if not FileName or type(FileName) ~= "string" or FileName == "" then
        return warn("Nome de arquivo inválido")
    end

    local File = string.format("%s/%s/%s.lua", MainFileName, tostring(game.PlaceId), FileName)
    local success, ConfigData = pcall(function()
        return HttpService:JSONDecode(readfile(File))
    end)

    if success and ConfigData then
        for Index, Value in next, ConfigData do
            SilentAimSettings[Index] = Value
        end
    end
end

local function getPositionOnScreen(Vector)
    local Vec3, OnScreen = WorldToScreen(Camera, Vector)
    return Vector2.new(Vec3.X, Vec3.Y), OnScreen
end

local function ValidateArguments(Args, RayMethod)
    local Matches = 0
    if #Args < RayMethod.ArgCountRequired then
        return false
    end
    for Pos, Argument in next, Args do
        if typeof(Argument) == RayMethod.Args[Pos] then
            Matches = Matches + 1
        end
    end
    return Matches >= RayMethod.ArgCountRequired
end

local function getDirection(Origin, Position)
    return (Position - Origin).Unit * 1000
end

-- CORRIGIDO: Suporte para Mobile e PC
local function getMousePosition()
    if IsMobile then
        local touch = UserInputService:GetTouchPosition()
        if touch and #touch > 0 then
            return touch[1]
        end
        return Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
    else
        return GetMouseLocation(UserInputService)
    end
end

local function IsPlayerVisible(Player)
    local PlayerCharacter = Player.Character
    local LocalPlayerCharacter = LocalPlayer.Character

    if not (PlayerCharacter or LocalPlayerCharacter) then return end

    local PlayerRoot = FindFirstChild(PlayerCharacter, SilentAimSettings.TargetPart) or FindFirstChild(PlayerCharacter, "HumanoidRootPart")

    if not PlayerRoot then return end

    local CastPoints, IgnoreList = {PlayerRoot.Position, LocalPlayerCharacter, PlayerCharacter}, {LocalPlayerCharacter, PlayerCharacter}
    local ObscuringObjects = #GetPartsObscuringTarget(Camera, CastPoints, IgnoreList)

    return ((ObscuringObjects == 0 and true) or (ObscuringObjects > 0 and false))
end

local function getClosestPlayer()
    if not SilentAimSettings.TargetPart then return end
    local Closest
    local DistanceToMouse
    for _, Player in next, GetPlayers(Players) do
        if Player == LocalPlayer then continue end
        if SilentAimSettings.TeamCheck and Player.Team == LocalPlayer.Team then continue end

        local Character = Player.Character
        if not Character then continue end

        if SilentAimSettings.VisibleCheck and not IsPlayerVisible(Player) then continue end

        local HumanoidRootPart = FindFirstChild(Character, "HumanoidRootPart")
        local Humanoid = FindFirstChild(Character, "Humanoid")
        if not HumanoidRootPart or not Humanoid or Humanoid and Humanoid.Health <= 0 then continue end

        local ScreenPosition, OnScreen = getPositionOnScreen(HumanoidRootPart.Position)
        if not OnScreen then continue end

        local Distance = (getMousePosition() - ScreenPosition).Magnitude
        if Distance <= (DistanceToMouse or SilentAimSettings.FOVRadius or 2000) then
            Closest = ((SilentAimSettings.TargetPart == "Random" and Character[ValidTargetParts[math.random(1, #ValidTargetParts)]]) or Character[SilentAimSettings.TargetPart])
            DistanceToMouse = Distance
        end
    end
    return Closest
end

-- ui creating & handling
local Library = loadstring(game:HttpGet("https://raw.githubusercontent.com/violin-suzutsuki/LinoriaLib/main/Library.lua"))()
local ThemeManager = loadstring(game:HttpGet("https://raw.githubusercontent.com/violin-suzutsuki/LinoriaLib/main/addons/ThemeManager.lua"))()
local SaveManager = loadstring(game:HttpGet("https://raw.githubusercontent.com/violin-suzutsuki/LinoriaLib/main/addons/SaveManager.lua"))()

Library:SetWatermark("Universal Silent Aim | github.com/Averiias")

-- CORRIGIDO: Garantir que a UI seja criada corretamente
local Window = Library:CreateWindow({
    Title = 'Universal Silent Aim',
    Center = true,
    AutoShow = true,
    TabPadding = 8,
    MenuFadeTime = 0.2
})

-- Adicionar botão de toggle para mobile
Library:Notify("Script carregado com sucesso! " .. (IsMobile and "(Modo Mobile)" or "(Modo PC)"))

local Tabs = {
    General = Window:AddTab("General"),
    ["UI Settings"] = Window:AddTab("UI Settings")
}

local GeneralTab = Tabs.General
local MainBOX = GeneralTab:AddLeftTabbox("Main") do
    local Main = MainBOX:AddTab("Main")

    Main:AddToggle("aim_Enabled", {Text = "Enabled", Default = SilentAimSettings.Enabled}):AddKeyPicker("aim_Enabled_KeyPicker", {
        Default = "RightAlt",
        SyncToggleState = true,
        Mode = "Toggle",
        Text = "Enabled",
        NoUI = false
    })

    Toggles.aim_Enabled:OnChanged(function()
        SilentAimSettings.Enabled = Toggles.aim_Enabled.Value
        mouse_box.Visible = SilentAimSettings.Enabled and SilentAimSettings.ShowSilentAimTarget
    end)

    Options.aim_Enabled_KeyPicker:OnClick(function()
        SilentAimSettings.Enabled = not SilentAimSettings.Enabled
        Toggles.aim_Enabled:SetValue(SilentAimSettings.Enabled)
        mouse_box.Visible = SilentAimSettings.Enabled and SilentAimSettings.ShowSilentAimTarget
    end)

    Main:AddToggle("TeamCheck", {Text = "Team Check", Default = SilentAimSettings.TeamCheck}):OnChanged(function()
        SilentAimSettings.TeamCheck = Toggles.TeamCheck.Value
    end)

    Main:AddToggle("VisibleCheck", {Text = "Visible Check", Default = SilentAimSettings.VisibleCheck}):OnChanged(function()
        SilentAimSettings.VisibleCheck = Toggles.VisibleCheck.Value
    end)

    Main:AddDropdown("TargetPart", {
        AllowNull = false,
        Text = "Target Part",
        Default = SilentAimSettings.TargetPart,
        Values = {"Head", "HumanoidRootPart", "Random"}
    }):OnChanged(function()
        SilentAimSettings.TargetPart = Options.TargetPart.Value
    end)

    Main:AddDropdown("Method", {
        AllowNull = false,
        Text = "Silent Aim Method",
        Default = SilentAimSettings.SilentAimMethod,
        Values = {
            "Raycast",
            "FindPartOnRay",
            "FindPartOnRayWithWhitelist",
            "FindPartOnRayWithIgnoreList",
            "Mouse.Hit/Target"
        }
    }):OnChanged(function()
        SilentAimSettings.SilentAimMethod = Options.Method.Value
    end)

    Main:AddSlider('HitChance', {
        Text = 'Hit chance',
        Default = SilentAimSettings.HitChance,
        Min = 0,
        Max = 100,
        Rounding = 1,
        Compact = false,
    }):OnChanged(function()
        SilentAimSettings.HitChance = Options.HitChance.Value
    end)
end

local MiscellaneousBOX = GeneralTab:AddLeftTabbox("Miscellaneous")
local PredictionTab = MiscellaneousBOX:AddTab("Prediction")

PredictionTab:AddToggle("Prediction", {
    Text = "Mouse.Hit/Target Prediction",
    Default = SilentAimSettings.MouseHitPrediction
}):OnChanged(function()
    SilentAimSettings.MouseHitPrediction = Toggles.Prediction.Value
end)

PredictionTab:AddSlider("Amount", {
    Text = "Prediction Amount",
    Min = 0.1,
    Max = 1,
    Default = SilentAimSettings.MouseHitPredictionAmount,
    Rounding = 3
}):OnChanged(function()
    PredictionAmount = Options.Amount.Value
    SilentAimSettings.MouseHitPredictionAmount = Options.Amount.Value
end)

local FieldOfViewBOX = GeneralTab:AddRightTabbox("Field Of View") do
    local Main = FieldOfViewBOX:AddTab("Visuals")

    Main:AddToggle("Visible", {
        Text = "Show FOV Circle",
        Default = SilentAimSettings.FOVVisible
    }):AddColorPicker("Color", {
        Default = Color3.fromRGB(54, 57, 241)
    })

    Toggles.Visible:OnChanged(function()
        fov_circle.Visible = Toggles.Visible.Value
        SilentAimSettings.FOVVisible = Toggles.Visible.Value
    end)

    Options.Color:OnChanged(function()
        fov_circle.Color = Options.Color.Value
    end)

    Main:AddSlider("Radius", {
        Text = "FOV Circle Radius",
        Min = 0,
        Max = 360,
        Default = SilentAimSettings.FOVRadius,
        Rounding = 0
    }):OnChanged(function()
        fov_circle.Radius = Options.Radius.Value
        SilentAimSettings.FOVRadius = Options.Radius.Value
    end)

    Main:AddToggle("MousePosition", {
        Text = "Show Silent Aim Target",
        Default = SilentAimSettings.ShowSilentAimTarget
    }):AddColorPicker("MouseVisualizeColor", {
        Default = Color3.fromRGB(54, 57, 241)
    })

    Toggles.MousePosition:OnChanged(function()
        SilentAimSettings.ShowSilentAimTarget = Toggles.MousePosition.Value
        if not Toggles.MousePosition.Value then
            mouse_box.Visible = false
        end
    end)

    Options.MouseVisualizeColor:OnChanged(function()
        mouse_box.Color = Options.MouseVisualizeColor.Value
    end)
end

local CreateConfigurationBOX = GeneralTab:AddRightTabbox("Create Configuration") do
    local Main = CreateConfigurationBOX:AddTab("Create")

    Main:AddInput("CreateConfigTextBox", {
        Default = "",
        Numeric = false,
        Finished = false,
        Text = "Configuration Name",
        Tooltip = "Creates a configuration file",
        Placeholder = "File Name here"
    }):OnChanged(function()
        if Options.CreateConfigTextBox.Value and string.len(Options.CreateConfigTextBox.Value) ~= 0 then
            FileToSave = Options.CreateConfigTextBox.Value
        end
    end)

    Main:AddButton("Create Configuration File", function()
        if FileToSave ~= "" and FileToSave ~= nil then
            UpdateFile(FileToSave)
            Library:Notify("Configuration '" .. FileToSave .. "' created!")
            -- Atualizar lista de arquivos
            Files = listfiles(string.format("%s/%s", "UniversalSilentAim", tostring(game.PlaceId)))
            Options.SaveConfigurationDropdown:SetValues(GetFiles())
            Options.LoadConfigurationDropdown:SetValues(GetFiles())
        else
            Library:Notify("Please enter a file name!")
        end
    end)
end

local SaveConfigurationBOX = GeneralTab:AddRightTabbox("Save Configuration") do
    local Main = SaveConfigurationBOX:AddTab("Save")

    Main:AddDropdown("SaveConfigurationDropdown", {
        AllowNull = true,
        Values = GetFiles(),
        Text = "Choose Configuration to Save"
    })

    Main:AddButton("Save Configuration", function()
        if Options.SaveConfigurationDropdown.Value and Options.SaveConfigurationDropdown.Value ~= "" then
            UpdateFile(Options.SaveConfigurationDropdown.Value)
            Library:Notify("Configuration '" .. Options.SaveConfigurationDropdown.Value .. "' saved!")
        else
            Library:Notify("Please select a configuration!")
        end
    end)

    Main:AddButton("Refresh List", function()
        Files = listfiles(string.format("%s/%s", "UniversalSilentAim", tostring(game.PlaceId)))
        Options.SaveConfigurationDropdown:SetValues(GetFiles())
        Options.LoadConfigurationDropdown:SetValues(GetFiles())
        Library:Notify("Configuration list refreshed!")
    end)
end

local LoadConfigurationBOX = GeneralTab:AddRightTabbox("Load Configuration") do
    local Main = LoadConfigurationBOX:AddTab("Load")

    Main:AddDropdown("LoadConfigurationDropdown", {
        AllowNull = true,
        Values = GetFiles(),
        Text = "Choose Configuration to Load"
    })

    Main:AddButton("Load Configuration", function()
        if Options.LoadConfigurationDropdown.Value and table.find(GetFiles(), Options.LoadConfigurationDropdown.Value) then
            LoadFile(Options.LoadConfigurationDropdown.Value)

            -- Atualizar UI com valores carregados
            Toggles.aim_Enabled:SetValue(SilentAimSettings.Enabled)
            Toggles.TeamCheck:SetValue(SilentAimSettings.TeamCheck)
            Toggles.VisibleCheck:SetValue(SilentAimSettings.VisibleCheck)
            Options.TargetPart:SetValue(SilentAimSettings.TargetPart)
            Options.Method:SetValue(SilentAimSettings.SilentAimMethod)
            Toggles.Visible:SetValue(SilentAimSettings.FOVVisible)
            Options.Radius:SetValue(SilentAimSettings.FOVRadius)
            Toggles.MousePosition:SetValue(SilentAimSettings.ShowSilentAimTarget)
            Toggles.Prediction:SetValue(SilentAimSettings.MouseHitPrediction)
            Options.Amount:SetValue(SilentAimSettings.MouseHitPredictionAmount)
            Options.HitChance:SetValue(SilentAimSettings.HitChance)

            Library:Notify("Configuration '" .. Options.LoadConfigurationDropdown.Value .. "' loaded!")
        else
            Library:Notify("Please select a valid configuration!")
        end
    end)
end

-- UI Settings Tab
ThemeManager:SetLibrary(Library)
SaveManager:SetLibrary(Library)

ThemeManager:SetFolder("UniversalSilentAim")
SaveManager:SetFolder("UniversalSilentAim/" .. tostring(game.PlaceId))

SaveManager:BuildConfigSection(Tabs["UI Settings"])
ThemeManager:ApplyToTab(Tabs["UI Settings"])

-- Inicializar valores padrão
task.spawn(function()
    task.wait(0.5)
    Toggles.aim_Enabled:SetValue(SilentAimSettings.Enabled)
    Options.TargetPart:SetValue(SilentAimSettings.TargetPart)
    Options.Method:SetValue(SilentAimSettings.SilentAimMethod)
    Options.Radius:SetValue(SilentAimSettings.FOVRadius)
    Options.HitChance:SetValue(SilentAimSettings.HitChance)
end)

-- Visual Update Loop
resume(create(function()
    RenderStepped:Connect(function()
        -- Atualizar visualização do alvo
        if SilentAimSettings.ShowSilentAimTarget and SilentAimSettings.Enabled then
            local closestPlayer = getClosestPlayer()
            if closestPlayer then
                local Root = closestPlayer.Parent.PrimaryPart or closestPlayer.Parent:FindFirstChild("HumanoidRootPart")
                if Root then
                    local RootToViewportPoint, IsOnScreen = WorldToViewportPoint(Camera, Root.Position)

                    mouse_box.Visible = IsOnScreen
                    mouse_box.Position = Vector2.new(RootToViewportPoint.X - 10, RootToViewportPoint.Y - 10)
                else
                    mouse_box.Visible = false
                end
            else
                mouse_box.Visible = false
            end
        else
            mouse_box.Visible = false
        end

        -- Atualizar FOV Circle
        if SilentAimSettings.FOVVisible then
            fov_circle.Visible = true
            fov_circle.Position = getMousePosition()
        else
            fov_circle.Visible = false
        end
    end)
end))

-- hooks
local oldNamecall
oldNamecall = hookmetamethod(game, "__namecall", newcclosure(function(...)
    local Method = getnamecallmethod()
    local Arguments = {...}
    local self = Arguments[1]
    local chance = CalculateChance(SilentAimSettings.HitChance)

    if SilentAimSettings.Enabled and self == workspace and not checkcaller() and chance then
        if Method == "FindPartOnRayWithIgnoreList" and SilentAimSettings.SilentAimMethod == Method then
            if ValidateArguments(Arguments, ExpectedArguments.FindPartOnRayWithIgnoreList) then
                local A_Ray = Arguments[2]
                local HitPart = getClosestPlayer()

                if HitPart then
                    local Origin = A_Ray.Origin
                    local Direction = getDirection(Origin, HitPart.Position)
                    Arguments[2] = Ray.new(Origin, Direction)
                    return oldNamecall(unpack(Arguments))
                end
            end
        elseif Method == "FindPartOnRayWithWhitelist" and SilentAimSettings.SilentAimMethod == Method then
            if ValidateArguments(Arguments, ExpectedArguments.FindPartOnRayWithWhitelist) then
                local A_Ray = Arguments[2]
                local HitPart = getClosestPlayer()

                if HitPart then
                    local Origin = A_Ray.Origin
                    local Direction = getDirection(Origin, HitPart.Position)
                    Arguments[2] = Ray.new(Origin, Direction)
                    return oldNamecall(unpack(Arguments))
                end
            end
        elseif (Method == "FindPartOnRay" or Method == "findPartOnRay") and SilentAimSettings.SilentAimMethod:lower() == Method:lower() then
            if ValidateArguments(Arguments, ExpectedArguments.FindPartOnRay) then
                local A_Ray = Arguments[2]
                local HitPart = getClosestPlayer()

                if HitPart then
                    local Origin = A_Ray.Origin
                    local Direction = getDirection(Origin, HitPart.Position)
                    Arguments[2] = Ray.new(Origin, Direction)
                    return oldNamecall(unpack(Arguments))
                end
            end
        elseif Method == "Raycast" and SilentAimSettings.SilentAimMethod == Method then
            if ValidateArguments(Arguments, ExpectedArguments.Raycast) then
                local A_Origin = Arguments[2]
                local HitPart = getClosestPlayer()

                if HitPart then
                    Arguments[3] = getDirection(A_Origin, HitPart.Position)
                    return oldNamecall(unpack(Arguments))
                end
            end
        end
    end
    return oldNamecall(...)
end))

local oldIndex = nil
oldIndex = hookmetamethod(game, "__index", newcclosure(function(self, Index)
    if self == Mouse and not checkcaller() and SilentAimSettings.Enabled and SilentAimSettings.SilentAimMethod == "Mouse.Hit/Target" then
        local HitPart = getClosestPlayer()

        if HitPart then
            if Index == "Target" or Index == "target" then
                return HitPart
            elseif Index == "Hit" or Index == "hit" then
                if SilentAimSettings.MouseHitPrediction then
                    return (HitPart.CFrame + (HitPart.Velocity * PredictionAmount))
                else
                    return HitPart.CFrame
                end
            elseif Index == "X" then
                local screenPos = WorldToViewportPoint(Camera, HitPart.Position)
                return screenPos.X
            elseif Index == "Y" then
                local screenPos = WorldToViewportPoint(Camera, HitPart.Position)
                return screenPos.Y
            elseif Index == "UnitRay" then
                local Origin = Camera.CFrame.Position
                local Direction = (HitPart.Position - Origin).Unit
                return Ray.new(Origin, Direction * 1000)
            end
        end
    end

    return oldIndex(self, Index)
end))

-- Notificação final
Library:Notify("Silent Aim loaded successfully! Press " .. (IsMobile and "RightShift" or "RightAlt") .. " to toggle")

print("===========================================")
print("Universal Silent Aim - Loaded Successfully!")
print("Mode: " .. (IsMobile and "Mobile" or "PC"))
print("Toggle Key: " .. (IsMobile and "RightShift" or "RightAlt"))
print("===========================================")