Commands

local Functions = Arsenic.Functions
local Environment = Arsenic.Environment
local Graphics = Arsenic.Graphics

local Local = Functions.Local
local Players = Functions.Players
local Server = Functions.Server
local Vehicles = Functions.Vehicles
local Particles = Functions.Particles
local Banishment = Functions.Banishment
local Weapons = Functions.Weapons
local Structures = Functions.Structures
local Cloning = Functions.Cloning

local Tabs = Graphics.Interface.Drag.Body.Tabs

local Commands = {}

local function RunList(list, func, ...)
    local Vargs = {...}
    for i,v in next, list do
        spawn(function()
            func(v, unpack(Vargs))
        end)
    end
end

local function RunListAsync(list, func, ...)
    local Vargs = {...}
    for i,v in next, list do
        func(v, unpack(Vargs))
    end
end

local function FindPlayer(player)
    local Caller = Environment.GetLocals(2).caller

    local PlayerOptions = {
        me = Caller,
        others = (function()
            local Return = {}
            for i,v in next, game:GetService('Players'):GetPlayers() do
                if v ~= Caller then
                    table.insert(Return, v)
                end
            end
            return Return
        end)(),
        all = game:GetService('Players'):GetPlayers()
    }

    local Option = rawget(PlayerOptions, player)
    if Option then
        return Option
    end

    return Arsenic.Find(game:GetService('Players'):GetPlayers(), player)
end

local function FindMaterial(material)
    local Materials = {
    "Plastic",
    "Wood",
    "Slate",
    "Concrete",
    "CorrodedMetal",
    "DiamondPlate",
    "Foil",
    "Grass",
    "Ice",
    "Marble",
    "Granite",
    "Brick",
    "Pebble",
    "Sand",
    "Fabric",
    "SmoothPlastic",
    "Metal",
    "WoodPlanks",
    "Cobblestone",
    "Neon",
    "Glass"}
    for i,v in next, Materials do
        if v:sub(1, material:len()):lower() == material:lower() then
            return v
        end
    end
end

local function FindItem(item)
    if item:lower() == 'all' then
        return game:GetService('Lighting').LootDrops:GetChildren()
    end

    if item:lower() == 'm14' then
        if Arsenic.Environment.Place ~= 'Mods' then
            return 'M14'
        end
        return game:GetService('Lighting').LootDrops.M14
    end

    if Arsenic.Environment.Place ~= 'Mods' then
        return Arsenic.Find(game:GetService('Lighting').LootDrops:GetChildren(), item)
    else
        return Arsenic.FindRaw(game:GetService('Lighting').LootDrops:GetChildren(), item)
    end
end

local function FindVehicle(vehicle)
    if vehicle:lower() == 'all' then
        return workspace.Vehicles:GetChildren()
    end

    return Arsenic.Find(workspace.Vehicles:GetChildren(), vehicle)
end

local function FindWeapon(player, weapon)
    for i,v in next, player.Backpack:GetChildren() do
        if v:FindFirstChild('Shooter') and v.Name:sub(1, weapon:len()):lower() == weapon:lower() then
            return v
        end
    end
end

local function FindCity(city)
    return Arsenic.Find(workspace['Anchored Objects']['Towns/Cities']:GetChildren(), city)
end

local function FindLocation(location)
    return Arsenic.Find(workspace.Locations:GetChildren(), location)
end

local function FindDeletedVehicle(vehicle)
    local vehicles = {}
    for i,v in next, game:GetService('ReplicatedStorage'):GetChildren() do
        if v:FindFirstChild('Seats') then
            table.insert(vehicles, v)
        end
    end

    if item:lower() == 'all' then
        return vehicles
    end

    return Arsenic.Find(vehicles, vehicle)
end

