Dvar::Dvar_RegisterInt("bg_bounces", 0, 0, 2, Game::DVAR_CODINFO, "Bounce glitch settings"); // 0 = disabled, 1 = enabled, 2 = double
Dvar::Dvar_RegisterInt("bg_bouncesAllAngles", 0, 0, 2, Game::DVAR_CODINFO, "Force bounce from all angles"); // 0 = disabled, 1 = simple, 2 = all surfaces
Dvar::Dvar_RegisterInt("bg_elevators", 1, 0, 2, Game::DVAR_CODINFO, "Elevators glitch settings"); // 0 = off, 1 = normal, 2 = easy

//////////////////////////////////////////////////////////////////////////////////////////////////////

namespace
{
    struct Site
    {
        uintptr_t address;
        uint32_t original;
    };

    static uint32_t ReadInstruction(uintptr_t Address)
    {
        return *reinterpret_cast<const uint32_t *>(Address);
    }

    namespace BouncePatches
    {
        struct PatchState
        {
            bool Init;
            bool HasLast;
            int LastBounces;
            int LastAllAngles;
            Site StepSlideMode;
            Site ProjectVelocityRet;
            Site JumpClear[3];
        };

        static PatchState S = {};

        static void InitializeIfNeeded()
        {
            if (S.Init)
                return;

            S.StepSlideMode.address = 0x8210CB74;
            S.StepSlideMode.original = ReadInstruction(0x8210CB74);

            S.ProjectVelocityRet.address = 0x82104008;
            S.ProjectVelocityRet.original = ReadInstruction(0x82104008);

            S.JumpClear[0].address = 0x8210A650;
            S.JumpClear[0].original = ReadInstruction(0x8210A650);
            S.JumpClear[1].address = 0x8210C8A8;
            S.JumpClear[1].original = ReadInstruction(0x8210C8A8);
            S.JumpClear[2].address = 0x8210C954;
            S.JumpClear[2].original = ReadInstruction(0x8210C954);

            S.Init = true;
        }

        void Apply()
        {
            InitializeIfNeeded();

            const int BgBounces = dvar::Dvar_GetInt("bg_bounces");
            const int BgAllAngles = dvar::Dvar_GetInt("bg_bouncesAllAngles");

            if (S.HasLast
                && BgBounces == S.LastBounces
                && BgAllAngles == S.LastAllAngles)
            {
                return;
            }

            if (BgBounces <= 0)
            {
                Memory::Write32(S.StepSlideMode.address, S.StepSlideMode.original);
            }
            else if (BgAllAngles == 2)
            {
                Memory::WriteBranch(S.StepSlideMode.address, 0x8210CB8C);
            }
            else
            {
                Memory::Write32(S.StepSlideMode.address, Memory::Nop());
            }

            Memory::Write32(
                S.ProjectVelocityRet.address,
                BgAllAngles > 0 ? Memory::Nop() : S.ProjectVelocityRet.original);

            const bool DisableJumpClear = BgBounces == 2;
            for (size_t I = 0; I < (sizeof(S.JumpClear) / sizeof(S.JumpClear[0])); ++I)
            {
                const Site &Cur = S.JumpClear[I];
                Memory::Write32(Cur.address, DisableJumpClear ? Memory::Nop() : Cur.original);
            }

            S.LastBounces = BgBounces;
            S.LastAllAngles = BgAllAngles;
            S.HasLast = true;
        }
    }

    namespace ElevatorPatches
    {
        struct PatchState
        {
            bool Init;
            bool HasLast;
            int LastMode;
            Site FirstStartSolid;
            Site SecondStartSolid;
            Site AllSolid[3];
        };

        static PatchState S = {};

        static void InitializeIfNeeded()
        {
            if (S.Init)
                return;

            S.FirstStartSolid.address = 0x8210A2A0;
            S.FirstStartSolid.original = ReadInstruction(0x8210A2A0);

            S.SecondStartSolid.address = 0x8210A2F0;
            S.SecondStartSolid.original = ReadInstruction(0x8210A2F0);

            S.AllSolid[0].address = 0x82106DB8;
            S.AllSolid[0].original = ReadInstruction(0x82106DB8);
            S.AllSolid[1].address = 0x82106E64;
            S.AllSolid[1].original = ReadInstruction(0x82106E64);
            S.AllSolid[2].address = 0x82106F30;
            S.AllSolid[2].original = ReadInstruction(0x82106F30);

            S.Init = true;
        }

        void Apply()
        {
            InitializeIfNeeded();

            const int BgElevators = dvar::Dvar_GetInt("bg_elevators");
            if (S.HasLast && BgElevators == S.LastMode)
                return;

            const bool EasyElevators = BgElevators == 2;
            const bool NormalOrEasy = BgElevators >= 1;

            Memory::Write32(
                S.FirstStartSolid.address,
                EasyElevators ? Memory::Nop() : S.FirstStartSolid.original);

            if (NormalOrEasy)
                Memory::WriteBranch(S.SecondStartSolid.address, 0x8210A334);
            else
                Memory::Write32(S.SecondStartSolid.address, S.SecondStartSolid.original);

            for (size_t I = 0; I < (sizeof(S.AllSolid) / sizeof(S.AllSolid[0])); ++I)
            {
                const Site &Cur = S.AllSolid[I];
                Memory::Write32(Cur.address, EasyElevators ? Memory::Nop() : Cur.original);
            }

            S.LastMode = BgElevators;
            S.HasLast = true;
        }
    }

}

void iw4mpHooks::ScrDrawScreenFieldHook(int localClientNum, int refreshedUI)
{
    s_pInstance->m_pScrDrawScreenFieldHook->GetOriginal(&ScrDrawScreenFieldHook)(localClientNum, refreshedUI);

    BouncePatches::Apply();
    ElevatorPatches::Apply();
}