#include "application.h"

#include "rendering/renderer.h"
#include "settings_manager.h"

#include "states/simulation_state.h"
#include "states/config_state.h"
#include "states/world_builder_state.h"

#include <GLFW/glfw3.h>
#include <ImGuizmo.h>

namespace Donut
{
    Application* Application::s_instance = nullptr;

    Application::Application(const std::string& name, int width, int height)
        : m_running(true), m_minimized(false)
    {
        s_instance = this;

        m_window = create_scope<Window>(name, width, height);
        m_window->set_event_callback([this](Event& event) 
        {
            on_event(event);
        });

        on_init();
    }

    Application::~Application()
    {
        on_shutdown();
        s_instance = nullptr;
    }

    void Application::run()
    {
        while (m_running)
        {
            if (!m_minimized)
            {
                on_update();
                on_render();
            }

            m_window->on_update();
        }
    }

    void Application::close()
    {
        m_running = false;
    }

    void Application::on_event(Event& event)
    {
        EventDispatcher dispatcher(event);
        dispatcher.dispatch<WindowCloseEvent>([this, &event](WindowCloseEvent& e) 
        {
            m_running = false;
            event.handled = true;
            return true;
        });
        
        dispatcher.dispatch<WindowResizeEvent>([this, &event](WindowResizeEvent& e) 
        {
            if (e.get_width() == 0 || e.get_height() == 0)
                m_minimized = true;
            else
                m_minimized = false;
            
            Renderer::on_window_resize(e.get_width(), e.get_height());
            m_engine->set_window_dimensions(e.get_width(), e.get_height());
            event.handled = true;
            return true;
        });
        
        dispatcher.dispatch<KeyPressedEvent>([this, &event](KeyPressedEvent& e) 
        {
            if (e.get_key_code() == GLFW_KEY_1)
            {
                m_state_manager->switch_to_state("Config");
                event.handled = true;
                return true;
            }
            else if (e.get_key_code() == GLFW_KEY_2)
            {
                m_state_manager->switch_to_state("Simulation");
                event.handled = true;
                return true;
            }
            else if (e.get_key_code() == GLFW_KEY_3)
            {
                m_state_manager->switch_to_state("WorldBuilder");
                event.handled = true;
                return true;
            }
            
            return true;
        });
        
        m_state_manager->on_event(event);
    }

    void Application::on_init()     
    { 
        Logger::init();
        
        SettingsManager::initialize();
        
        const auto& settings = SettingsManager::get_settings_const();
        RendererAPI::API api = (settings.graphics.render_api == "Vulkan") ? RendererAPI::API::Vulkan : RendererAPI::API::OpenGL;
        RendererAPI::set_api(api);
        
        Renderer::init();
        m_window->init_im_gui();
        
        Renderer::on_window_resize(1280, 720);
        RenderCommand::set_face_culling(false);

        m_engine = create_scope<Engine>();
        m_engine->set_window_dimensions(1280, 720);
        
        m_state_manager = create_scope<StateManager>();
        m_state_manager->register_state("Config",       create_scope<ConfigState>());
        m_state_manager->register_state("Simulation",   create_scope<SimulationState>());
        m_state_manager->register_state("WorldBuilder", create_scope<WorldBuilderState>());
        m_state_manager->switch_to_state("Config");
    }

    void Application::on_shutdown() 
    { 
        if (m_state_manager)
            m_state_manager->shutdown();
            
        Renderer::shutdown();
        SettingsManager::shutdown();
        Logger::shutdown();
    }

    void Application::on_update()
    {
        float current_frame = (float)glfwGetTime();
        m_delta_time = current_frame - m_last_frame;
        m_last_frame = current_frame;

        m_state_manager->update(m_delta_time);
    }

    void Application::on_render()
    {
        m_state_manager->render();
        m_window->begin_im_gui_frame();
        
        ImGuizmo::BeginFrame();
        ImGuizmo::SetOrthographic(false);
        
        setup_docking_layout();
        m_state_manager->on_im_ui_render();
        m_window->end_im_gui_frame();
    }
    
    void Application::setup_docking_layout()
    {
        ImGuiViewport* viewport = ImGui::GetMainViewport();
        ImGui::DockSpaceOverViewport(0, viewport, ImGuiDockNodeFlags_PassthruCentralNode);
    }
};