local function AppendChecks(checks)
    local function GetRank(player)
        local Ranks = {
            Normie = 1,
            Mod = 2,
            Admin = 3,
            Root = 4
        }
        return rawget(Ranks, Arsenic.GetRank(player))
    end

    local Caller = Environment.GetLocals(2).caller
    local Player = Environment.GetLocals(2).player

    if (checks.HierarchyCheck and (GetRank(Caller) < GetRank(Player)))
    or (checks.RootCheck and (Caller ~= Arsenic.Client))
    or (checks.AllCheck and (rawget(checks, 1) == 'all' or rawget(checks, 1) == 'others'))
    or (checks.ValueCheck and not rawget(checks, 1)) then
        return
    end

    return true
end

local function TickCheck(check, value)
    if not value then
        check.Label.Font = 'SourceSansSemibold'
        check.Text = ''
        return
    end
    check.Label.Font = 'SourceSansBold'
    check.Text = '✓'
end

-- Commands

-- Local
function Commands.cmds(caller)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end
    Graphics.Interface.DragC.Visible = true
end

function Commands.setprefix(caller, new)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end

    if new:len() ~= 1 then
        return 'Prefix must be, exactly, ONE character'
    end

    Arsenic.Variables.Prefix = new
    return 'Set chat prefix to ' .. new
end

function Commands.ws(caller, value)
    value = tonumber(value)
    if not AppendChecks({RootCheck = true, ValueCheck = true, value}) then
        return 'Invalid caller/arguments'
    end

    Local.SetWalkSpeed(value)
    return 'Set client speed to ' .. value
end

function Commands.jp(caller, value)
    value = tonumber(value)
    if not AppendChecks({RootCheck = true, ValueCheck = true, value}) then
        return 'Invalid caller/arguments'
    end

    Local.SetJumpPower(value)
    return 'Set client jump power to ' .. value
end

function Commands.unlockcam(caller)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end

    Local.SetZoom(133742069)
    return 'Unlocked client\'s max camera zoom'
end

function Commands.nofog(caller)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end

    Local.SetFog(133742069)
    return 'Removed client\'s fog'
end

function Commands.heal(caller)
    if not AppendChecks{RootCheck = true} then
        return 'Invalid caller'
    end

    Arsenic('AddHealth', 100, 0)
    return 'Healed client'
end

function Commands.fly(caller)
    if not AppendChecks{RootCheck = true} then
        return 'Invalid caller'
    end

    if Arsenic.Loops.Flying then
        return 'Flight is already enabled'
    end

    TickCheck(Tabs.Local.Toggles.Fly, true)
    spawn(function() Local.Fly(true) end)
    return 'Enabled client flight'
end

function Commands.unfly(caller)
    if not AppendChecks{RootCheck = true} then
        return 'Invalid caller'
    end

    if not Arsenic.Loops.Flying then
        return 'Flight is not enabled'
    end

    TickCheck(Tabs.Local.Toggles.Fly, false)
    Local.Fly(false)
    return 'Disabled client flight'
end

function Commands.spec(caller, player)
    if not AppendChecks({RootCheck = true, AllCheck = true, player}) then
        return 'Invalid caller/arguments'
    end

    player = FindPlayer(player)

    Local.Spectate(player)
    return 'Spectating ' .. player.Name
end

function Commands.glowstick(caller)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end

    if Arsenic.Loops.Glowstick then
        return 'Glowstick is already enabled'
    end

    TickCheck(Tabs.Local.Toggles.Glowstick, true)
    Local.Glowstick(true)
    return 'Enabled client glowstick effect'
end

function Commands.unglowstick(caller)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end

    if not Arsenic.Loops.Glowstick then
        return 'Glowstick is not enabled'
    end

    TickCheck(Tabs.Local.Toggles.Glowstick, false)
    Local.Glowstick(false)
    return 'Disabled client glowstick effect'
end

function Commands.autoheal(caller)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end

    Local.Autoheal(true)
    return 'Enabled client auto-heal'
end

function Commands.noautoheal(caller)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end

    Local.Autoheal(false)
    return 'Disabled client auto-heal'
end

