local ffi = require "ffi"
local bit = require "bit"
local vector = require "vector"
local aa_funcs = require "gamesense/antiaim_funcs" or error "Missing gamesense/antiaim_funcs"
local clipboard = require "gamesense/clipboard" or error("Clipboard library required")
local json = require("json")
local weapons = require("gamesense/csgo_weapons")

-- [[ UI Helper / Renaming ]]
local function prefix(x, z) 
    return (z and ("\\a698a6dFF~ \\a414141FF(\\ab5b5b5FF%s\\a414141FF) \\a89f596FF%s"):format(x, z) or ("\\a89f596FF%s"):format(x)) 
end

local PROJ_NAME = "SXPHORA.SENSE"

-- [[ Variables & State ]]
local menu = {}
local notifications = {}
local hitmarker_queue = {}
local tracer_queue = {}
local last_tag_time = 0
local aa_dir = 0 
local timer = globals.tickcount()

-- [[ Notification System ]]
local notify = (function()
    local b = vector
    local c = function(d, b, c) return d + (b - d) * c end
    local e = function() return b(client.screen_size()) end
    local f = function(d, ...) local c = {...} local c = table.concat(c, "") return b(renderer.measure_text(d, c)) end
    local g = { notifications = { bottom = {} }, max = { bottom = 5 } }
    g.__index = g
    g.new_bottom = function(h, i, j, text, color_key)
        table.insert(g.notifications.bottom, {
            started = false,
            instance = setmetatable({ active = false, timeout = 7, color = { ["r"] = h, ["g"] = i, ["b"] = j, a = 0 }, x = e().x / 2, y = e().y, text = text, color_key = color_key }, g)
        })
        if #g.notifications.bottom > g.max.bottom then table.remove(g.notifications.bottom, 1) end
    end
    function g:handler()
        local d, b = 0, 0
        for d, b in pairs(g.notifications.bottom) do
            if not b.instance.active and b.started then table.remove(g.notifications.bottom, d) end
        end
        for d = 1, #g.notifications.bottom do if g.notifications.bottom[d].instance.active then b = b + 1 end end
        for c, e in pairs(g.notifications.bottom) do
            if c > g.max.bottom then return end
            if e.instance.active then e.instance:render_bottom(d, b) d = d + 1 end
            if not e.started then e.instance:start() e.started = true end
        end
    end
    function g:start() self.active = true self.delay = globals.realtime() + self.timeout end
    function g:get_text()
        local d = ""
        for b, b in pairs(self.text) do d = d .. b[1] end
        return d
    end
    function g:render_bottom(g, l)
        local e, r_size = e(), ui.get(menu["Visuals"]["notheight"])
        local n = self:get_text()
        local text_size = f("", n)
        local q = text_size.x + 50
        local s, t = (e.x / 2 - q / 2), math.ceil(self.y - 40)
        local u = globals.frametime()
        if globals.realtime() < self.delay then
            self.y = c(self.y, e.y - 45 - (l - g) * r_size * 1.4, u * 7)
            self.color.a = c(self.color.a, 255, u * 2)
        else
            self.y = c(self.y, self.y - 10, u * 15)
            self.color.a = c(self.color.a, 0, u * 20)
            if self.color.a <= 1 then self.active = false end
        end
        renderer.rectangle(s, t, q, r_size, 25, 25, 25, self.color.a, 10)
        renderer.text(s + q/2, t + r_size/2, 255, 255, 255, self.color.a, "c", 0, n)
    end
    return g
end)()

-- [[ MENU SETUP ]]
local function setup_menu()
    ui.new_label("aa", "anti-aimbot angles", prefix("------------------------------------------"))
    ui.new_label("aa", "anti-aimbot angles", prefix("         " .. PROJ_NAME .. " ENHANCEMENTS            "))
    ui.new_label("aa", "anti-aimbot angles", prefix("------------------------------------------"))

    menu["Rage"] = {
        resolver_enable = ui.new_checkbox("aa", "anti-aimbot angles", prefix("adaptive resolver")),
        resolver_mode = ui.new_combobox("aa", "anti-aimbot angles", "\nresolver_mode", {"standard", "bruteforce", "experimental"}),
    }

    menu["AA"] = {
        fake_pitch = ui.new_combobox("aa", "anti-aimbot angles", prefix("impossible pitch"), {"off", "head-to-feet", "jitter down", "zero snap"}),
        m_left = ui.new_hotkey("aa", "anti-aimbot angles", "manual left", true),
        m_right = ui.new_hotkey("aa", "anti-aimbot angles", "manual right", true),
        m_back = ui.new_hotkey("aa", "anti-aimbot angles", "manual back", true),
    }

    menu["Visuals"] = {
        tracer = ui.new_checkbox("VISUALS", "Effects", prefix("bullet tracers redux")),
        tracer_color = ui.new_color_picker("VISUALS", "Effects", "Tracer Color", 255, 255, 255, 255),
        hitmark = ui.new_checkbox("aa", "anti-aimbot angles", prefix("world hitmarker")),
        notheight = ui.new_slider("aa", "anti-aimbot angles", prefix("notify height"), 10, 50, 25),
        indicators = ui.new_checkbox("aa", "anti-aimbot angles", prefix("indicators"), true),
    }

    menu["Misc"] = {
        tag_enable = ui.new_checkbox("aa", "anti-aimbot angles", prefix("custom clan tag")),
        tag_input = ui.new_textbox("aa", "anti-aimbot angles", prefix("tag text")),
        tag_speed = ui.new_slider("aa", "anti-aimbot angles", prefix("tag speed"), 1, 10, 5),
        killsay = ui.new_checkbox("aa", "anti-aimbot angles", prefix("killsay")),
    }
