//
// Created by sebastian on 24.12.25.
//

#include "GameLayer.h"

#include "../engine/core/EngineTime.h"
#include "../engine/core/animations/AnimationComponent.h"
#include "../engine/core/animations/AnimationSystem.h"
#include "../engine/core/ECS/ModelStateComponent.h"
#include "../engine/core/ECS/WorldSpriteComponent.h"
#include "../engine/core/inputsOutputs/stateControl/StateRegistry.h"
#include "../engine/platform/glfw/InputManager.h"
#include "../engine/renderer/Renderer.h"
#include "../engine/renderer/loader/OBJLoader.h"
#include "../engine/renderer/model/TexturedModel.h"
#include "../engine/renderer/textures/ModelTexture.h"
#include "../engine/toolbox/MathUtils.h"
#include "../engine/layer/entities/Light.h"
#include "../engine/renderer/loader/AssetManager.h"
#include "hexWorld/HexModelFactory.h"
#include "hexWorld/MapGenerator.h"
#include "hexWorld/building/BuildingFactory.h"
#include "hexWorld/building/TemporaryBuildingDefinitionFactory.h"
#include "hexWorld/ecs/components/ProducingComponent.h"
#include "hexWorld/ecs/systems/BuildPreviewSystem.h"
#include "hexWorld/ecs/systems/CollectResourceSystem.h"
#include "hexWorld/ecs/systems/ProducingSystem.h"
#include "hexWorld/ecs/systems/SelectionSystem.h"
#include "hexWorld/ecs/systems/UpgradeSystem.h"
#include "hexWorld/events/BuildingTypeSelectEvent.h"
#include "hexWorld/events/TurnChangedEvent.h"

GameLayer::GameLayer() : texturedModel(0, 0), testEntity(0)
//Platzhalter, echtes Model kommt in onAttach
{
}

void GameLayer::onAttach()
{
    Loader& loader = Loader::instance();
    texturedModel = *OBJLoader::loadModel("assets/dragon/dragon.obj", "assets/dragon/dragon.png", loader);
    entities.push_back(std::make_shared<Entity>(Entity(std::make_shared<TexturedModel>(texturedModel), glm::vec3(0,0,-25), 0,0,0, 1.f)));
    camera = std::make_unique<Camera>();
    light = std::make_unique<Light>(glm::vec3(50,100,50), glm::vec3(1,1,1));
    mousePicker = std::make_unique<MousePicker>(renderer->getProjectionMatrix(), MathUtils::createViewMatrix(*camera));

    //Map Generation
    hexModelDefault = std::make_shared<TexturedModel>(HexModelFactory::createTexturedHexModel(loader, 10.0f, RessourceType::NONE));
    hexModelWood = std::make_shared<TexturedModel>(HexModelFactory::createTexturedHexModel(loader, 10.0f, RessourceType::WOOD));
    hexModelStone = std::make_shared<TexturedModel>(HexModelFactory::createTexturedHexModel(loader, 10.0f, RessourceType::STONE));
    map = std::make_unique<Map>();

    AssetManager::loadModel("lowPolyTree", "assets/trees/lowPolyTree.obj", "assets/trees/lowPolyTree.png", loader);
    AssetManager::loadModel("lowPolyTree2", "assets/trees/tree.obj", "assets/trees/tree.png", loader);

    //treeModel = std::make_unique<TexturedModel>(*OBJLoader::loadModel("assets/trees/lowPolyTree.obj", "assets/trees/lowPolyTree.png", loader));
    //treeEntity = std::make_unique<Entity>(Entity(treeModel, glm::vec3(0,0,0), 0,0,0, 0.5f));
    MapGenerator::init(loader, 10.f);
    MapGenerator::generateHexMap(*map, 10,10, *entityManager);
    //printf("Generated Terrain with %lu Tiles!\n", map->tiles.size());


    EventBus::getInstance().subscribe<TurnChangedEvent>([this](const TurnChangedEvent& event) {
         ProducingSystem::onTurnEnded(*entityManager);
    });

    gameInputUser = std::make_unique<GameInputUser>(*entityManager, *mousePicker, *camera, *gameMode);
    Application::getInstance().stateManager->registerMouseUser(gameInputUser.get(), {StateRegistry::get().game});

    EventBus::getInstance().subscribe<BuildingTypeSelectEvent>([this](const BuildingTypeSelectEvent& event) {
       gameMode->setActiveBuilding(event.selectedBuildingType);
    });

    std::unordered_map<Engine::PlayerID, glm::vec3> colorMapping;
    colorMapping[0] = glm::vec3(1.0f, 0.0f, 0.0f);
    colorMapping[1] = glm::vec3(0.0f, 1.0f, 0.0f);
    colorMapping[2] = glm::vec3(0.0f, 0.0f, 1.0f);
    colorMapping[3] = glm::vec3(1.0f, 1.0f, 0.0f);
    MinimapConfig minimapConfig = MinimapConfig(200, colorMapping);
    renderer->configureMinimap(minimapConfig);
}

void GameLayer::onDetach()
{
    Layer::onDetach();
}

void GameLayer::onUpdate()
{
    mousePicker->update(*camera);
    if (gameInputUser->isKeyboardEnabled()) {
        KeyboardIntent intent = gameInputUser->processKeyboard();

        camera->move(intent.moveDir, 0.5f);

        if (intent.buildingType.has_value()) {
            gameMode->setActiveBuilding(*intent.buildingType);
        }

        if (intent.nextTurn) {
            worldSystems->onTurnEnd(*entityManager, *gameMode, *turnState);
        }

        if (intent.toggleUpgrade) {
            if (gameMode->isUpgradeMode()) {
                UpgradeSystem::disableUpgradeMode(*entityManager, gameMode->getCurrentPlayer(), *gameMode);
                gameMode->setUpgradeMode(false);
            } else {
                UpgradeSystem::enableUpgradeMode(*entityManager, gameMode->getCurrentPlayer(), *gameMode, *turnState);
                gameMode->setUpgradeMode(true);
            }
        }

        if (intent.cancelAction) {
            gameMode->resetActiveBuilding();
            BuildPreviewSystem::disableBuildPreview(*entityManager);
        }
    }

    AnimationSystem::update(*entityManager, EngineTime::totalTime);
    worldSystems->update(*entityManager, *gameMode, *mousePicker, *camera, *gameInputUser, *turnState);

}

void GameLayer::onRender() {
    RenderSystem::render(*entityManager, *renderer);

    renderer->render(*light, *camera);
}