#include "ui_layer.h"

#include "scene/scene.h"
#include "core/settings_manager.h"
#include "core/hdri_manager.h"
#include "rendering/render_api.h"

#include <imgui.h>
#include <glm/glm.hpp>
#include <string>

namespace Donut
{
    // One-time ImGui theme: rounded, roomy, dark with a warm accretion-disk accent.
    static auto apply_donut_style() -> void
    {
        ImGuiStyle& s = ImGui::GetStyle();
        s.WindowRounding = 7.0f; s.ChildRounding = 5.0f; s.FrameRounding = 4.0f;
        s.GrabRounding = 4.0f; s.PopupRounding = 4.0f; s.ScrollbarRounding = 5.0f; s.TabRounding = 4.0f;
        s.WindowPadding = ImVec2(12, 12); s.FramePadding = ImVec2(9, 5);
        s.ItemSpacing = ImVec2(9, 8); s.ItemInnerSpacing = ImVec2(7, 5);
        s.WindowBorderSize = 0.0f; s.FrameBorderSize = 0.0f; s.WindowTitleAlign = ImVec2(0.02f, 0.5f);

        const ImVec4 amber   = ImVec4(0.98f, 0.62f, 0.20f, 1.00f);
        const ImVec4 amberHi = ImVec4(1.00f, 0.73f, 0.36f, 1.00f);
        ImVec4* c = s.Colors;
        c[ImGuiCol_WindowBg]        = ImVec4(0.07f, 0.08f, 0.10f, 0.97f);
        c[ImGuiCol_ChildBg]         = ImVec4(0.10f, 0.11f, 0.13f, 0.55f);
        c[ImGuiCol_PopupBg]         = ImVec4(0.09f, 0.10f, 0.12f, 0.98f);
        c[ImGuiCol_TitleBg]         = ImVec4(0.09f, 0.10f, 0.12f, 1.00f);
        c[ImGuiCol_TitleBgActive]   = ImVec4(0.13f, 0.14f, 0.17f, 1.00f);
        c[ImGuiCol_Text]            = ImVec4(0.90f, 0.91f, 0.93f, 1.00f);
        c[ImGuiCol_TextDisabled]    = ImVec4(0.48f, 0.50f, 0.54f, 1.00f);
        c[ImGuiCol_FrameBg]         = ImVec4(0.16f, 0.17f, 0.20f, 1.00f);
        c[ImGuiCol_FrameBgHovered]  = ImVec4(0.22f, 0.24f, 0.28f, 1.00f);
        c[ImGuiCol_FrameBgActive]   = ImVec4(0.26f, 0.28f, 0.33f, 1.00f);
        c[ImGuiCol_Header]          = ImVec4(0.17f, 0.19f, 0.23f, 1.00f);
        c[ImGuiCol_HeaderHovered]   = ImVec4(0.24f, 0.27f, 0.32f, 1.00f);
        c[ImGuiCol_HeaderActive]    = ImVec4(0.28f, 0.31f, 0.37f, 1.00f);
        c[ImGuiCol_Button]          = ImVec4(0.20f, 0.22f, 0.26f, 1.00f);
        c[ImGuiCol_ButtonHovered]   = ImVec4(0.27f, 0.30f, 0.35f, 1.00f);
        c[ImGuiCol_ButtonActive]    = amber;
        c[ImGuiCol_SliderGrab]      = amber;
        c[ImGuiCol_SliderGrabActive]= amberHi;
        c[ImGuiCol_CheckMark]       = amberHi;
        c[ImGuiCol_Tab]             = ImVec4(0.13f, 0.14f, 0.17f, 1.00f);
        c[ImGuiCol_TabHovered]      = ImVec4(0.28f, 0.31f, 0.37f, 1.00f);
        c[ImGuiCol_TabActive]       = ImVec4(0.22f, 0.24f, 0.28f, 1.00f);
        c[ImGuiCol_Separator]       = ImVec4(0.20f, 0.22f, 0.26f, 1.00f);
        c[ImGuiCol_ScrollbarGrab]   = ImVec4(0.24f, 0.26f, 0.30f, 1.00f);
    }