end
setup_menu()

-- [[ Bullet Tracers Logic ]]
client.set_event_callback("bullet_impact", function(e)
    if ui.get(menu["Visuals"]["tracer"]) and client.userid_to_entindex(e.userid) == entity.get_local_player() then
        local lx, ly, lz = client.eye_position()
        table.insert(tracer_queue, {lx, ly, lz, e.x, e.y, e.z, globals.curtime() + 2})
    end
end)

-- [[ Resolver Logic ]]
client.set_event_callback("net_update_end", function()
    if not ui.get(menu["Rage"].resolver_enable) then return end
    local enemies = entity.get_players(true)
    for i=1, #enemies do
        local ent = enemies[i]
        if entity.is_alive(ent) and not entity.is_dormant(ent) then
            local pitch = entity.get_prop(ent, "m_angEyeAngles", 0)
            if math.abs(pitch) >= 89 then
                entity.set_prop(ent, "m_angEyeAngles", 89, 0)
            end
            if ui.get(menu["Rage"].resolver_mode) == "bruteforce" then
                local yaw = entity.get_prop(ent, "m_angEyeAngles", 1)
                entity.set_prop(ent, "m_angEyeAngles", pitch, yaw + client.random_int(-30, 30))
            end
        end
    end
end)

-- [[ Anti-Aim & Manuals ]]
client.set_event_callback("setup_command", function(cmd)
    local lp = entity.get_local_player()
    if not lp or not entity.is_alive(lp) then return end

    if ui.get(menu["AA"].m_left) then aa_dir = 1
    elseif ui.get(menu["AA"].m_right) then aa_dir = 2
    elseif ui.get(menu["AA"].m_back) then aa_dir = 0 end

    local p_mode = ui.get(menu["AA"].fake_pitch)
    if p_mode ~= "off" then
        local p_val = 89
        if p_mode == "head-to-feet" then p_val = (globals.tickcount() % 2 == 0) and 89 or -89
        elseif p_mode == "jitter down" then p_val = 89 + client.random_float(-0.5, 0.5)
        elseif p_mode == "zero snap" then p_val = (globals.tickcount() % 4 == 0) and 0 or 89 end
        entity.set_prop(lp, "m_angEyeAngles", p_val, 0)
    end

    local yaw_ref = ui.reference("aa", "anti-aimbot angles", "yaw")
    if aa_dir == 1 then ui.set(yaw_ref, 90)
    elseif aa_dir == 2 then ui.set(yaw_ref, -90)
    elseif aa_dir == 0 then ui.set(yaw_ref, 0) end
end)

-- [[ Paint & Indicators ]]
client.set_event_callback("paint", function()
    notify:handler()

    -- Render Tracers
    if ui.get(menu["Visuals"]["tracer"]) then
        local r, g, b, a = ui.get(menu["Visuals"]["tracer_color"])
        for i, data in pairs(tracer_queue) do
            if globals.curtime() <= data[7] then
                local x1, y1 = renderer.world_to_screen(data[1], data[2], data[3])
                local x2, y2 = renderer.world_to_screen(data[4], data[5], data[6])
                if x1 and x2 then renderer.line(x1, y1, x2, y2, r, g, b, a) end
            else table.remove(tracer_queue, i) end
        end
    end

    -- Render Indicators
    if ui.get(menu["Visuals"]["indicators"]) then
        local lp = entity.get_local_player()
        if not lp or not entity.is_alive(lp) then return end
        local w, h = client.screen_size()
        renderer.text(w/2, h/2 + 20, 255, 255, 255, 255, "cb", 0, PROJ_NAME)
        
        local desync = math.floor(math.abs(entity.get_prop(lp, "m_flPoseParameter", 11) * 120 - 60))
        renderer.text(w/2, h/2 + 30, 150, 200, 60, 255, "c-", 0, "DESYNC: " .. desync .. "°")
    end
end)

-- [[ Clan Tag Logic ]]
client.set_event_callback("run_command", function()
    if not ui.get(menu["Misc"].tag_enable) then return end
    local cur_time = globals.realtime()
    if cur_time - last_tag_time < (11 - ui.get(menu["Misc"].tag_speed)) * 0.1 then return end
    
    local tag = ui.get(menu["Misc"].tag_input)
    if tag ~= "" then
        client.set_clan_tag(tag)
        last_tag_time = cur_time
    end
end)

-- [[ Killsay (Gucci style) ]]
local killsays = {"Powered by " .. PROJ_NAME, "Sit down", "Nice desync, easy tap", "Get SXPHORA'D"}
client.set_event_callback("player_death", function(e)
    if not ui.get(menu["Misc"].killsay) then return end
    if client.userid_to_entindex(e.attacker) == entity.get_local_player() then
        client.exec("say " .. killsays[client.random_int(1, #killsays)])
    end
end)

client.log(PROJ_NAME .. " Integrated Successfully.")