#include "Global.h"
#include "Input.h"
#include "Instance.h"
#include "Level.h"
#include "Log.h"
#include "bgfx/bgfx.h"
#include <bx/math.h>
#include <cstdint>

namespace
{
}

namespace Game
{
    void EntityRenderData::Render(const Model* models, const Material* materials)
    {
        if (ModelHandle == UINT16_MAX || MaterialHandle == UINT16_MAX) return;

        Transform.UpdateMatrix();
        bgfx::setTransform(Transform.M.M);

        const Model& currentModel = models[ModelHandle];
        const Material& currentMaterial = materials[MaterialHandle];
        bgfx::setVertexBuffer(0, currentModel.VertexBuffer);
        bgfx::setIndexBuffer(currentModel.IndexBuffer);
        bgfx::setState(currentMaterial.State);

        float TimeValues[4]{0.0f};
        TimeValues[0] = GetInstance().Time.Now;
        bgfx::setTexture(0, currentMaterial.Textures[0].SamplerHandle, currentMaterial.Textures[0].Handle);
        bgfx::setUniform(currentMaterial.Uniforms[Material::UTime], TimeValues);
        bgfx::setUniform(currentMaterial.Uniforms[Material::UDotColor], TestColor);

        bgfx::submit(0, currentMaterial.Shader);
    }

    void Level::Setup(GameData& data)
    {
        Log("Level setup");
        void* storagePtr = data.EntityStorage;
        bool needReset = false;
        needReset |= Cubes.Setup(storagePtr, needReset);
        needReset |= Tests.Setup(storagePtr, needReset);
        if (Cubes.Count == 0)
        {
            for (uint32_t yy = 0; yy < 11; ++yy)
            {
                for (uint32_t xx = 0; xx < 11; ++xx)
                {
                    Cube* c = Cubes.New();
                    if (c)
                    {
                        c->TestX = xx;
                        c->TestY = yy;
                    }
                }
            }

            Cube* floor = Cubes.New();
        }
        if (Tests.Count == 0)
        {
            Tests.New();
        }
    }

    void Level::Update()
    {
        PlayerData& player = GetInstance().Player;

        float delta = GetInstance().Time.Delta;
        constexpr float moveSpeed = 10.0f;
        constexpr float rotSpeed = 0.6f;

        float forwardInput = (GetKey(ScanCode::W) ? 1.0f : 0.0f) + (GetKey(ScanCode::S) ? -1.0f : 0.0f);
        float rightInput = (GetKey(ScanCode::D) ? 1.0f : 0.0f) + (GetKey(ScanCode::A) ? -1.0f : 0.0f);
        bx::Vec3 moveInput = bx::Vec3{rightInput, forwardInput, 0.0f};
        moveInput = bx::normalize(moveInput);
        bx::Vec3 inputVec = {moveInput.x * delta * moveSpeed, 0.0f, moveInput.y * delta * moveSpeed};

        bx::Vec3 camForward = player.FreeflyCamTransform.Forward();
        bx::Vec3 camRight = player.FreeflyCamTransform.Right();

        if (GetMouseButton(MouseButton::Left))
        {
            Vec2 mouseMovement = GetMouseMovement();
            bx::Vec3 rotInput = {mouseMovement.y * delta * rotSpeed, mouseMovement.x * delta * rotSpeed, 0.0f};
            player.FreeflyXRot += rotInput.x;
            player.FreeflyYRot += rotInput.y;
            bx::mtxRotateY(player.FreeflyCamTransform.Rotation.M, player.FreeflyYRot);
            player.FreeflyCamTransform.RotateLocal({player.FreeflyXRot, 0.0f, 0.0f});
        }

        player.FreeflyCamTransform.TranslateLocal({0.0f, 0.0f, -inputVec.z});
        player.FreeflyCamTransform.TranslateLocal({-inputVec.x, 0.0f, 0.0f});

        Cubes.Update();
        Tests.Update();
    }

    void Cube::Setup()
    {
        EData.MaterialHandle = 0;
        EData.ModelHandle = 0;
    }

    void Cube::Update()
    {
        if (TestX >= 0 && TestY >= 0)
        {
            double globalTime = GetInstance().Time.Now;
            double time = TestY <= 5 ? globalTime * 1.0f : 0.0f;
            float scale = 1.0f + TestX * 0.4f;
            EData.Transform.Position = bx::Vec3{TestX * 2.0f, TestY * 2.0f, 0.0f};
            EData.Transform.Scale = {scale, scale, scale};
        }
        else
        {
            EData.Transform.Position = {0.0f, -1.0f, 0.0f};
            EData.Transform.Scale = {100.0f, 1.0f, 100.0f};
            EData.TestColor[0] = 0.3f;
            EData.TestColor[1] = 0.325f;
            EData.TestColor[2] = 0.3f;
        }
    }

    void TestEntity::Setup()
    {
        EData.MaterialHandle = 0;
        EData.ModelHandle = 1;

        EData.Transform.Position = {0.0f, 0.0f, 10.0f};
    }

    void TestEntity::Update()
    {
        EData.TestColor[0] = 0.0f;
        // EData.TestColor[1] = 0.9f;
        // EData.TestColor[2] = 0.5f;
    }
} // namespace Game