function Commands.admin(caller, player)
    if not AppendChecks({RootCheck = true, AllCheck = true, player}) then
        return 'Invalid caller/arguments'
    end
    player = FindPlayer(player)
    Players.SetAdmin(player, true)
    return 'Gave admin perms to ' .. player.Name
end

function Commands.mod(caller, player)
    if not AppendChecks({RootCheck = true, AllCheck = true, player}) then
        return 'Invalid caller/arguments'
    end
    player = FindPlayer(player)
    Players.SetMod(player, true)
    return 'Gave mod perms to ' .. player.Name
end

function Commands.unadmin(caller, player)
    if not AppendChecks({RootCheck = true, AllCheck = true, player}) then
        return 'Invalid caller/arguments'
    end
    player = FindPlayer(player)
    Players.SetAdmin(player, false)
    return 'Removed admin perms from' .. player.Name
end

function Commands.unmod(caller, player)
    if not AppendChecks({RootCheck = true, AllCheck = true, player}) then
        return 'Invalid caller/arguments'
    end
    player = FindPlayer(player)
    Players.SetMod(player, false)
    return 'Removed mod perms from ' .. player.Name
end

-- Players

function Commands.shirt(caller, player, id)
    id = tonumber(id)
    if not AppendChecks({ValueCheck = true, id}) then
        return 'Invalid ID value'
    end

    player = FindPlayer(player)

    if type(player) == 'table' then
        RunListAsync(player, Players.Shirt, id)
        return 'Changed everybody\'s shirt ID to ' .. id
    end

    Players.Shirt(player, id)
    return 'Changed ' .. player.Name .. '\'s shirt ID to ' .. id
end

function Commands.pants(caller, player, id)
    id = tonumber(id)
    if not AppendChecks({ValueCheck = true, id}) then
        return 'Invalid ID value'
    end

    player = FindPlayer(player)

    if type(player) == 'table' then
        RunListAsync(player, Players.Pants, id)
        return 'Changed everybody\'s pants ID to ' .. id
    end

    Players.Pants(player, id)
    return 'Changed ' .. player.Name .. '\'s pants ID to ' .. id
end

function Commands.tp(caller, player, player2)
    if not AppendChecks({HierarchyCheck = true, AllCheck = true, player2}) then
        return 'Invalid arguments'
    end

    player = FindPlayer(player)
    player2 = FindPlayer(player2)

    if type(player) == 'table' then
        RunList(player, Players.Teleport, player2)
        return 'Teleported players to ' .. player2.Name
    end

    Players.Teleport(player, player2)
    return 'Teleported ' .. player.Name .. ' to ' .. player2.Name
end

function Commands.loc(caller, player, location)
    player = FindPlayer(player)
    location = FindLocation(location)

    if type(player) == 'table' then
        RunList(player, Players.Teleport, location, true)
        return 'Teleported players to ' .. location.Name
    end

    Players.Teleport(player, location, true)
    return 'Teleported ' .. player.Name .. ' to ' .. location.Name
end

