#ifndef EDITOR_HPP
#define EDITOR_HPP

#include "open_engine/renderer/renderer2d.hpp"
#include <open_engine.hpp>

#include <glm/ext/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/fwd.hpp>
#include <imgui.h>
#include <glad/glad.h>
#include <GLFW/glfw3.h>

class EditorLayer : public OpenEngine::Layer
{
    public:
        EditorLayer()
            : OpenEngine::Layer("editor_layer"),
            camera(1280.0f / 720.0f, 1.0f)
        {
        }
        ~EditorLayer() {};

        void OnAttach() override
        {
            OE_PROFILE_FUNCTION();
            {
                OE_PROFILE_SCOPE("Texture2D Creation");
                face = OpenEngine::Texture2D::Create("assets/textures/awesomeface.png");
            }

            OpenEngine::FramebufferSpecification specs;
            specs.width = 1280;
            specs.height = 720;

            framebuffer = OpenEngine::FrameBuffer::Create(specs);
        }

        void OnDetach() override
        {
        }

        void OnUpdate() override
        {

            OpenEngine::Renderer2D::ResetStats();
            OE_PROFILE_FUNCTION()
            {
                camera.OnUpdate();
                framebuffer->Bind();

                OE_PROFILE_SCOPE("Setting up Rendering");

                OpenEngine::RenderCommand::SetClearColor({0.11f, 0.11f, 0.15f, 1.0f});
                OpenEngine::RenderCommand::Clear();
                OpenEngine::Renderer2D::BeginScene(camera.GetCamera());
            }
            {
                OE_PROFILE_SCOPE("Drawing Quads");
                OpenEngine::Transform tr1 = {glm::vec3(0.0f, 0.0f, -0.1f), glm::vec3(1.0f, 1.0f, 0.0f), angle};
                OpenEngine::Transform tr3 = {glm::vec3(-0.5f, -0.5f, 0.0f), glm::vec3(1.0f, 0.5f, 0.0f), angle * 0.5f};
                OpenEngine::Renderer2D::DrawQuad(tr1, face);
                OpenEngine::Renderer2D::DrawQuad(tr3, rectangle_color);
            }

            OpenEngine::Renderer2D::EndScene();

            OpenEngine::Renderer2D::BeginScene(camera.GetCamera());

            for (float y = -5.0f; y < 5.0f; y += 0.5f) {
                for (float x = -5.0f; x < 5.0f; x += 0.5f) {

                    glm::vec4 gradient_color = {(x + 5.0f) / 10.0f, 0.3f, (y + 5.0f) / 10.0f, 1.0f};
                    OpenEngine::Renderer2D::DrawQuad({{x, y, 0.0f}, glm::vec3(0.45f, 0.45f, 0.0f)}, gradient_color);

                }
            }

            OpenEngine::Renderer2D::EndScene();

            framebuffer->Unbind();
        }

        void OnEvent(OpenEngine::Event& event) override
        {
            OE_PROFILE_FUNCTION();

            {
                OE_PROFILE_SCOPE("Camera OnEvent");
                camera.OnEvent(event);
            }
        }

        void OnImGuiRender() override
        {
            OE_PROFILE_FUNCTION();

            ImGui::DockSpaceOverViewport();

            ImGui::Begin("Square settings");

            ImGui::SliderFloat("Angle", &angle, -360, 360);
            ImGui::ColorPicker4("Rectangle color", &rectangle_color[0]);

            for (auto& result : profiling_results)
            {
                char label[50];
                strcpy(label, "%.3fms ");
                strcat(label, result.name);
                ImGui::Text(label, result.duration);
            }

            profiling_results.clear();

            ImGui::End();
            ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2{ 0, 0 });
            ImGui::Begin("Viewport");
            ImVec2 viewport_panel_size = ImGui::GetContentRegionAvail();
            if (viewport_size != *((glm::vec2*)&viewport_panel_size)) {
                framebuffer->Resize(viewport_panel_size.x, viewport_panel_size.y);
                viewport_size = { viewport_panel_size.x, viewport_panel_size.y };

                camera.OnResize(viewport_panel_size.x, viewport_panel_size.y);
            }
            uint32_t texture_id = framebuffer->GetColorAttachmentRendererID();
            ImGui::Image((void*)texture_id, ImVec2{ viewport_size.x, viewport_size.y }, ImVec2{ 0, 1 }, ImVec2{ 1, 0 });
            ImGui::End();
            ImGui::PopStyleVar();

            auto stats = OpenEngine::Renderer2D::GetStats();
            static float time = 0;

            time += OpenEngine::Time::DeltaTime();

            if (time >= 1) {
                time = 0;
            }

            ImGui::Begin("Statistics");
            ImGui::Text("FPS: %0.0f", 1 / OpenEngine::Time::DeltaTime());
            ImGui::Text("Renderer2D:");
            ImGui::Text("\t\tDraw calls: %d", stats.draw_calls);
            ImGui::Text("\t\tQuad count: %d", stats.quad_count);
            ImGui::Text("\t\tVertices count: %d", stats.GetToralVertexCount());
            ImGui::Text("\t\tIndices count: %d", stats.GetToralIndexCount());
            ImGui::End();
        }

    private:
        float angle = 0.0f;
        OpenEngine::Ref<OpenEngine::Texture2D> face;

        OpenEngine::OrthographicCameraController camera;

        std::vector<OpenEngine::Time::ProfilingResult> profiling_results;

        glm::vec2 viewport_size = { 0.0f, 0.0f };
        OpenEngine::Ref<OpenEngine::FrameBuffer> framebuffer;
        glm::vec4 rectangle_color = {0.8f, 0.2f, 0.7f, 1.0f};
};

class EditorApp : public OpenEngine::Application
{
    public:
        EditorApp();
        ~EditorApp();
};

#endif // EDITOR_HPP