---

-- perfect user interface • gamesense
----- enQ#1349


print "pui debug"

-------------------------------------------------------------------------
-- #region :: Header


--
-- #region : Definitions

--#region: localization

local assert, defer, error, getfenv, setfenv, getmetatable, setmetatable, ipairs,
pairs, next, pcall, rawequal, rawset, rawlen, readfile, require, select,
tonumber, tostring, type, unpack, xpcall =
assert, defer, error, getfenv, setfenv, getmetatable, setmetatable, ipairs,
pairs, next, pcall, rawequal, rawset, rawlen, readfile, require, select,
tonumber, tostring, type, unpack, xpcall


local function mcopy (o)
	if type(o) ~= "table" then return o end
	local res = {} for k, v in pairs(o) do res[mcopy(k)] = mcopy(v) end return res
end

local table, math, string = mcopy(table), mcopy(math), mcopy(string)
local ui, client = mcopy(ui), mcopy(client)

--#endregion

--#region: globals

table.find = function (t, j)  for k, v in pairs(t) do if v == j then return k end end return false  end
table.ifind = function (t, j)  for i = 1, table.maxn(t) do if t[i] == j then return i end end  end
table.qfind = function (t, j)  for i = 1, #t do if t[i] == j then return i end end  end
table.ihas = function (t, ...) local arg = {...} for i = 1, table.maxn(t) do for j = 1, #arg do if t[i] == arg[j] then return true end end end return false end