function Commands.hunger(caller, player, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid value'
    end

    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(Player, Players.SetHunger, value)
        return 'Set all players\'s hunger to ' .. value
    end

    Players.SetHunger(player, value)
    return 'Set ' .. player.Name .. '\'s hunger to ' .. value
end

function Commands.thirst(caller, player, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid value'
    end

    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(player, Players.SetThirst, value)
        return 'Set all players\'s thirst to ' .. value
    end

    Players.SetThirst(player, value)
    return 'Set ' .. player.Name .. '\'s thirst to ' .. value
end

function Commands.infvitals(caller, player)
    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(player, Players.SetHunger, 99999)
        return 'Set all players\'s vitals to 99999'
    end

    Players.SetThirst(player, 99999)
    Players.SetHunger(player, 99999)
    return 'Set ' .. player.Name .. '\'s vitals to 99999'
end

function Commands.stamina(caller, player, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid value'
    end

    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(Player, Players.SetStamina, value)
        return 'Set all players\'s stamina to ' .. value
    end

    Players.SetStamina(player, value)
    return 'Set ' .. player.Name .. '\'s stamina to ' .. value
end

function Commands.clog(caller, player)
    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(player, Players.CombatLog, true)
        return 'Combat logged players'
    end

    Players.CombatLog(player, true)
    return 'Combat logged ' .. player.Name
end

function Commands.days(caller, player, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid value'
    end

    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(player, Players.SetDays, value)
        return 'Set all players\'s days to ' .. value
    end

    Players.SetDays(player, value)
    return 'Set ' .. player.Name .. '\'s days to ' .. value
end

function Commands.pkills(caller, player, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid value'
    end

    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(player, Players.SetPlayers, value)
        return 'Set all players\'s player kills to ' .. value
    end

    Players.SetPlayers(player, value)
    return 'Set ' .. player.Name .. '\'s player kills to ' .. value
end

function Commands.zkills(caller, player, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid value'
    end

    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(player, Players.SetZombies, value)
        return 'Set all players\'s zombie kills to ' .. value
    end

    Players.SetZombies(player, value)
    return 'Set ' .. player.Name .. '\'s zombie kills to ' .. value
end

-- Server

function Commands.lootmod(caller, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid arguments'
    end

    Server.LootRate(value)
    return 'Changed server loot rate to ' .. value
end

function Commands.spawn(caller, player, item, amount)
    if not AppendChecks({AllCheck = true, item}) then
        return 'Invalid arguments'
    end

    player = FindPlayer(player)
    item = FindItem(item)
    amount = tonumber(amount)

    if not amount then
        amount = 1
    end

    if type(player) == 'table' then
        RunList(player, Server.Spawn, item, amount)
        return 'Spawned items on players'
    end
    Server.Spawn(player, item, amount)
    return 'Spawned ' .. item.Name .. ' on ' .. player.Name
end

function Commands.clearloot(caller)
    Server.ClearLoot()
    return 'Cleared all spawned loot'
end

-- Vehicles

function Commands.vspeed(caller, vehicle, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid arguments'
    end

    vehicle = FindVehicle(vehicle)

    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.Speed, value)
        return 'Set all vehicles\' speed values to ' .. value
    end

    Vehicles.Speed(vehicle, value)
    return 'Set ' .. vehicle.Name .. '\'s sped value to ' .. value
end

function Commands.vgod(caller, vehicle)
    vehicle = FindVehicle(vehicle)
    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.God)
        return 'Godded all vehicles'
    end

    Vehicles.God(vehicle)
    return 'Godded ' .. vehicle.Name
end

function Commands.vexplode(caller, vehicle)
    vehicle = FindVehicle(vehicle)
    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.Explode)
        return 'Exploded all vehicles'
    end

    Vehicles.Explode(vehicle)
    return 'Exploded ' .. vehicle.Name
end

function Commands.vtp(caller, player, vehicle)
    if not AppendChecks({AllCheck = true, vehicle}) then
        return 'Invalid arguments'
    end

    vehicle = FindVehicle(vehicle)
    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(player, Vehicles.Teleport, vehicle)
        return 'Teleported all players to ' .. vehicle.Name
    end

    Vehicles.Teleport(player, vehicle)
    return 'Teleported ' .. player.Name .. ' to ' .. vehicle.Name
end

function Commands.vbring(caller, vehicle, player)
    if not AppendChecks({AllCheck = true, player}) then
        return 'Invalid arguments'
    end

    vehicle = FindVehicle(vehicle)
    player = FindPlayer(player)

    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.Bring, player)
        return 'Brought all vehicles to ' .. player.Name
    end

    Vehicles.Bring(vehicle, player)
    return 'Brought ' .. vehicle.Name .. ' to ' .. player.Name
end

function Commands.vclone(caller, vehicle, player)
    if not AppendChecks({AllCheck = true, vehicle}) then
        return 'Invalid arguments'
    end

    vehicle = FindVehicle(vehicle)
    player = FindPlayer(player)

    if type(player) == 'table' then
        RunListAsync(player, Vehicles.Clone, vehicle)
        return 'Cloned ' .. vehicle.Name ' to players'
    end

    Vehicles.Clone(vehicle , player)
    return 'Cloned ' .. vehicle.Name .. ' to ' .. player.Name
end

function Commands.vopacity(caller, vehicle, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid parameters'
    end

    vehicle = FindVehicle(vehicle)
    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.Opacity, value)
        return 'Changed all vehicles\' opacities to ' .. value
    end

    Vehicles.Opacity(vehicle, value)
    return 'Changed ' .. vehicle.Name .. '\'s opacity to ' .. value
end

function Commands.vmat(caller, vehicle, value)
    vehicle = FindVehicle(vehicle)
    value = FindMaterial(value)

    if not value then
        return 'Invalid parameters'
    end

    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.Material, value)
        return 'Changed all vehicles\' material to ' .. value
    end

    Vehicles.Material(vehicle, value)
    return 'Changed ' .. vehicle.Name .. '\'s material to ' .. tostring(value)
end

function Commands.vbreak(caller, vehicle)
    vehicle = FindVehicle(vehicle)
    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.Break)
        return 'Broke all vehicles'
    end

    Vehicles.Break(vehicle)
    return 'Broke ' .. vehicle.Name
end

function Commands.vdelete(caller, vehicle)
    vehicle = FindVehicle(vehicle)
    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.Remove)
        return 'Deleted all vehicles'
    end

    Vehicles.Remove(vehicle)
    return 'Deleted ' .. vehicle.Name
end

function Commands.vadd(caller, vehicle)
    vehicle = FindDeletedVehicle(vehicle)
    if type(vehicle) == 'table' then
        RunList(vehicle, Vehicles.Replenish)
        return 'Replenished all deleted vehicles'
    end

    Vehicles.Replenish(vehicle)
    return 'Replenished ' .. vehicle.Name
end

-- Particles

function Commands.sparkles(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Particles.Sparkles)
        return 'Sparkles created in players'
    end

    Particles.Sparkles(player)
    return 'Sparkles create in ' .. player.Name
end

function Commands.smoke(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Particles.Smoke)
        return 'Smoke created in players'
    end

    Particles.Smoke(player)
    return 'Smoke create in ' .. player.Name
end

function Commands.fire(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Particles.Fire)
        return 'Fire created in players'
    end

    Particles.Fire(player)
    return 'Fire create in ' .. player.Name
end

function Commands.unsparkles(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Particles.Remove, 'Sparkles')
        return 'Deleted sparkles in players'
    end

    Particles.Remove(player, 'Sparkles')
    return 'Deleted sparkles in ' .. player.Name
end

function Commands.unsmoke(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Particles.Remove, 'BuildingSmoke')
        return 'Deleted smoke in players'
    end

    Particles.Remove(player, 'BuildingSmoke')
    return 'Deleted smoke in ' .. player.Name
end

function Commands.unfire(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Particles.Remove, 'FireEffect')
        return 'Deleted fire in players'
    end

    Particles.Remove(player, 'FireEffect')
    return 'Deleted fire in ' .. player.Name
end

-- Physical

function Commands.face(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Players.ShowFace, true)
        return 'Made all players\' faces visible'
    end

    Players.ShowFace(player, true)
    return 'Made ' .. player.Name .. '\'s face visible'
end

function Commands.noface(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Players.ShowFace, false)
        return 'Made all players\' faces invisible'
    end

    Players.ShowFace(player, false)
    return 'Made ' .. player.Name .. '\'s face invisible'
end

function Commands.faceswap(caller, player, player2)
    if (player == 'others' or players == 'all') or player2 == 'others' or player2 == 'all' then
        return 'Invalid parameters'
    end

    player = FindPlayer(player)
    player2 = FindPlayer(player2)

    Arsenic.Functions.Players.FaceSwap(player, player2)
    return 'Faceswapped ' .. player.Name .. ' and ' .. player2.Name
end

function Commands.vest(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Players.ShowVest, true)
        return 'Made all players\' vests visible'
    end

    Players.ShowVest(player, true)
    return 'Made ' .. player.Name .. '\'s vest visible'
end

function Commands.novest(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Players.ShowVest, false)
        return 'Made all players\' vests invisible'
    end

    Players.ShowVest(player, false)
    return 'Made ' .. player.Name .. '\'s vest invisible'
end

function Commands.opacity(caller, player, value)
    value = tonumber(value)
    if not AppendChecks({ValueCheck = true, value}) then
        return 'Invalid value'
    end

    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Players.Visibility, value)
        return 'Set players\' character opacity to ' .. value
    end

    Players.Visibility(player, value)
    return 'Set ' .. player.Name .. ' opacity to ' .. value
