#include "CTestRender.h"
#include "CEngine.h"

#include "CResourcesManager.h"
#include "CWindowManager.h"
#include "CGL430Model.h"
#include "COpenGL430Renderer.h"
#include "CCommandProcessor.h"
#include "U_Scripting.h"
#include "CConVarManager.h"
#include "U_Numbers.h"

#include "glm/glm.hpp"
#include "glm/gtc/quaternion.hpp"

bool CTestRender::V_Init()
{
    auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
    auto winman = CEngine::GetInstance()->Components.GetComponentTyped<CWindowManager>();
    auto& renderer = winman->Renderer;

    Model = resman->GetOrCreate(renderer->GetModelType(), "tankroad_terrain.emdl");

    return true;
}

void CTestRender::Draw()
{
    float WindowAspect = 1.0f;
    COMPONENT_CALL_GET(WindowAspect, CWindowManager, GetWindowAspect());

    glm::mat4 view = glm::lookAt(CameraTransform.GetPosition(), CameraTransform.GetPosition() + CameraTransform.GetForwardVector(), CameraTransform.GetUpVector());
    glm::mat4 proj = glm::perspective(glm::radians(CameraFOV), WindowAspect, 0.01f, 10000.0f);
    glm::mat4 modl = ModelTransform.GetModelMatrix();

    //glm::mat4 modl = glm::mat4(1.0f);
    //glm::mat4 view = glm::lookAt(glm::vec3(0, 0, 3), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
    //glm::mat4 proj = glm::perspective(glm::radians(60.0f), WindowAspect, 0.1f, 100.0f);

    auto winman = CEngine::GetInstance()->Components.GetComponentTyped<CWindowManager>();
    auto _renderer = winman->Renderer.get();
    auto renderer = dynamic_cast<COpenGL430Renderer*>(_renderer);

    //renderer->S_Default.Bind();

    renderer->S_Default.setUniform("model", modl);
    renderer->S_Default.setUniform("view", view);
    renderer->S_Default.setUniform("proj", proj);

    auto mdl = std::dynamic_pointer_cast<CModelBase>(Model);
    mdl->V_Draw();
}

bool CTestRender::V_ScriptInit(std::shared_ptr<sol::state> state, sol::table table)
{
    auto fieldsMan = CScriptFieldsManager::ValidateFieldsManager(table, true).first;

    sol::table camera = CameraTransform.GetScriptTable(state);
    sol::table model = ModelTransform.GetScriptTable(state);

    table["camera"] = camera;
    table["model"] = model;

    auto scFov = std::make_unique<CProxyScriptField<float>>(CameraFOV);
    fieldsMan->AddField<std::string>("fov", std::move(scFov));

    sol::table keys = table.create_named("key");

    {
        auto keys_man = CScriptFieldsManager::CreateFieldsManager(keys);

        auto scForward = std::make_unique<CProxyScriptField<bool>>(Forward, true);
        auto scBack = std::make_unique<CProxyScriptField<bool>>(Back, true);
        auto scLeft = std::make_unique<CProxyScriptField<bool>>(Left, true);
        auto scRight = std::make_unique<CProxyScriptField<bool>>(Right, true);
        auto scShift = std::make_unique<CProxyScriptField<bool>>(Shift, true);
        auto scCtrl = std::make_unique<CProxyScriptField<bool>>(Ctrl, true);

        keys_man->AddField("forward", std::move(scForward));
        keys_man->AddField("back", std::move(scBack));
        keys_man->AddField("left", std::move(scLeft));
        keys_man->AddField("right", std::move(scRight));
        keys_man->AddField("shift", std::move(scShift));
        keys_man->AddField("ctrl", std::move(scCtrl));

        keys_man->CreateMetaTable(keys);
    }

    auto SetTransformFuncs = [](sol::table tabl, CTransform& trans) -> void
    {
        sol::state_view st = tabl.lua_state();

        tabl.set_function("setPosition", [&trans](sol::object vec) { trans.SetPosition(ScriptUtils::FromObject<glm::vec3>(vec)); });
        tabl.set_function("setRotation", [&trans](sol::object quat) { trans.SetRotation(ScriptUtils::FromObject<glm::quat>(quat)); });
        tabl.set_function("setScale", [&trans](sol::object scl) { trans.SetScale(ScriptUtils::FromObject<glm::vec3>(scl)); });

        tabl.set_function("getPosition", [&trans, st]() -> sol::object { return ScriptUtils::ToObject(trans.GetPosition(), st); });
        tabl.set_function("getRotation", [&trans, st]() -> sol::object { return ScriptUtils::ToObject(trans.GetRotation(), st); });

        tabl.set_function("getRotationEuler", [&trans, st]() -> sol::object
        {
            glm::quat rot = trans.GetRotation();
            glm::vec3 euler = glm::eulerAngles(rot);

            return ScriptUtils::ToObject(euler, st);
        });

        tabl.set_function("getRotationEulerDegrees", [&trans, st]() -> sol::object
        {
            glm::quat rot = trans.GetRotation();
            glm::vec3 eulerDegrees = glm::eulerAngles(rot);

            eulerDegrees.x = glm::degrees(eulerDegrees.x);
            eulerDegrees.y = glm::degrees(eulerDegrees.y);
            eulerDegrees.z = glm::degrees(eulerDegrees.z);

            return ScriptUtils::ToObject(eulerDegrees, st);
        });

        tabl.set_function("getScale", [&trans, st]() -> sol::object { return ScriptUtils::ToObject(trans.GetScale(), st); });
    };
    return true;
}