    namespace
    {
        // Setup: renderer backend + environment
        class SetupWorkspace : public Workspace
        {
        public:
            auto name() const -> const char* override { return "Setup"; }
            auto view() const -> View override { return View::None; }
            auto on_ui(const UIContext& ctx) -> void override
            {
                if (ImGui::CollapsingHeader("Renderer", ImGuiTreeNodeFlags_DefaultOpen))
                {
                    auto& s = SettingsManager::get_settings();
                    const char* apis[] = { "OpenGL", "Vulkan" };
                    int cur = (s.graphics.render_api == "Vulkan") ? 1 : 0;
                    if (ImGui::Combo("Graphics API", &cur, apis, 2))
                    {
                        s.graphics.render_api = apis[cur];
                        SettingsManager::save_settings();
                    }
                    const char* running = (RendererAPI::get_api() == RendererAPI::API::Vulkan) ? "Vulkan" : "OpenGL";
                    if (s.graphics.render_api != running)
                        ImGui::TextColored(ImVec4(0.98f, 0.62f, 0.20f, 1.0f), "Restart to apply (%s running)", running);
                    else
                        ImGui::TextDisabled("Active backend: %s", running);
                }

                if (ImGui::CollapsingHeader("Environment", ImGuiTreeNodeFlags_DefaultOpen))
                {
                    auto& hdri = HDRIManager::get();
                    std::string preview = hdri.get_hdri_name(ctx.scene.hdri_path);
                    if (ImGui::BeginCombo("Starfield", preview.c_str()))
                    {
                        for (const auto& path : hdri.get_available_hdri())
                        {
                            bool selected = (path == ctx.scene.hdri_path);
                            if (ImGui::Selectable(hdri.get_hdri_name(path).c_str(), selected))
                                ctx.scene.hdri_path = path;   // RenderPath rebuilds the cubemap next frame
                            if (selected) ImGui::SetItemDefaultFocus();
                        }
                        ImGui::EndCombo();
                    }
                    ImGui::TextDisabled("Switching rebuilds the cubemap (brief pause).");
                }
            }
        };

        // Scene: place and edit objects
        class SceneWorkspace : public Workspace
        {
        public:
            auto name() const -> const char* override { return "Scene"; }
            auto view() const -> View override { return View::Scene; }
            auto on_ui(const UIContext& ctx) -> void override
            {
                Scene& sc = ctx.scene;
                ImGui::TextDisabled("Drag to orbit, scroll to zoom. HDRI skybox behind.");
                auto& objs = sc.objects;
                if (sc.selected_object >= (int)objs.size()) sc.selected_object = (int)objs.size() - 1;

                ImGui::Text("Spheres (%d)", (int)objs.size());
                if (ImGui::Button("Add") && objs.size() < 64)
                {
                    SceneObject o;
                    o.position = glm::vec3(((int)objs.size() % 5) * 5.0f - 10.0f, 2.0f, ((int)objs.size() / 5) * 5.0f);
                    o.radius   = 1.5f;
                    o.color    = glm::vec3(0.35f + 0.12f * (objs.size() % 5), 0.55f, 0.9f - 0.12f * (objs.size() % 4));
                    objs.push_back(o);
                    sc.selected_object = (int)objs.size() - 1;
                }
                ImGui::SameLine();
                if (ImGui::Button("Delete") && !objs.empty())
                {
                    objs.erase(objs.begin() + sc.selected_object);
                    if (sc.selected_object >= (int)objs.size()) sc.selected_object = (int)objs.size() - 1;
                }

                ImGui::BeginChild("obj_list", ImVec2(0, 120), true);
                for (int i = 0; i < (int)objs.size(); ++i)
                {
                    std::string label = "Sphere " + std::to_string(i);
                    if (ImGui::Selectable(label.c_str(), sc.selected_object == i)) sc.selected_object = i;
                }
                ImGui::EndChild();

                if (sc.selected_object >= 0 && sc.selected_object < (int)objs.size())
                {
                    SceneObject& o = objs[sc.selected_object];
                    ImGui::DragFloat3("Position", &o.position.x, 0.1f);
                    ImGui::DragFloat("Radius", &o.radius, 0.05f, 0.1f, 20.0f);
                    ImGui::ColorEdit3("Color", &o.color.x);
                }
            }
        };

        // Simulation: camera + accretion disk + quality
        class SimulationWorkspace : public Workspace
        {
        public:
            auto name() const -> const char* override { return "Simulation"; }
            auto view() const -> View override { return View::BlackHole; }
            auto on_ui(const UIContext& ctx) -> void override
            {
                Scene& sc = ctx.scene;
                BlackHoleParams& bh = sc.black_hole;

                if (ImGui::CollapsingHeader("Camera", ImGuiTreeNodeFlags_DefaultOpen))
                {
                    bool ff = sc.is_free_fly();
                    if (ImGui::RadioButton("Orbital", !ff)) sc.set_free_fly(false);
                    ImGui::SameLine();
                    if (ImGui::RadioButton("Free-fly", ff)) sc.set_free_fly(true);
                    ImGui::SameLine();
                    if (ImGui::Button("Reset view")) sc.reset_sim_camera();
                    ImGui::SliderFloat("FOV", &bh.fov_degrees, 20.0f, 90.0f, "%.0f\xc2\xb0");
                    ImGui::TextDisabled(ff ? "WASD move | Q/E down-up | Shift boost | drag look"
                                           : "Drag to orbit | scroll to zoom");
                }

                if (ImGui::CollapsingHeader("Accretion disk", ImGuiTreeNodeFlags_DefaultOpen))
                {
                    ImGui::SliderFloat("Temperature", &bh.temperature, 2000.0f, 15000.0f, "%.0f K");
                    ImGui::SliderFloat("Brightness",  &bh.brightness, 0.0f, 3.0f, "%.2f");
                    ImGui::SliderFloat("Inner radius", &bh.disk_inner_rs, 3.0f, 12.0f, "%.1f r_s");
                    if (bh.disk_outer_rs < bh.disk_inner_rs + 0.5f) bh.disk_outer_rs = bh.disk_inner_rs + 0.5f;
                    ImGui::SliderFloat("Outer radius", &bh.disk_outer_rs, bh.disk_inner_rs + 0.5f, 25.0f, "%.1f r_s");
                    ImGui::SliderFloat("Turbulence",  &bh.turbulence, 0.0f, 2.0f, "%.2f");
                    ImGui::TextDisabled("Inner edge is the ISCO (3 r_s). Novikov-Thorne profile.");
                }

                if (ImGui::CollapsingHeader("Quality"))
                {
                    ImGui::SliderInt("Integration steps", &bh.quality_steps, 2000, 15000);
                    ImGui::TextDisabled("Deeper lensing at higher cost. Settled frame is 4x supersampled.");
                }
            }
        };