end

-- Banishment

function Commands.kill(caller, player)
    if not AppendChecks({HierarchyCheck = true}) then
        return 'Invalid caller'
    end
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Banishment.Kill)
        return 'Killed players'
    end

    Banishment.Kill(player)
    return 'Killed ' .. player.Name
end

function Commands.boom(caller, player)
    if not AppendChecks({HierarchyCheck = true}) then
        return 'Invalid caller'
    end
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Banishment.Explode)
        return 'Exploded players'
    end

    Banishment.Explode(player)
    return 'Exploded ' .. player.Name
end

function Commands.kick(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Banishment.Kick)
        return 'Kicked players'
    end

    Banishment.Kick(player)
    return 'Kicked ' .. player.Name
end

function Commands.ban(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Banishment.Ban)
        return 'Banned players'
    end

    Banishment.Ban(player)
    return 'Banned ' .. player.Name
end

function Commands.unban(caller, player)
    local Bans = Arsenic.Storage.Bans
    if player == 'all' then
        RunListAsync(Bans, Banishment.Unban)
        return 'Cleared bans'
    end
    player = Arsenic.FindRaw(Bans, player)
    Banishment.Unban(player)
    return 'Unbanned ' .. player
end

function Commands.punish(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Banishment.Punish)
        return 'Punished players'
    end

    Banishment.Punish(player)
    return 'Punished ' .. player.Name
