#include <game.h>

#include <Controller/DebugCameraController.h>
#include <Core/HAL/Filesystem/Filesystem.h>
#include <Core/HAL/Keyboard/Keyboard.h>
#include <Core/JulietInit.h>
#include <Core/Logging/LogManager.h>
#include <Core/Memory/MemoryArena.h>
#include <Data/StaticMesh.h>
#include <Entity/Entity.h>
#include <Entity/EntityManager.h>
#include <Graphics/Camera.h>
#include <Graphics/MeshRenderer.h>
#include <imgui.h>

#if JULIET_DEBUG
#include <Debug/DebugTopBar.h>
#endif

namespace
{
    GameState* gGameState = nullptr;
}

GameState* GetGameState()
{
    return gGameState;
}

extern "C" JULIET_API void __cdecl GameShutdown()
{
    printf("Shutting down game...\n");

    using namespace Juliet;

    ShutdownEntityManager();
}

extern "C" JULIET_API void __cdecl GameUpdate(Juliet::GameData* params, [[maybe_unused]] float deltaTime)
{
    using namespace Juliet;

    gGameState = params->GameState;
    if (!gGameState)
    {
        Arena* gameStateArena = ArenaAllocate({ .ReserveSize = Megabytes(1) } JULIET_DEBUG_PARAM("Game Total Arena"));
        auto*  gameState      = ArenaPushStruct<GameState>(gameStateArena);
        gGameState = params->GameState = gameState;
        gameState->TotalArena          = gameStateArena;

        gameState->TotalTime = 0.0f;
        gameState->Score     = 0;

        printf("Game Arena Allocated: %p\n", static_cast<void*>(gameState));

        // Reserve cameras. Lets go with 4 for now
        ReserveCamera(4);

        // Bootstrap world
        auto*  worldArena            = ArenaAllocate({ .ReserveSize = Megabytes(1) } JULIET_DEBUG_PARAM("World Arena"));
        World* world                 = ArenaPushStruct<World>(worldArena JULIET_DEBUG_PARAM("World"));
        gameState->World             = world;
        gameState->World->WorldArena = worldArena;

        // Entity Use case
        InitEntityManager(gameState->World);
        auto& manager = GetEntityManager();

        NonNullPtr mesh = MakeEntity<StaticMesh>(manager, 1.f, 2.f);

        MeshAssetID    cubeAsset = GetCubePrimitiveMeshAssetID();
        MeshInstanceID meshInst  = CreateMeshInstance(cubeAsset, 0, MatrixIdentity());
        mesh->Base->MeshInstance = meshInst;

        // Summer at 2pm lighting
        Vector3 sunDirection     = { -0.2f, -0.9f, -0.3f };
        Vector3 sunColor         = { 1.0f, 0.95f, 0.85f };
        float   ambientIntensity = 0.4f;
        SetGlobalLight(sunDirection, sunColor, ambientIntensity);
    }

#if JULIET_DEBUG
    DrawTopBar();
#endif

    GameMode previousFrameMode = gGameState->Mode;
    if (IsKeyPressed(ScanCode::F1))
    {
        if (previousFrameMode == GameMode::Play)
        {
            gGameState->Mode = GameMode::Debug;
        }
        else if (previousFrameMode == GameMode::Debug)
        {
            gGameState->Mode = GameMode::Play;
        }
    }

    if (gGameState->Mode == GameMode::Editor)
    {
        if (IsKeyPressed(ScanCode::F5))
        {
            gGameState->Mode = GameMode::Play;
        }
    }

    if (gGameState->Mode == GameMode::Play)
    {
        if (IsKeyPressed(ScanCode::Escape))
        {
            gGameState->Mode = GameMode::Editor;
        }

        // update game
    }

    auto& manager = GetEntityManager();
    UpdateEntityManager(manager);

    if (gGameState->Mode == GameMode::Debug)
    {
        if (previousFrameMode == GameMode::Play)
        {
            ActivateDebugController();
        }

        if (IsKeyPressed(ScanCode::Escape))
        {
            gGameState->Mode = GameMode::Editor;
        }

        UpdateDebugController(deltaTime);

#if JULIET_DEBUG
        ImGui::Begin("Debug");
        RenderImGuiDebugController(deltaTime);
        ImGui::End();
#endif
    }
    if (gGameState->Mode != GameMode::Debug && previousFrameMode == GameMode::Debug)
    {
        DeactivateDebugController();
    }
}