table.minn = function (t) local s = 0 for i = 1, #t do if t[i] == nil then break end s = s + 1 end return s end
table.filter = function (t)  local res = {} for i = 1, table.maxn(t) do if t[i] ~= nil then res[#res+1] = t[i] end end return res  end
table.append = function (t, ...)  for i, v in ipairs{...} do table.insert(t, v) end  end
table.copy = mcopy

local ternary = function (c, a, b)  if c then return a else return b end  end
local contend = function (func, callback, ...)
	local t = { pcall(func, ...) }
	if not t[1] then return type(callback) == "function" and callback(t[2]) or error(t[2], callback or 2) end
	return unpack(t, 2)
end

--#endregion

--#region: directory tools

local dirs = {
	execute = function (t, path, func)
		local p, k for _, s in ipairs(path) do
			k, p, t = s, t, t[s]
			if t == nil then return end
		end
		if p[k] then func(p[k]) end
	end,
	replace = function (t, path, value)
		local p, k for _, s in ipairs(path) do
			k, p, t = s, t, t[s]
			if t == nil then return end
		end
		p[k] = value
	end,
	find = function (t, path)
		local p, k for _, s in ipairs(path) do
			k, p, t = s, t, t[s]
			if t == nil then return end
		end
		return p[k]
	end,
}

dirs.pave = function (t, place, path)
    local p = t for i, v in ipairs(path) do
        if type(p[v]) == "table" then p = p[v]
        else p[v] = (i < #path) and {} or place  p = p[v]  end
    end return t
end

dirs.extract = function (t, path)
	if not path or #path == 0 then return t end
    local j = dirs.find(t, path)
    return dirs.pave({}, j, path)
end

--#endregion

local pui, pui_mt, methods_mt = {}, {}, {
	element = {}, group = {}
}

-- #endregion
--

--
-- #region : Elements

--#region: arguments

local registry, ragebot, players = {}, {}, {}

local elements = {
	button		= { type = "function",	arg = 2, unsavable = true },
	checkbox	= { type = "boolean",	arg = 1, init = false	},
	color_picker= { type = "table",		arg = 5 },
	combobox	= { type = "string",	arg = 2, variable = true },
	hotkey		= { type = "table",		arg = 3, enum = {[0] = "Always on", "On hotkey", "Toggle", "Off hotkey"} },
	label		= { type = "string",	arg = 1, unsavable = true },
	listbox		= { type = "number",	arg = 2, init = 0, variable = true },
	multiselect	= { type = "table",		arg = 2, init = {}, variable = true },
	slider		= { type = "number",	arg = 8 },
	textbox		= { type = "string",	arg = 1, init = "" },
	string		= { type = "string",	arg = 2, init = "" },
	unknown		= { type = "string",	arg = 2, init = "" } -- new_string type
}

local weapons = { "Global", "G3SG1 / SCAR-20", "SSG 08", "AWP", "R8 Revolver", "Desert Eagle", "Pistol", "Zeus", "Rifle", "Shotgun", "SMG", "Machine gun" }

--#endregion

--#region: registry

local ui_mset = function (k, v)
	if registry[k].type == "hotkey" then
		ui.set(k, elements.hotkey.enum[ v[2] ], v[3])
	else
		ui.set(k, v)
	end
end

local ui_mget = function (k)
	if registry[k].type == "hotkey" then return { ui.get(k) } else return ui.get(k) end
end

do
	client.set_event_callback("shutdown", function ()
		for k, v in next, registry do
			if v.__ref and not v.__rage then
				if v.overridden then ui_mset(k, v.original) end
				ui.set_enabled(k, true)
				ui.set_visible(k, not v.__hidden)
			end
		end
		ragebot.cycle(function (active)
			for k, v in pairs(ragebot.context[active]) do
				if v ~= nil and registry[k].overridden then
					ui_mset(k, v)
				end
			end
		end, true)
	end)
	client.set_event_callback("pre_config_save", function ()
		for k, v in next, registry do
			if v.__ref and not v.__rage and v.overridden then
				v.ovr_restore = { ui_mget(k) }
				ui_mset(k, v.original)
			end
		end
		ragebot.cycle(function (active)
			for k, v in pairs(ragebot.context[active]) do
				if registry[k].overridden then
					ragebot.cache[active][k] = { ui_mget(k) }
					ui_mset(k, v)
				end
			end
		end, true)
	end)
	client.set_event_callback("post_config_save", function ()
		for k, v in next, registry do
			if v.__ref and not v.__rage and v.overridden then
				ui_mset(k, unpack(v.ovr_restore))
				v.ovr_restore = nil
			end
		end
		ragebot.cycle(function (active)
			for k, v in pairs(ragebot.context[active]) do
				if registry[k].overridden and ragebot.cache[active][k] ~= nil then
					ui_mset(k, unpack(ragebot.cache[active][k]))
					ragebot.cache[active][k] = nil
				end
			end
		end, true)
	end)
end

--#endregion

--#region: elemence

local elemence = {} do
	local callbacks = function (this, isref)
		if this.name == "Weapon type" and string.lower(registry[this.ref].tab) == "rage" then return ui.get(this.ref) end

		ui.set_callback(this.ref, function (self)
			if registry[self].__rage and ragebot.silent then return end
			for i = 0, #registry[self].callbacks, 1 do
				if type(registry[self].callbacks[i]) == "function" then registry[self].callbacks[i](this) end
			end
		end)

		if this.type == "button" then return
		elseif this.type == "color_picker" or this.type == "hotkey" then
			registry[this.ref].callbacks[0] = function (self) this.value = { ui.get(self.ref) } end
			return { ui.get(this.ref) }
		else
			registry[this.ref].callbacks[0] = function (self) this.value = ui.get(self.ref) end
			if this.type == "multiselect" then
				this.value = ui.get(this.ref)
				registry[this.ref].callbacks[1] = function (self)
					registry[this.ref].options = {}
					for i = 1, #self.value do registry[this.ref].options[ self.value[i] ] = true end
				end
				registry[this.ref].callbacks[1](this)
			end
			return ui.get(this.ref)
		end
	end

	elemence.new = function (ref, add)
		local self = {}; add = add or {}

		self.ref = ref
		self.name, self.type = ui.name(ref), ui.type(ref)

		--
		registry[ref] = registry[ref] or {
			type = self.type, ref = ref, tab = add.__tab, container = add.__container,
			__ref = add.__ref, __hidden = add.__hidden, __init = add.__init, __list = add.__list, __rage = add.__rage,
			__plist = add.__plist and not (self.type == "label" or self.type == "button" or self.type == "hotkey"),

			overridden = false, original = self.value, donotsave = add.__plist or false,
			callbacks = { [0] = add.__callback }, events = {}, depend = { [0] = {ref}, {}, {} },
		}

		registry[ref].self = setmetatable(self, methods_mt.element)
		self.value = callbacks(self, add.__ref)

		if add.__rage then
			methods_mt.element.set_callback(self, ragebot.memorize)
		end
		if registry[ref].__plist then
			players.elements[#players.elements+1] = self
			methods_mt.element.set_callback(self, players.slot_update, true)
		end

		return self
	end

	elemence.group = function (...)
		return setmetatable({ ... }, methods_mt.group)
	end

	elemence.string = function (name, default)
		local this = {}

		this.ref = ui.new_string(name, default or "")
		this.type = "string"
		this[0] = {savable = true}

		return setmetatable(this, methods_mt.element)
	end

	elemence.features = function (self, args)
		do
			local addition
			local v, kind = args[1], type(args[1])

			if not addition and (kind == "table" or kind == "cdata") and not v.r then
				addition = "color"
				local r, g, b, a = v[1] or 255, v[2] or 255, v[3] or 255, v[4] or 255
				self.color = elemence.new( ui.new_color_picker(registry[self.ref].tab, registry[self.ref].container, self.name, r, g, b, a), {
					__init = { r, g, b, a },
					__plist = registry[self.ref].__plist
				} )
			elseif not addition and (kind == "table" or kind == "cdata") and v.r then
				addition = "color"
				self.color = elemence.new( ui.new_color_picker(registry[self.ref].tab, registry[self.ref].container, self.name, v.r, v.g, v.b, v.a), {
					__init = { v.r, v.g, v.b, v.a },
					__plist = registry[self.ref].__plist
				} )
			elseif not addition and kind == "number" then
				addition = "hotkey"
				self.hotkey = elemence.new( ui.new_hotkey(registry[self.ref].tab, registry[self.ref].container, self.name, true, v, {
					__init = v
				}) )
			end
			registry[self.ref].depend[0][2] = addition and self[addition].ref
			registry[self.ref].__addon = addition
		end
		do
			registry[self.ref].donotsave = args[2] == false
		end
	end

	elemence.memorize = function (self, path, origin)
		if registry[self.ref].donotsave then return end

		if not elements[self.type].unsavable then
			dirs.pave(origin, self.ref, path)
		end

		if self.color then
			path[#path] = path[#path] .. "_c"
			dirs.pave(origin, self.color.ref, path)
		end
		if self.hotkey then
			path[#path] = path[#path] .. "_h"
			dirs.pave(origin, self.hotkey.ref, path)
		end
	end

	elemence.hidden_refs = {
		"Unlock hidden cvars", "Allow custom game events", "Faster grenade toss",
		"sv_maxunlag", "sv_maxusrcmdprocessticks", "sv_clockcorrection_msecs", -- m4kb12jk
	}

	--#region: depend

	local cases = {
		combobox = function (v)
			if v[3] == true then
				return v[1].value ~= v[2]
			else
				for i = 2, #v do
					if v[1].value == v[i] then return true end
				end
			end
			return false
		end,
		listbox = function (v)
			if v[3] == true then
				return v[1].value ~= v[2]
			else
				for i = 2, #v do
					if v[1].value == v[i] then return true end
				end
			end
			return false
		end,
		multiselect = function (v)
			return table.ihas(v[1].value, unpack(v, 2))
		end,
		slider = function (v)
			return v[2] <= v[1].value and v[1].value <= (v[3] or v[2])
		end,
	}

	local depend = function (v)
		local condition = false

		if type(v[2]) == "function" then
			condition = v[2]( v[1] )
		else
			local f = cases[v[1].type]
			if f then condition = f(v)
			else condition = v[1].value == v[2] end
		end

		return condition and true or false
	end

	elemence.dependant = function (owner, dependant, dis)
		local count = 0

		for i = 1, #owner do
			if depend(owner[i]) then count = count + 1 else break end
		end

		local allow, action = count >= #owner, dis and "set_enabled" or "set_visible"

		for i, v in ipairs(dependant) do ui[action](v, allow) end
	end

	--#endregion
end

--#endregion

--#region: utils

local utils = {}

do
	utils.rgb_to_hex = function (color)
		return string.format("%02X%02X%02X%02X", color[1], color[2], color[3], color[4] or 255)
	end

	utils.hex_to_rgb = function (hex)
		hex = hex:gsub("^#", "")
		return tonumber(hex:sub(1, 2), 16), tonumber(hex:sub(3, 4), 16), tonumber(hex:sub(5, 6), 16), tonumber(hex:sub(7, 8), 16) or 255
	end

	utils.gradient_text = function (text, colors, precision)
		local symbols, length = {}, #string.gsub(text, ".[\128-\191]*", "a")
		local s = 1 / (#colors - 1)
		precision = precision or 1

		local i = 0
		for letter in string.gmatch(text, ".[\128-\191]*") do
			i = i + 1

			local weight = i / length
			local cw = weight / s
			local j = math.ceil(cw)
			local w = (cw / j)
			local L, R = colors[j], colors[j+1]

			local r = L[1] + (R[1] - L[1]) * w
			local g = L[2] + (R[2] - L[2]) * w
			local b = L[3] + (R[3] - L[3]) * w
			local a = L[4] + (R[4] - L[4]) * w

			symbols[#symbols+1] = ((i-1) % precision == 0) and ("\a%02x%02x%02x%02x%s"):format(r, g, b, a, letter) or letter
		end

		symbols[#symbols+1] = "\aCDCDCDFF"

		return table.concat(symbols)
	end

	local gradients = function (col, text)
		local colors = {}; for w in string.gmatch(col, "\b%x+") do
			colors[#colors+1] = { utils.hex_to_rgb( string.sub(w, 2) ) }
		end
		if #colors > 0 then return utils.gradient_text(text, colors, #text > 8 and 2 or 1) end
	end

	utils.format = function (s)
		if type(s) == "string" then
			s = string.gsub(s, "\f<(.-)>", pui.macros)
			s = string.gsub(s, "[\v\r\t]", {["\v"] = "\a".. pui.accent, ["\r"] = "\aCDCDCDFF", ["\t"] = "    "})
			s = string.gsub(s, "([\b%x]-)%[(.-)%]", gradients)
		end return s
	end

	utils.unpack_color = function (...)
		local arg = {...}
		local kind = type(arg[1])

		if kind == "table" or kind == "cdata" or kind == "userdata" then
			if arg[1].r then
				return {arg[1].r, arg[1].g, arg[1].b, arg[1].a}
			elseif arg[1][1] then
				return {arg[1][1], arg[1][2], arg[1][3], arg[1][4]}
			end
		end

		return arg
	end

	--#region: dispense

	local dispensers = {
		color_picker = function (args)
			args[1] = string.sub(utils.format(args[1]), 1, 117)

			if type(args[2]) ~= "number" then
				local col = args[2]
				args.n, args.req, args[2] = args.n + 3, args.req + 3, col.r
				table.insert(args, 3, col.g)
				table.insert(args, 4, col.b)
				table.insert(args, 5, col.a)
			end

			for i = args.req + 1, args.n do
				args.misc[i - args.req] = args[i]
			end

			args.data.__init = {args[2] or 255, args[3] or 255, args[4] or 255, args[5] or 255}
		end,
		listbox = function (args, variable)
			args[1] = string.sub(utils.format(args[1]), 1, 117)
			for i = args.req + 1, args.n do
				args.misc[i - args.req] = args[i]
			end

			args.data.__init, args.data.__list = 0, not variable and args[2] or {unpack(args, 2, args.n)}
		end,
		combobox = function (args, variable)
			args[1] = string.sub(utils.format(args[1]), 1, 117)
			for i = args.req + 1, args.n do
				args.misc[i - args.req] = args[i]
			end

			args.data.__init, args.data.__list = not variable and args[2][1] or args[2], not variable and args[2] or {unpack(args, 2, args.n)}
		end,
		multiselect = function (args, variable)
			args[1] = string.sub(utils.format(args[1]), 1, 117)
			for i = args.req + 1, args.n do
				args.misc[i - args.req] = args[i]
			end

			args.data.__init, args.data.__list = {}, not variable and args[2] or {unpack(args, 2, args.n)}
		end,
		slider = function (args)
			args[1] = string.sub(utils.format(args[1]), 1, 117)

			for i = args.req + 1, args.n do
				args.misc[i - args.req] = args[i]
			end

			args.data.__init = args[4] or args[2]
		end,
		button = function (args)
			args[2] = args[2] or function()end
			args[1] = string.sub(utils.format(args[1]), 1, 117)
			args.n, args.data.__callback = 2, args[2]
		end
	}

	utils.dispense = function (key, raw, ...)
		local args, group, ctx = {...}, {}, elements[key]

		if type(raw) == "table" then
			group[1], group[2] = raw[1], raw[2]
			group.__plist = raw.__plist
		else
			group[1], group[2] = raw, args[1]
			table.remove(args, 1)
		end

		args.n, args.data = table.maxn(args), {
			__tab = group[1], __container = group[2],
			__plist = group.__plist and true or nil
		}

		local variable = (ctx and ctx.variable) and type(args[2]) == "string"
		args.req, args.misc = not variable and ctx.arg or args.n, {}

		if dispensers[key] then
			dispensers[key](args, variable)
		else
			for i = 1, args.n do
				if type(args[i]) == "string" then
					args[i] = string.sub(utils.format(args[i]), 1, 117)
				end

				if i > args.req then args.misc[i - args.req] = args[i] end
			end
			args.data.__init = ctx.init
		end

		return args, group
	end

	--#endregion
end

--#endregion

-- #endregion
--


-- #endregion -----------------------------------------------------------
--


-------------------------------------------------------------------------
-- #region :: pui


--
-- #region : pui

--#region: variables

pui.macros = setmetatable({}, {
	__newindex = function (self, key, value) rawset(self, tostring(key), value) end,
	__index = function (self, key) return rawget(self, tostring(key)) end
})

pui.accent, pui.menu_open = nil, ui.is_menu_open()

do
	local reference = ui.reference("MISC", "Settings", "Menu color")
	pui.accent = utils.rgb_to_hex{ ui.get(reference) }
	local previous = pui.accent

	ui.set_callback(reference, function ()
		local color = { ui.get(reference) }
		pui.accent = utils.rgb_to_hex(color)

		for idx, ref in next, registry do
			if ref.type == "label" and not ref.__ref then
				local new, count = string.gsub(ref.self.value, previous, pui.accent)
				if count > 0 then
					ui.set(idx, new)
					ref.self.value = new
				end
			end
		end
		previous = pui.accent
		client.fire_event("pui::accent_color", color)
	end)
end

client.set_event_callback("paint_ui", function ()
	local state = ui.is_menu_open()
	if state ~= pui.menu_open then
		client.fire_event("pui::menu_state", state)
		pui.menu_open = state
	end
end)

--#endregion

--#region: features

pui.group = function (tab, container) return elemence.group(tab, container) end

pui.format = utils.format

pui.reference = function (tab, container, name)
	local found = { contend(ui.reference, 3, tab, container, name) }
	local total, hidden = #found, false

	-- done on purpose, don't blame me
	if string.lower(tab) == "misc" and string.lower(container) == "settings" then
		for i, v in ipairs(elemence.hidden_refs) do
			if string.find(name, "^" ..v) then hidden = true break end
		end
	end

	for i, v in ipairs(found) do
		found[i] = elemence.new(v, {
			__ref = true, __hidden = hidden or nil,
			__tab = tab, __container = container,
			__rage = string.lower(container) == "aimbot" or nil,
		})
	end

	if total > 1 then local shift = 0
		for i = 1, total > 4 and total or 4, 2 do
			local m, j = i - shift, i + 1 - shift
			if found[j] and (found[j].type == "hotkey" or found[j].type == "color_picker") then
				local addition = found[j].type == "color_picker" and "color" or "hotkey"
				registry[ found[m].ref ].__addon, found[m][addition] = addition, found[j]

				table.remove(found, j) shift = shift + 1
			end
		end return unpack(found)
	else return found[1] end
end

pui.traverse = function (t, f, p)
	p = p or {}

	if type(t) == "table" and t.__name ~= "pui::element" and t[#t] ~= "~" then
		for k, v in next, t do
			local np = table.copy(p); np[#np+1] = k
			pui.traverse(v, f, np)
		end
	else
		f(t, p)
	end
end

--#endregion

--#region: config system

do
	local save = function (config, ...)
		local packed = {}

		pui.traverse(dirs.extract(config, {...}), function (ref, path)
			local value
			local etype = registry[ref].type

			if etype == "color_picker" then
				value = "#".. utils.rgb_to_hex{ ui.get(ref) }
			elseif etype == "hotkey" then
				local _, mode, key = ui.get(ref)
				value = {mode, key or 0}
			else
				value = ui.get(ref)
			end

			if type(value) == "table" then value[#value+1] = "~" end
			dirs.pave(packed, value, path)
		end)

		return packed
	end

	local load = function (config, package, ...)
		if not package then return end

		local packed = dirs.extract(package, {...})
		pui.traverse(dirs.extract(config, {...}), function (ref, path)
			pcall(function ()
				local value, proxy = dirs.find(packed, path), registry[ref]
				local vtype, etype = type(value), proxy.type
				local object = elements[etype]

				if vtype == "string" and value:sub(1, 1) == "#" then
					value, vtype = { utils.hex_to_rgb(value) }, "table"
				elseif vtype == "table" and value[#value] == "~" then
					value[#value] = nil
				end

				if etype == "hotkey" and value and type(value[1]) == "number" then
					value[1] = elements.hotkey.enum[ value[1] ]
				end

				if object and object.type == vtype then
					if vtype == "table" and etype ~= "multiselect" then
						ui.set(ref, unpack(value))
						if etype == "color_picker" then methods_mt.element.invoke(proxy.self) end
					else
						ui.set(ref, value)
					end
				else
					if proxy.__init then ui.set(ref, proxy.__init) end
				end
			end)
		end)
	end

	--
	local package_mt = {
		__type = "pui::package", __metatable = false,
		__call = function (self, raw, ...)
			return (type(raw) == "table" and load or save)(self[0], raw, ...)
		end,
		save = function (self, ...) return save(self[0], ...) end,
		load = function (self, ...) load(self[0], ...) end,
	}	package_mt.__index = package_mt

	pui.setup = function (t)
		local package = { [0] = {} }
		pui.traverse(t, function (r, p) elemence.memorize(r, p, package[0]) end)
		return setmetatable(package, package_mt)
	end
end

--#endregion

-- #endregion
--

--
-- #region : methods

methods_mt.element = {
	__type = "pui::element", __name = "pui::element", __metatable = false,
	__eq = function (this, that) return this.ref == that.ref end,
	__tostring = function (self) return string.format('pui.%s[%d] "%s"', self.type, self.ref, self.name) end,
	__call = function (self, ...) if #{...} > 0 then ui.set(self.ref, ...) else return ui.get(self.ref) end end,

	--

	depend = function (self, ...)
		local arg = {...}
		local disabler = arg[1] == true

		local depend = registry[self.ref].depend[disabler and 2 or 1]
		local this = registry[self.ref].depend[0]

		for i = (disabler and 2 or 1), table.maxn(arg) do
			local v = arg[i]
			if v then
				if v.__name == "pui::element" then v = {v, true} end
				depend[#depend+1] = v

				local check = function () elemence.dependant(depend, this, disabler) end
				check()

				registry[v[1].ref].callbacks[#registry[v[1].ref].callbacks+1] = check
			end
		end

		return self
	end,

	override = function (self, value)
		local ctx, wctx = registry[self.ref], ragebot.context[ragebot.ref.value]

		if value ~= nil then
			if not ctx.overridden then
				if self.type == "hotkey" then self.value = { ui.get(self.ref) } end
				if ctx.__rage then wctx[self.ref] = self.value else ctx.original = self.value end
			end ctx.overridden = true
			if ctx.__rage then ctx.__ovr_v = value end
			ui_mset(self.ref, value)
		else
			if ctx.overridden then
				local original = ctx.original if ctx.__rage then original, ctx.__ovr_v = wctx[self.ref], nil end
				ui_mset(self.ref, original)
				ctx.overridden = false
			end
		end
	end,
	get_original = function (self)
		if registry[self.ref].overridden then
			if registry[self.ref].__rage then
				return ragebot.context[ragebot.ref.value][self.ref]
			else
				return registry[self.ref].original
			end
		else return self.value end
	end,

	--

	set = function (self, ...)
		if self.type == "color_picker" then
			ui.set(self.ref, unpack(utils.unpack_color(...)) )
			methods_mt.element.invoke(self)
		elseif self.type == "label" then
			local t = utils.format(...)
			ui.set(self.ref, t)
			self.value = t
		else
			ui.set(self.ref, ...)
		end
	end,
	get = function (self, value)
		if value and self.type == "multiselect" then
			return registry[self.ref].options[value] or false
		end
		return ui.get(self.ref)
	end,

	reset = function (self) if registry[self.ref].__init then ui.set(self.ref, registry[self.ref].__init) end end,

	update = function (self, t)
		ui.update(self.ref, t)
		registry[self.ref].__list = t

		local cap = #t-1
		if ui.get(self.ref) > cap then ui.set(self.ref, cap) end
	end,
	get_list = function (self) return registry[self.ref].__list end,

	is_active = function (self)
		return self.value and ui.get(self.hotkey.ref)
	end,
	get_color = function (self)
		if registry[self.ref].__addon then return ui.get(self.color.ref) end
	end,
	set_color = function (self, ...)
		if registry[self.ref].__addon then methods_mt.element.set(self.color, ...) end
	end,
	get_hotkey = function (self)
		if registry[self.ref].__addon then return ui.get(self.hotkey.ref) end
	end,
	set_hotkey = function (self, ...)
		if registry[self.ref].__addon then methods_mt.element.set(self.hotkey, ...) end
	end,

	is_reference = function (self) return registry[self.ref].__ref or false end,
	get_type = function (self) return self.type end,
	get_name = function (self) return self.name end,

	set_visible = function (self, visible)
		ui.set_visible(self.ref, visible)
		if registry[self.ref].__addon then ui.set_visible(self[registry[self.ref].__addon].ref, visible) end
	end,
	set_enabled = function (self, enabled)
		ui.set_enabled(self.ref, enabled)
		if registry[self.ref].__addon then ui.set_enabled(self[registry[self.ref].__addon].ref, enabled) end
	end,

	set_callback = function (self, func, once)
		if once == true then func(self) end
		registry[self.ref].callbacks[#registry[self.ref].callbacks+1] = func
	end,
	unset_callback = function (self, func)
		table.remove(registry[self.ref].callbacks, table.qfind(registry[self.ref].callbacks, func) or 0)
	end,
	invoke = function (self, ...)
		for i = 0, #registry[self.ref].callbacks do registry[self.ref].callbacks[i](self, ...) end
	end,

	set_event = function (self, event, func, condition)
		local slot = registry[self.ref]
		if condition == nil then condition = true end
		local is_cond_fn, latest = type(condition) == "function", nil
		slot.events[func] = function (this)
			local permission if is_cond_fn then permission = condition(this) else permission = this.value == condition end

			local action = permission and client.set_event_callback or client.unset_event_callback
			if latest ~= permission then action(event, func) latest = permission end
		end
		slot.events[func](self)
		slot.callbacks[#slot.callbacks+1] = slot.events[func]
	end,
	unset_event = function (self, event, func)
		client.unset_event_callback(event, func)
		methods_mt.element.unset_callback(self, registry[self.ref].events[func])
		registry[self.ref].events[func] = nil
	end,

	get_location = function (self) return registry[self.ref].tab, registry[self.ref].container end,
}	methods_mt.element.__index = methods_mt.element

methods_mt.group = {
	__name = "pui::group",
	__metatable = false,
	__index = function (self, key) return rawget(methods_mt.group, key) or pui_mt.__index(self, key) end,
	get_location = function (self) return self[1], self[2] end
}

-- #endregion
--

--
-- #region : pui_mt, ragebot and plist handler

do
	local cached = {}
	for k, v in next, elements do
		cached[k] = function (origin, ...)
			local args, group = utils.dispense(k, origin, ...)
			local this = elemence.new( contend(ui["new_".. k], 3, group[1], group[2], unpack(args, 1, args.n < args.req and args.n or args.req)), args.data )

			elemence.features(this, args.misc)
			return this
		end
	end

	pui_mt.__name, pui_mt.__metatable = "pui::basement", false
	pui_mt.__index = function (self, key)
		if not elements[key] then return ui[key] end
		if key == "string" then return elemence.string end

		return cached[key]
	end
end


--#region: ragebot handler

ragebot = {
	ref = pui.reference("RAGE", "Weapon type", "Weapon type"),
	context = {}, cache = {},
	silent = false,
} do
	local previous, cycle_action = ragebot.ref.value, nil
	for i, v in ipairs(weapons) do ragebot.context[v], ragebot.cache[v] = {}, {} end

	local neutral = ui.reference("RAGE", "Aimbot", "Enabled")
	ui.set_callback(neutral, function ()
		if not ragebot.silent then client.delay_call(0, client.fire_event, "pui::adaptive_weapon", ragebot.ref.value, previous) end
		if cycle_action then cycle_action(ragebot.ref.value) end
	end)

	ragebot.cycle = function (fn, mute)
		cycle_action = mute and fn or nil
		ragebot.silent = mute and true or false

		for i, v in ipairs(weapons) do
			ragebot.ref:override(v)
		end

		ragebot.ref:override()
		cycle_action, ragebot.silent = nil, false
	end

	ui.set_callback(ragebot.ref.ref, function (self)
		ragebot.ref.value = ui.get(self)

		if not ragebot.silent and previous ~= ragebot.ref.value then
			for i = 1, #registry[self].callbacks, 1 do registry[self].callbacks[i](ragebot.ref) end
		end

		previous = ragebot.ref.value
	end)

	local memorize = function (self)
		local ctx = ragebot.context[ragebot.ref.value]
		if registry[self.ref].overridden then
			if ctx[self.ref] == nil then
				ctx[self.ref] = self.value
				ui_mset(self.ref, registry[self.ref].__ovr_v)
			end
		else
			if ctx[self.ref] then
				ui_mset(self.ref, ctx[self.ref])
				ctx[self.ref] = nil
			end
		end
	end

	client.set_event_callback("pui::adaptive_weapon", function (cur, prev)
		for k, v in next, registry do
			if v.__rage then memorize(v.self) end
		end
	end)

	ragebot.memorize = function (self) end
end

--#endregion

--#region: plist handler

players = {
	elements = {}, list = {},
} do
	--#region: stuff

	pui.plist = elemence.group("PLAYERS", "Adjustments")
	pui.plist.__plist = true

	local selected = 0
	local refs, slot = {
		list = pui.reference("PLAYERS", "Players", "Player list"),
		reset = pui.reference("PLAYERS", "Players", "Reset all"),
		apply = pui.reference("PLAYERS", "Adjustments", "Apply to all"),
	}, {}

	--#endregion

	--#region: slot metatable

	local slot_mt = {
		__type = "pui::player_slot", __metatable = false,
		__tostring = function (self)
			return string.format("pui::player_slot[%d] of %s", self.idx, methods_mt.element.__tostring(registry[self.ref].self))
		end,
		set = function (self, ...) -- don't mind
			local ctx, value = registry[self.ref], {...}

			local is_colorpicker = ctx.type == "color_picker"
			if is_colorpicker then
				value = utils.unpack_color(...)
			end

			if self.idx == selected then
				ui.set( self.ref, unpack(value) )
				if is_colorpicker then
					methods_mt.element.invoke(ctx.self)
				end
			else
				self.value = is_colorpicker and value or unpack(value)
			end
		end,
		get = function (self, find)
			if find and registry[self.ref].type == "multiselect" then
				return table.qfind(self.value, find) ~= nil
			end

			if registry[self.ref].type ~= "color_picker" then return self.value
			else return unpack(self.value) end
		end,
	}	slot_mt.__index = slot_mt

	--#endregion

	--#region: slots handling stuff

	players.traverse = function (fn) for i, v in ipairs(players.elements) do fn(v) end end

	slot = {
		select = function (idx)
			if not idx then return end
			for i, v in ipairs(players.elements) do
				methods_mt.element.set(v, v[idx].value)
			end
		end,
		add = function (idx)
			if not idx then return end
			for i, v in ipairs(players.elements) do
				local default = ternary(registry[v.ref].__init ~= nil, registry[v.ref].__init, v.value)
				v[idx], players.list[idx] = setmetatable({
					ref = v.ref, idx = idx, value = default
				}, slot_mt), true
			end
		end,
		remove = function (idx)
			if not idx then return end
			for i, v in ipairs(players.elements) do
				v[idx], players.list[idx] = nil, nil
			end
		end,
	}

	players.slot_update = function (self)
		if self[selected] then self[selected].value = self.value
		else slot.add(selected) end
	end

	--#endregion

	--#region: callbacks

	local silent = false
	local update = function (e)
		selected = ui.get(refs.list.ref)

		local new, old = entity.get_players(), players.list
		local me = entity.get_local_player()

		for idx, v in next, old do
			if entity.get_classname(idx) ~= "CCSPlayer" then
				slot.remove(idx)
			end
		end

		for i, idx in ipairs(new) do
			if idx ~= me and not players.list[idx] and entity.get_classname(idx) == "CCSPlayer" then
				slot.add(idx)
			end
		end

		if not silent and not e.value then
			for i = #new, 1, -1 do
				if new[i] ~= me then ui.set(refs.list.ref, new[i]) break end
			end
			client.update_player_list()
			silent = true
		else
			silent = false
		end

		slot.select(selected)
		client.fire_event("pui::plist_update", selected)
	end

	do
		local function once ()
			update{}
			client.unset_event_callback("pre_render", once)
		end
		client.set_event_callback("pre_render", once)
	end
	methods_mt.element.set_callback(refs.list, update, true)
	client.set_event_callback("player_connect_full", update)
	client.set_event_callback("player_disconnect", update)
	client.set_event_callback("player_spawned", update)
	client.set_event_callback("player_spawn", update)
	client.set_event_callback("player_death", update)
	client.set_event_callback("player_team", update)

	--

	methods_mt.element.set_callback(refs.apply, function ()
		players.traverse(function (v)
			for idx, _ in next, players.list do
				v[idx].value = v[selected].value
			end
		end)
	end)
	methods_mt.element.set_callback(refs.reset, function ()
		players.traverse(function (v)
			for idx, _ in next, players.list do
				if idx == selected then
					slot_mt.set(v[idx], registry[v.ref].__init)
				else
					v[idx].value = registry[v.ref].__init
				end
			end
		end)
	end)

	--#endregion
end

--#endregion

-- #endregion
--


-- #endregion -----------------------------------------------------------
--


return setmetatable(pui, pui_mt)