end

function Commands.unpunish(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Banishment.Unpunish)
        return 'Unpunished players'
    end

    Banishment.Unpunish(player)
    return 'Unpunished ' .. player.Name
end

function Commands.crash(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Banishment.Crash)
        return 'Crashed players'
    end

    Banishment.Crash(player)
    return 'Crashed ' .. player.Name
end

function Commands.trip(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Banishment.Trip)
        return 'Tripped players'
    end

    Banishment.Trip(player)
    return 'Tripped ' .. player.Name
end

function Commands.nohum(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Banishment.SetHumanoid, false)
        return 'Removed players\' humanoids'
    end

    Banishment.SetHumanoid(player, false)
    return 'Removed ' .. player.Name .. '\'s humanoid'
end

function Commands.hum(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunListAsync(player, Banishment.SetHumanoid, true)
        return 'Replenished players\' humanoids'
    end

    Banishment.SetHumanoid(player, true)
    return 'Replenished ' .. player.Name .. '\'s humanoid'
end

-- Weapons

function Commands.setrecoil(caller, player, weapon, amount)
    amount = tonumber(amount)
    if not AppendChecks({ValueCheck = true, amount}) or (player == 'all' or player == 'others') then
        return 'Invalid parameters'
    end

    player = FindPlayer(player)
    weapon = FindWeapon(player, weapon)

    if not amount or amount <= 0 then
        amount = 1
    end

    Weapons.SetRecoil(player, weapon, amount)

    return 'Changed ' .. player.Name .. '\'s ' .. weapon.Name .. ' to '
end

function Commands.norecoil(caller, player, weapon)
    if not AppendChecks({AllCheck = true, player}) then
        return 'Invalid parameters'
    end

    player = FindPlayer(player)
    weapon = FindWeapon(player, weapon)

    Weapons.SetRecoil(player, weapon, 1)

    return 'Reduced recoil from ' .. player.Name .. '\'s ' .. weapon.Name
end

function Commands.setspread(caller, weapon, amount)
    amount = tonumber(amount)
    if not AppendChecks({RootCheck = true, ValueCheck = true, amount}) then
        return 'Invalid caller'
    end

    weapon = FindWeapon(Arsenic.Client, weapon)

    Weapons.SetSpread(weapon, amount)
    return 'Set the bullet spread of client\'s ' .. weapon.Name .. ' to ' .. amount
end

function Commands.nospread(caller, weapon)
    if not AppendChecks({RootCheck = true}) then
        return 'Invalid caller'
    end

    weapon = FindWeapon(Arsenic.Client, weapon)

    Weapons.SetSpread(weapon, 0)
    return 'Removed bullet spread from client\'s ' .. weapon.Name
end

function Commands.firerate(caller, weapon, amount)
    amount = tonumber(amount)
    if not AppendChecks({RootCheck = true, ValueCheck = true, amount}) then
        return 'Invalid caller'
    end

    weapon = FindWeapon(Arsenic.Client, weapon)

    Weapons.FireRate(weapon, amount)
    return 'Set the fire rate of client\'s ' .. weapon.Name .. ' to ' .. amount
end

function Commands.infammo(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Weapons.SetAmmo, 133742069360)
        return 'Set all players\' ammo to 133742069360'
    end

    Weapons.SetAmmo(player, 133742069360)
    return 'Set all of ' .. player.Name .. '\'s ammo to 133742069360'
end

function Commands.refillammo(caller, player)
    player = FindPlayer(player)
    if type(player) == 'table' then
        RunList(player, Weapons.RefillAmmo)
        return 'Refilled all players\' ammo'
    end

    Weapons.RefillAmmo(player)
    return 'Refilled all of ' .. player.Name .. '\'s ammo'
end

-- Structures

function Commands.encage(caller, player)
    if not AppendChecks({AllCheck = true, player}) then
        return 'Invalid arguments'
    end

    player = FindPlayer(player)
    Structures.Truss(player, 1, 0.125, 1, 10)
    return 'Put' .. player.Name .. ' in a cage'
end

function Commands.uncage(caller, player)
    if not AppendChecks({AllCheck = true, player}) then
        return 'Invalid arguments'
    end

    player = FindPlayer(player)
    Structures.Truss(player, 1, 0.125, 1, 30)
    return 'Opened cage on ' .. player.Name
end

function Commands.helix(caller, player)
    if not AppendChecks({AllCheck = true, player}) then
        return 'Invalid arguments'
    end

    player = FindPlayer(player)
    Structures.Truss(player, math.rad(10), 0.125, math.rad(10), 30)
    return 'Created helix on ' .. player.Name
end

function Commands.truss(caller, player, x, y, z, d)
    if not AppendChecks({AllCheck = true, player}) then
        return 'Invalid arguments'
    end

    if not tonumber(x) or not tonumber(y) or not tonumber(z) or not tonumber(d) then
        return 'Invalid parameter value'
    end

    player = FindPlayer(player)
    Structures.Truss(player, tonumber(x), tonumber(y), tonumber(z), tonumber(d))
    return 'Created custom truss structure on ' .. player.Name
end

-- Cloning

function Commands.city(caller, player, city)
    if not AppendChecks({AllCheck = true, city}) then
        return 'Invalid arguments'
    end

    city = FindCity(city)
    player = FindPlayer(player)

    if type(player) == 'table' then
        RunList(player, Cloning.Clone, city)
        return 'Cloned ' .. city.Name .. ' to players'
    end

    Cloning.Clone(player, city)
    return 'Cloned ' .. city.Name .. ' to ' .. player.Name
end

function Commands.wipeclones(caller)
    for i,v in next, workspace:GetChildren() do
        if v:IsA('Model') and FindCity(v.Name) then
            Arsenic('ChangeParent', v, nil)
        end
    end
    return 'Removed all cloned structures'
end

return Commands