void CTestRender::V_Update()
{
    auto global_start_point = CEngine::GetInstance()->Time.GetCurrent();

    auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
    auto winman = CEngine::GetInstance()->Components.GetComponentTyped<CWindowManager>();

    float sensitivity = 0.005f;
    float speed = 1.0f;

    auto start_point = std::chrono::high_resolution_clock::now();

    COMPONENT_CALL_GET(sensitivity, CConVarManager, GetConVarValue<float>("cam.sensitivity"));
    auto end_point = std::chrono::high_resolution_clock::now();

    if((end_point - start_point) >= std::chrono::duration<float>(0.1f))
    {
        Log::ErrInstance() << "sensitivity cvar took " << std::chrono::duration_cast<std::chrono::duration<float>>(end_point - start_point) << Log::Endl;
    }

    start_point = std::chrono::high_resolution_clock::now();
    COMPONENT_CALL_GET(speed, CConVarManager, GetConVarValue<float>("cam.speed"));
    end_point = std::chrono::high_resolution_clock::now();

    if((end_point - start_point) >= std::chrono::duration<float>(0.1f))
    {
        Log::ErrInstance() << "speed cvar took " << std::chrono::duration_cast<std::chrono::duration<float>>(end_point - start_point) << Log::Endl;
    }

    float dx, dy;
    start_point = std::chrono::high_resolution_clock::now();
    SDL_GetRelativeMouseState(&dx, &dy);
    end_point = std::chrono::high_resolution_clock::now();

    if((end_point - start_point) >= std::chrono::duration<float>(0.1f))
    {
        Log::ErrInstance() << "SDL_GetRelativeMouseState took " << std::chrono::duration_cast<std::chrono::duration<float>>(end_point - start_point) << Log::Endl;
    }

    float deltaYaw = dx * sensitivity;
    float deltaPitch = dy * sensitivity;

    CameraAngles.y -= CAngle::radians(deltaYaw);
    CameraAngles.x -= CAngle::radians(deltaPitch);

    CameraAngles.x.clamp180deg(-89.0f, 89.0f);

    glm::quat qPitch = glm::angleAxis(CameraAngles.x.asRadians(), glm::vec3(1, 0, 0));
    glm::quat qYaw   = glm::angleAxis(CameraAngles.y.asRadians(),   glm::vec3(0, 1, 0));
    glm::quat orientation = glm::normalize(qYaw * qPitch);

    CameraTransform.SetRotation(glm::normalize(orientation));

    start_point = std::chrono::high_resolution_clock::now();
    SDL_PumpEvents();
    end_point = std::chrono::high_resolution_clock::now();

    if((end_point - start_point) >= std::chrono::duration<float>(0.1f))
    {
        Log::ErrInstance() << "SDL_PumpEvents took " << std::chrono::duration_cast<std::chrono::duration<float>>(end_point - start_point) << Log::Endl;
    }

    start_point = std::chrono::high_resolution_clock::now();
    const bool* keyboard = SDL_GetKeyboardState(NULL);
    end_point = std::chrono::high_resolution_clock::now();

    if((end_point - start_point) >= std::chrono::duration<float>(0.1f))
    {
        Log::ErrInstance() << "SDL_GetKeyboardState took " << std::chrono::duration_cast<std::chrono::duration<float>>(end_point - start_point) << Log::Endl;
    }

    Forward = keyboard[SDL_SCANCODE_W     ];
    Back    = keyboard[SDL_SCANCODE_S     ];
    Left    = keyboard[SDL_SCANCODE_A     ];
    Right   = keyboard[SDL_SCANCODE_D     ];
    Shift   = keyboard[SDL_SCANCODE_LSHIFT];
    Ctrl    = keyboard[SDL_SCANCODE_LCTRL ];

    auto euler_repr = CameraTransform.GetEulerRotation().GetRotation();

    if(dx != 0.0f || dy != 0.0f)
    {
        //Log::Instance() << "Delta mouse: " << dx << ", " << dy << "; Angles: " << euler_repr.x.asDegrees() << ", " << euler_repr.y.asDegrees() << ", " << euler_repr.z.asDegrees() << Log::Endl;
    }

    auto global_end_point = CEngine::GetInstance()->Time.GetCurrent();
	auto update_diff = std::chrono::duration_cast<std::chrono::duration<float>>(global_end_point - global_start_point);

    if(update_diff.count() >= 0.1f)
    {
        Log::ErrInstance() << "global testrender update took " << update_diff.count() << Log::Endl;
    }
}

LINK_COMPONENT_TO_CLASS(CTestRender, testrender)