--[==[if
    LocalPlayer() == player.GetByUniqueID(--[[BubuNddi(jp)]] "993888442") or
    LocalPlayer() == player.GetByUniqueID(--[[CapsAdmin]] "1416729906") or
    LocalPlayer() == player.GetByUniqueID(--[[[JP] L.Bodewig]] "3231181953")
then]==]

if CLIENT then

    local function Create1BitMaterial(path)
        return CreateMaterial(
            path .. "_hotd_"..RealTime(),
            "UnlitGeneric",
            {
                ["$basetexture"] = path,
                ["$alphatest"] = 1,
            }
        )
    end

    -- particles

    local particles = {}

    local fire_mat = Create1BitMaterial("effects/fire_cloud2")

    local function create_particles()
        for i=1, math.random(2,10) do
            particles[i] = {ang = math.random(0,360), len = math.random()*400}
        end
    end

    local function draw_particles(x,y)
        if particles then
            for k,v in pairs(particles) do
                surface.SetDrawColor(255, 255, 255, 255)
                surface.SetMaterial(fire_mat)

                local dx = math.sin(math.rad(v.ang)) * v.len / 2
                local dy = math.cos(math.rad(v.ang)) * v.len / 2

                surface.DrawTexturedRectRotated(x + dx, y+dy, 100, 100 + v.len, v.ang)
            end
        end
    end

    -- crosshair

    local crosshair_mat = Material("VGUI/hud/xbox_reticle")
    local size = 128

    local function draw_crosshair(x,y, alpha)
        surface.SetDrawColor(255, 0, 0, alpha or 255)
        surface.SetMaterial(crosshair_mat)
        surface.DrawTexturedRect(x-size/2,y-size/2,size,size)
    end

    -- flash

    local white_id = surface.GetTextureID("VGUI/white_additive")

    local function draw_flash(alpha)
        surface.SetDrawColor(255, 255, 255, alpha)
        surface.SetTexture(white_id)
        surface.DrawTexturedRect(0,0,ScrW(), ScrH())
    end

    -- ammo

    local max_ammo = 6
    local ammo = max_ammo

    local ammo_id = surface.GetTextureID("VGUI/ico_box6")
    local offset = 64
    local spacing = 64
    local size = 64

    local function draw_ammo()
        local x = offset
        local y = ScrH() - offset * 2

        for i = 0, ammo-1 do
            surface.SetDrawColor(255, 255, 255, 255)
            surface.SetTexture(ammo_id)
            surface.DrawTexturedRect(x + (i * spacing), y, size, size)
        end
    end

    -- reload
    local reload_text = "RELOAD"
    surface.CreateFont(
        "hotd_reload_font",
        {
            font = "coolvetica",
            size = 128,
            weight = 700,
        }
    )

    local function draw_reload()
        surface.SetFont("hotd_reload_font")
        local w, h = surface.GetTextSize(reload_text)
        surface.SetTextPos((ScrW() / 2) - w / 2, (ScrH() / 2) - h / 2)
        surface.SetTextColor(255, 0, 0, math.abs(math.sin(RealTime()*20)) * 255)
        surface.DrawText(reload_text)
    end

    -- sound

    local function play_gunshot(ent)
        ent:EmitSound("npc/sniper/sniper1.wav", 100, 150)
        ent:EmitSound("weapons/pistol/pistol_fire3.wav", 100, 75)
    end

    -- graphics
    local graphics_cvars =
    {
        r_lod = 5,
        mat_filterlightmaps = 0,
        mat_filtertextures = 0,
        mat_mipmaptextures = 0,
        r_shadows = 0,
        mat_fullbright = 1,
    }

    hotd_old_graphics_cvars = hotd_old_graphics_cvars or {}

    local function enable_graphics()
        for cmd, val in pairs(graphics_cvars) do
            hotd_old_graphics_cvars[cmd] = hotd_old_graphics_cvars[cmd] or GetConVarString(cmd)

            RunConsoleCommand(cmd, val)
        end

        hook.Add("RenderScreenspaceEffects", "hotd", function()
            DrawColorModify
            {
                ["$pp_colour_addr"] = 0.0,
                ["$pp_colour_addg"] = 0.01,
                ["$pp_colour_addb"] = 0.05,
                ["$pp_colour_brightness"] = -0.1,
                ["$pp_colour_contrast"] = 1.2,
                ["$pp_colour_colour"] = 0.8,
                ["$pp_colour_mulr"] = 0,
                ["$pp_colour_mulg"] = 0,
                ["$pp_colour_mulb"] = 0,
            }
        end)
    end

    local function disable_graphics()
        for cmd, val in pairs(hotd_old_graphics_cvars) do
            RunConsoleCommand(cmd, val)
        end

        hotd_old_graphics_cvars = {}

        hook.Remove("RenderScreenspaceEffects", "hotd")
    end

    -- network

    hotd_players = hotd_players or {}

    local players = hotd_players
    local avatar_size = 32

    local function hide_avatars()
        for id, pos in pairs(players) do
            local pnl = players[id].panel or NULL

            if pnl:IsValid() then
                pnl:SetVisible(false)
            end
        end
    end

    local function network_cursor(x, y)
        RunConsoleCommand("hotd_mpos", x / ScrW(), y / ScrH())
    end

    -- logic

    local last_attack = 0
    local last_x, last_y
    local reload_sound_played = false

    local function draw_hud()
        if not vgui.CursorVisible() or not vgui.CursorVisible() or (pace and pace.Editor:IsValid()) or (g_SpawnMenu and g_SpawnMenu:IsVisible()) then
            hide_avatars()
        return end

        local x,y = gui.MousePos()
        local ply = LocalPlayer()

        draw_ammo()

        if ammo < 0 then
            if input.IsMouseDown(MOUSE_RIGHT) then
                ammo = max_ammo
                ply:EmitSound("weapons/shotgun/shotgun_cock.wav")
            end

            draw_reload()

            draw_crosshair(x,y, math.abs(math.sin(RealTime()*20)) * 255)

            if not reload_sound_played then
                local snd = CreateSound(ply, "vo/npc/male01/reloadfm01.wav")
                snd:Play()
                timer.Simple(0.4, function()
                    snd:Stop("vo/npc/male01/reloadfm01.wav")
                end)
                reload_sound_played = true

                hide_avatars()
            end

            return
        end

        if last_attack > RealTime() then
            draw_flash(50)
            draw_crosshair(x, y)
            draw_particles(last_x, last_y)
            draw_flash(25)

            hide_avatars()
            return
        end

        draw_crosshair(x,y)

        if input.IsMouseDown(MOUSE_LEFT) then
            particles = {}

            if ammo > 0 then
                play_gunshot(ply)

                local ent = ply:GetViewEntity()
                local aim = util.AimVector(ent:GetAngles(), ply:GetFOV(), x, y, ScrW(), ScrH())

                local data = util.TraceLine({
                    start = ent:GetPos(),
                    endpos = ent:GetPos() + aim * 2048,
                    mask = MASK_OPAQUE_AND_NPCS,
                })

                if data.Entity:IsPlayer() or data.Entity:IsNPC() then
                    local params = EffectData()
                        params:SetOrigin(data.HitPos)
                        params:SetStart(data.HitPos)
                    util.Effect("BloodImpact", params)
                else
                    ply:EmitSound("weapons/fx/rics/ric2.wav", 100, 100)
                end

                -- this is terrible but it's only temporary
                -- update or is it ???????????????
                net.Start("hotd_fire")
                    net.WriteVector(aim)
                    net.WriteEntity(data.Entity)
                net.SendToServer()
            else
                ply:EmitSound("weapons/pistol/pistol_empty.wav", 100, 125)
            end

            last_attack = RealTime() + 0.1

            last_x = x
            last_y = y

            create_particles()

            ammo = ammo - 1
        end

        reload_sound_played = false

        for id, pos in pairs(players) do
            local pnl = players[id].panel or NULL

            if Entity(id):IsValid() then
                local delta = FrameTime() * 16

                pos.sx = pos.sx or pos.x
                pos.sy = pos.sy or pos.y

                pos.sx = pos.sx + ((pos.x - pos.sx) * delta)
                pos.sy = pos.sy + ((pos.y - pos.sy) * delta)

                if pnl:IsValid() then
                    pnl:SetAlpha(255)
                    pnl:SetVisible(true)
                    pnl:SetPos((pos.sx - avatar_size/2), (pos.sy - avatar_size/2))
                end

                draw_crosshair(pos.sx, pos.sy)

                if pos.shoot then
                    particles = {}
                    last_attack = RealTime() + 0.1
                    last_x = pos.x
                    last_y = pos.y
                    create_particles()
                    pos.shoot = false
                end
            else
                players[id] = nil
                if pnl:IsValid() then
                    pnl:Remove()
                end
            end
        end

        network_cursor(x, y)
    end

    usermessage.Hook("hotd_play_gunshot", function(umr)
        local ent = umr:ReadEntity()

        if ent:IsValid() then
            local id = ent:EntIndex()

            play_gunshot(ent)

            if players[id] then
                players[id].shoot = true
            end
        end
    end)

    usermessage.Hook("hotd_mpos", function(umr)
        local ply, x,y = umr:ReadEntity(), umr:ReadFloat(), umr:ReadFloat()

        if ply:IsValid() then
            x = x * ScrW()
            y = y * ScrH()

            local id = ply:EntIndex()
            players[id] = players[id] or {}

            players[id].x = x
            players[id].y = y

            local pnl = players[id].panel or NULL

            if not pnl:IsValid() then
                pnl = vgui.Create("AvatarImage")
                pnl:SetPlayer(ply)
                players[id].panel = pnl
            end

            pnl:SetSize(avatar_size, avatar_size)
        end
    end)

    function hotd_enable()
        hook.Add("HUDPaint", "hotd", draw_hud)
        enable_graphics()
        gui.EnableScreenClicker(true)
    end

    function hotd_disable()
        hook.Remove("HUDPaint", "hotd")
        disable_graphics()
        gui.EnableScreenClicker(false)
    end