        // Export: pick what to render out (not wired up yet)
        class ExportWorkspace : public Workspace
        {
        public:
            auto name() const -> const char* override { return "Export"; }
            auto view() const -> View override { return View::None; }
            auto on_ui(const UIContext&) -> void override
            {
                ImGui::TextDisabled("Render observables to disk for analysis.");
                ImGui::Spacing();
                if (ImGui::CollapsingHeader("Channels", ImGuiTreeNodeFlags_DefaultOpen))
                {
                    ImGui::Checkbox("Colour (tonemapped)",   &m_color);
                    ImGui::Checkbox("Redshift (g)",          &m_redshift);
                    ImGui::Checkbox("Emission temperature",  &m_temperature);
                    ImGui::Checkbox("Impact parameter",      &m_impact);
                }
                if (ImGui::CollapsingHeader("Output", ImGuiTreeNodeFlags_DefaultOpen))
                {
                    ImGui::Combo("Resolution", &m_resolution, "960 x 540\0" "1920 x 1080\0" "3840 x 2160\0");
                    ImGui::Combo("Format",     &m_format,     "PNG\0" "EXR (HDR)\0" "CSV (data)\0");
                }
                ImGui::Spacing();
                ImGui::BeginDisabled();
                ImGui::Button("Export frame", ImVec2(-1.0f, 0.0f));
                ImGui::EndDisabled();
                ImGui::TextDisabled("Not wired up yet: needs the RHI readback path + G-buffer shader outputs.");
            }
        private:
            bool m_color = true, m_redshift = false, m_temperature = false, m_impact = false;
            int  m_resolution = 1, m_format = 0;
        };
    }

    UILayer::UILayer()
    {
        m_workspaces.push_back(create_scope<SetupWorkspace>());
        m_workspaces.push_back(create_scope<SceneWorkspace>());
        m_workspaces.push_back(create_scope<SimulationWorkspace>());
        m_workspaces.push_back(create_scope<ExportWorkspace>());

        // Open on Simulation so the black hole greets the user on launch.
        for (int i = 0; i < (int)m_workspaces.size(); ++i)
            if (std::string(m_workspaces[i]->name()) == "Simulation") { m_landing = i; m_active = i; }
    }

    auto UILayer::draw(const UIContext& ctx) -> View
    {
        static bool styled = false;
        if (!styled) { apply_donut_style(); styled = true; }

        // Full-viewport dock space with a pass-through centre, so the panel docks to
        // any edge while the render shows through the middle.
        ImGui::DockSpaceOverViewport(0, ImGui::GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode);

        ImGui::SetNextWindowSize(ImVec2(360, 620), ImGuiCond_FirstUseEver);
        ImGui::Begin("Donut");

        ImGuiIO& io = ImGui::GetIO();
        ImGui::TextDisabled("%s", ctx.device_name.empty() ? "GPU" : ctx.device_name.c_str());
        ImGui::Text("%.0f FPS", io.Framerate);
        ImGui::SameLine(); ImGui::TextDisabled("%.1f ms/frame", io.Framerate > 0 ? 1000.0f / io.Framerate : 0.0f);
        ImGui::Spacing();

        if (ImGui::BeginTabBar("workspaces"))
        {
            for (int i = 0; i < (int)m_workspaces.size(); ++i)
            {
                ImGuiTabItemFlags flags = (!m_landed && i == m_landing) ? ImGuiTabItemFlags_SetSelected : 0;
                if (ImGui::BeginTabItem(m_workspaces[i]->name(), nullptr, flags))
                {
                    m_active = i;
                    ImGui::Spacing();
                    m_workspaces[i]->on_ui(ctx);
                    ImGui::EndTabItem();
                }
            }
            ImGui::EndTabBar();
            m_landed = true;
        }
        ImGui::End();

        return m_workspaces[m_active]->view();
    }
}