end

if SERVER then

    util.AddNetworkString("hotd_fire")

    hotd_scene_entity = NULL

    hotd_map_data = {map = game.GetMap(), points = {}}
    local hotd_map_index = 1
    local hotd_lerp = 0
    hotd_active_npcs = hotd_active_npcs

    local male_thanks_sounds =
    {
        "vo/npc/male01/answer01.wav",
        "vo/npc/male01/answer02.wav",
        "vo/npc/male01/answer03.wav",
        "vo/npc/male01/answer04.wav",
        "vo/npc/male01/answer05.wav",
        "vo/npc/male01/answer07.wav",
        "vo/npc/male01/answer08.wav",
        "vo/npc/male01/answer09.wav",
        "vo/npc/male01/answer10.wav",
        "vo/npc/male01/answer11.wav",
        "vo/npc/male01/answer12.wav",
        "vo/npc/male01/answer13.wav",
        "vo/npc/male01/answer14.wav",
        "vo/npc/male01/answer15.wav",
        "vo/npc/male01/answer16.wav",
        "vo/npc/male01/answer17.wav",
        "vo/npc/male01/answer18.wav",
        "vo/npc/male01/answer19.wav",
        "vo/npc/male01/answer20.wav",
        "vo/npc/male01/answer21.wav",
        "vo/npc/male01/answer22.wav",
        "vo/npc/male01/answer23.wav",
        "vo/npc/male01/answer24.wav",
        "vo/npc/male01/answer25.wav",
        "vo/npc/male01/answer26.wav",
        "vo/npc/male01/answer27.wav",
        "vo/npc/male01/answer28.wav",
        "vo/npc/male01/answer29.wav",
        "vo/npc/male01/answer30.wav",
        "vo/npc/male01/answer31.wav",
        "vo/npc/male01/answer32.wav",
        "vo/npc/male01/answer33.wav",
        "vo/npc/male01/answer34.wav",
        "vo/npc/male01/answer35.wav",
        "vo/npc/male01/answer36.wav",
        "vo/npc/male01/answer37.wav",
        "vo/npc/male01/answer38.wav",
        "vo/npc/male01/answer39.wav",
        "vo/npc/male01/answer40.wav",
    }
    local female_thanks_sounds =
    {
        "vo/npc/female01/answer01.wav",
        "vo/npc/female01/answer02.wav",
        "vo/npc/female01/answer03.wav",
        "vo/npc/female01/answer04.wav",
        "vo/npc/female01/answer05.wav",
        "vo/npc/female01/answer07.wav",
        "vo/npc/female01/answer08.wav",
        "vo/npc/female01/answer09.wav",
        "vo/npc/female01/answer10.wav",
        "vo/npc/female01/answer11.wav",
        "vo/npc/female01/answer12.wav",
        "vo/npc/female01/answer13.wav",
        "vo/npc/female01/answer14.wav",
        "vo/npc/female01/answer15.wav",
        "vo/npc/female01/answer16.wav",
        "vo/npc/female01/answer17.wav",
        "vo/npc/female01/answer18.wav",
        "vo/npc/female01/answer19.wav",
        "vo/npc/female01/answer20.wav",
        "vo/npc/female01/answer21.wav",
        "vo/npc/female01/answer22.wav",
        "vo/npc/female01/answer23.wav",
        "vo/npc/female01/answer24.wav",
        "vo/npc/female01/answer25.wav",
        "vo/npc/female01/answer26.wav",
        "vo/npc/female01/answer27.wav",
        "vo/npc/female01/answer28.wav",
        "vo/npc/female01/answer29.wav",
        "vo/npc/female01/answer30.wav",
        "vo/npc/female01/answer31.wav",
        "vo/npc/female01/answer32.wav",
        "vo/npc/female01/answer33.wav",
        "vo/npc/female01/answer34.wav",
        "vo/npc/female01/answer35.wav",
        "vo/npc/female01/answer36.wav",
        "vo/npc/female01/answer37.wav",
        "vo/npc/female01/answer38.wav",
        "vo/npc/female01/answer39.wav",
        "vo/npc/female01/answer40.wav",
    }

    function hotd_initialize()
        hook.Add("Think", "hotd", hotd_think)
        SafeRemoveEntity(hotd_scene_entity)

        if not hotd_load_map() then
            hotd_shutdown()
            return
        end

        local ent = ents.Create("prop_dynamic")
        ent:SetModel("models/tools/camera/camera.mdl")
        ent:SetPos(hotd_map_data.points[1].pos)
        ent:Spawn()

        hotd_scene_entity = ent
    end

    function hotd_shutdown()
        hook.Add("Think", "hotd", hotd_think)
        SafeRemoveEntity(hotd_scene_entity)

        hotd_map_index = 1
        hotd_lerp = 0

        if table.Count(hotd_players) > 0 then
            for key, ply in pairs(hotd_players) do
                hotd_disable(ply)
            end
        end

        if hotd_active_npcs then
            for key, data in pairs(hotd_active_npcs) do
                SafeRemoveEntity(data.ent)
            end
        end
    end

    local function hotd_think()
        local ent = hotd_scene_entity

        if ent:IsValid() then

            local data_cur = hotd_map_data.points[hotd_map_index]
            local data_nxt = hotd_map_data.points[hotd_map_index + 1]

            if not data_cur then
                ErrorNoHalt("invalid map index ?? '" .. hotd_map_index .. "'")
                hotd_shutdown()
            return end

            if data_nxt then
                ent:SetPos(LerpVector(hotd_lerp, data_cur.pos, data_nxt.pos))
                ent:SetAngles(LerpAngle(hotd_lerp, data_cur.ang, data_nxt.ang))
            end

            if data_nxt.npcs then
                if not hotd_active_npcs then
                    for _, data in pairs(data_nxt.npcs) do
                        local npc = ents.Create(data.class)
                            npc:SetPos(data.pos)
                            data.ang.p = 0
                            npc:SetAngles(data.ang)
                            npc:Spawn()
                            npc:DropToFloor()
                        data.ent = npc
                    end

                    hotd_active_npcs = table.Copy(data_nxt.npcs)
                end
            end

            if hotd_active_npcs and data_cur.npcs then

                local aim_pos = Vector(0,0,0)
                local enemy_count = 0

                local friendly_count = 0

                for key, data in pairs(hotd_active_npcs) do
                    if not data.ent:IsValid() then
                        hotd_active_npcs[key] = nil
                    else
                        if data.class ~= "npc_citizen" then
                            aim_pos = aim_pos + data.ent:EyePos()
                            enemy_count = enemy_count + 1
                        else
                            friendly_count = friendly_count + 1
                        end
                    end
                end

                if enemy_count == 0 then
                    if friendly_count > 0 then

                        for key, data in pairs(hotd_active_npcs) do
                            if data.ent.hotd_thanked then
                                if data.ent.hotd_thanked < os.clock() then
                                    hotd_active_npcs[key] = nil
                                end
                                aim_pos = data.ent.hotd_last_pos
                            elseif data.ent:GetPos():Distance(ent:GetPos()) < 100 then
                                if data.ent:GetModel():lower():find("female") then
                                    data.ent:EmitSound(table.Random(female_thanks_sounds))
                                else
                                    data.ent:EmitSound(table.Random(male_thanks_sounds))
                                end

                                data.ent.hotd_last_pos = data.ent:EyePos()
                                data.ent.hotd_thanked = os.clock() + 1
                            else
                                if data.ent.hotd_goto ~= ent:GetPos() then
                                    data.ent:SetLastPosition(ent:GetPos())
                                    data.ent:SetSchedule(SCHED_FORCED_GO)
                                    data.ent.hotd_goto = ent:GetPos()
                                end
                                aim_pos = aim_pos + data.ent:EyePos()
                            end
                        end
                    else
                        hotd_active_npcs = nil
                        data_cur.npcs = nil
                    end
                elseif enemy_count > 1 then
                    aim_pos = aim_pos / enemy_count
                end

                ent:SetAngles((aim_pos - ent:GetPos()):Angle())
            else
                hotd_lerp = hotd_lerp + FrameTime() * 0.75

                if hotd_lerp > 1 then
                    hotd_lerp = 0
                    hotd_map_index = hotd_map_index + 1
                end
            end

            for key, ply in pairs(hotd_players) do
                ply:SetViewEntity(ent)
                ply:SetPos(ent:GetPos() - (ply:EyePos() - ply:GetPos()) + ent:GetForward() * -50)
                ply:SetEyeAngles(ent:GetAngles())
                ply:SetMoveType(MOVETYPE_NOCLIP)
                if not ply:Alive() then
                    hotd_disable(ply)
                end
            end
        end
    end

    hotd_players = hotd_players or {}

    function hotd_enable(ply)
        hotd_disable(ply)

        local count = table.Count(hotd_players)

        ply:SendLua("hotd_enable()")
        hotd_players[ply:UniqueID()] = ply

        -- so we can shut down properly if there's an error
        if count == 0 then
            hotd_initialize()
        end

        hook.Add("Think", "hotd", hotd_think)
    end

    function hotd_disable(ply)
        ply:SendLua("hotd_disable()")
        hotd_players[ply:UniqueID()] = nil

        if table.Count(hotd_players) == 0 then
            hotd_shutdown()
        end

        ply:SetViewEntity(NULL)
    end

    function hotd_save_map(str, data)
        str = str or game.GetMap()
        data = data or hotd_map_data

        data.map = data.map or game.GetMap()
        luadata.WriteFile("hotd_map_" .. str .. ".txt", data)
    end

    function hotd_load_map(str)
        str = str or game.GetMap()

        local data = luadata.ReadFile("hotd_map_" .. str .. ".txt")

        if not data.map then
            ErrorNoHalt("invalid hotd map " .. str .. "!")
            hotd_shutdown()
            return false
        end

        if data.map ~= game.GetMap() then
            ErrorNoHalt("hotd map " .. str .. " was made for " .. data.map .. "!")
            hotd_shutdown()
            return false
        end

        hotd_map_data = data

        return true
    end

    local editor_points = {}

    function hotd_enable_editor(ply)

        editor_points = {}
        local current_class = "npc_zombie"

        local function remove_point(pos)
            for key, data in pairs(editor_points) do
                if data.pos:Distance(pos) < 50 then
                    SafeRemoveEntity(data.ent)
                    table.remove(editor_points, key)
                    break
                end
            end
        end

        hook.Add("KeyPress", "hotd", function(_ply, key)
            if _ply ~= ply then return end

            local pos = ply:EyePos()
            local ang = ply:EyeAngles()

            if key == IN_ATTACK then

                remove_point(pos)

                local ent = ents.Create("prop_dynamic")
                    ent:SetModel("models/tools/camera/camera.mdl")
                    ent:SetPos(pos)
                    ent:SetAngles(ang)
                    ent:Spawn()

                local key = table.insert(editor_points, {pos = pos, ang = ang, ent = ent})

                ply:EmitSound("buttons/button17.wav")

                print("adding point: ", key, pos, ang)

            elseif key == IN_ATTACK2 then

                remove_point(pos)

                ply:EmitSound("buttons/button16.wav")

                print("removing point: ", key, pos, ang)

            elseif key == IN_DUCK then

                local data = editor_points[#editor_points]
                data.npcs = data.npcs or {}

                local ent = ents.Create("prop_dynamic")
                ent:SetModel("models/editor/playerstart.mdl")
                ent:SetPos(pos)
                ent:SetAngles(ang)
                ent:DropToFloor()

                table.insert(
                    data.npcs,
                    {
                        class = current_class,
                        pos = pos,
                        ang = ang,
                        ent = ent,
                    }
                )

                print("adding npc ", "npc_zombie", pos, ang)

            elseif key == IN_RELOAD and ply:KeyDown(IN_WALK) then
                hotd_save_map(nil, {points = editor_points})

                hotd_disable_editor(ply)

                ply:EmitSound("buttons/button15.wav")
            end
        end)

        hook.Add("PlayerSay", "hotd", function(_ply, str)
            if _ply ~= ply then return end

            class = str:match("setnpcclass (.+)")
            current_class = class
        end)

    end

    function hotd_disable_editor(ply)
        for key, data in pairs(editor_points) do
            SafeRemoveEntity(data.ent)
            data.ent = nil

            if data.npcs then
                for key, data in pairs(data.npcs) do
                    SafeRemoveEntity(data.ent)
                    data.ent = nil
                end
            end
        end
        hook.Remove("KeyPress", "hotd")
        hook.Remove("PlayerSay", "hotd")
    end

    net.Receive("hotd_fire", function(len, ply)
        local aim = net.ReadVector()
        local ent = net.ReadEntity()

        local view = ply:GetViewEntity()
        local data = util.TraceLine({
            start = view:GetPos(),
            endpos = view:GetPos() + aim * 2048,
            mask = MASK_OPAQUE_AND_NPCS,
        })

        if data.Entity ~= ent then return end

        local hitpos = data.HitPos

        if ent:IsValid() then
            if ent:IsPlayer() or ent:IsNPC() then
                local params = EffectData()
                    params:SetOrigin(hitpos)
                    params:SetStart(hitpos)
                util.Effect("BloodImpact", params)
            end

            local params = DamageInfo()
                params:SetAttacker(ply)
                params:SetDamagePosition(hitpos)
                params:SetDamage(100)
                params:SetDamageForce((hitpos - ply:EyePos()):Normalize())
                params:SetDamageType(DMG_BULLET)
            ent:TakeDamageInfo(params)

            local rp = RecipientFilter()
            rp:AddAllPlayers()
            rp:RemovePlayer(ply)
            umsg.Start("hotd_play_gunshot", rp)
                umsg.Entity(ply)
            umsg.End()
        end
    end)

    concommand.Add("hotd_mpos", function(ply, _, args)
        local x, y = tonumber(args[1]) or 0, tonumber(args[2]) or 0

        local RP = RecipientFilter()
        RP:AddAllPlayers()
        RP:RemovePlayer(ply)

        umsg.Start("hotd_mpos", RP)
            umsg.Entity(ply)
            umsg.Float(x)
            umsg.Float(y)
        umsg.End()
    end)

    require("cvar3")
    all:ReplicateData("sv_cheats", "1")
end

--end