#include "Instance.h"
#include "Mesh.h"
#include "Tools.h"
#include "bx/timer.h"

#include <imgui.h>
#include <tracy/Tracy.hpp>

namespace
{
    constexpr int32_t FrameTimeBufSize = 512;
    int64_t FrameTimes[FrameTimeBufSize]{0};
    int32_t FrameTimeIdx = 0;
} // namespace

namespace Tools
{
    const char* GetAssetPath(Generated::AssetHandle assetHandle)
    {
        const auto& inst = Game::GetInstance();
        for (int32_t j = 0; j < inst.DebugData.AssetCount; ++j)
        {
            if (inst.DebugData.AssetHandles[j] == assetHandle)
            {
                return inst.DebugData.AssetHandlePaths[j];
            }
        }
        return "---";
    }

    void ModelDropdown(Generated::ModelHandle& modelHandle)
    {
        auto& R = Game::GameRendering::Get();
        const char* name = GetAssetPath(modelHandle.Asset);
        if (ImGui::BeginCombo("Model", name))
        {
            for (int32_t i = 0; i < R.ModelCount; ++i)
            {
                if (ImGui::Selectable(GetAssetPath(R.Models[i].Handle.Asset), i == modelHandle.ModelIdx))
                {
                    modelHandle = R.Models[i].Handle;
                }
            }
            ImGui::EndCombo();
        }
    }

    void TextureDropdown(Generated::TextureHandle& texHandle)
    {
        auto& R = Game::GameRendering::Get();
        const char* name = GetAssetPath(texHandle.Asset);
        if (ImGui::BeginCombo("Texture", name))
        {
            for (int32_t i = 0; i < R.MaxTextures; ++i)
            {
                if (!IsValid(R.Textures[i].TexHandle)) continue;
                ImGui::PushID(i);
                ImVec2 pos = ImGui::GetCursorScreenPos();
                if (ImGui::Selectable("", i == texHandle.TextureIdx, ImGuiSelectableFlags_AllowOverlap, {0, 64}))
                {
                    texHandle = R.Textures[i].TexHandle;
                }
                ImGui::SetCursorScreenPos(pos);
                ImGui::Image(R.Textures[i].RenderHandle.idx, {64, 64});
                ImGui::SameLine();
                ImGui::Text("%s", GetAssetPath(R.Textures[i].TexHandle.Asset));
                ImGui::PopID();
            }
            ImGui::EndCombo();
        }
    }
    void RenderDebugUI(Game::GameRendering& rendering)
    {
        auto& time = Game::GetInstance().Time;
        if (rendering.UIVisible == Game::UIVisibilityState::Debug)
        {
            ZoneScopedN("DebugUI");

            auto& shared = Game::GetShared();
            auto& debug = Game::GetInstance().DebugData;
            auto& level = Game::GetInstance().GameLevel;

            if (ImGui::IsMouseClicked(ImGuiMouseButton_Right))
            {
                debug.DebugCardRotation++;
                if (debug.DebugCardRotation >= 4) debug.DebugCardRotation = 0;
            }
            if (ImGui::Begin("Log"))
            {
                ImGui::Checkbox("Shorten File Names", &debug.ShortenLogFileNames);
                ImGui::BeginTable(
                    "tbl", 4, ImGuiTableFlags_Resizable | ImGuiTableFlags_Hideable | ImGuiTableFlags_SizingFixedFit);
                ImGui::TableSetupColumn("Time", ImGuiTableColumnFlags_NoResize);
                ImGui::TableSetupColumn("Log");
                ImGui::TableSetupColumn("Line", ImGuiTableColumnFlags_NoResize);
                ImGui::TableSetupColumn("File", ImGuiTableColumnFlags_NoResize);
                ImGui::TableHeadersRow();
                for (int32_t i = 0; i < bx::min(100, LogInternal::LogHistorySize); ++i)
                {
                    int32_t idx = GetLogHistory().WriteIdx - i - 1;
                    if (idx < 0) idx += LogInternal::LogHistorySize;
                    const char* line = &GetLogHistory().LogBuffer[idx * LogInternal::MaxLineSize];
                    if (line[0] != 0)
                    {
                        int64_t timeOffset = GetLogHistory().WriteTime[idx] - time.StartTime;
                        double writeTime = (double)timeOffset / bx::getHPFrequency();
                        uint32_t fileLine = GetLogHistory().LineBuffer[idx];
                        const char* filePath = &GetLogHistory().FileBuffer[idx * LogInternal::MaxLineSize];
                        const char* filePathRes =
                            debug.ShortenLogFileNames ? bx::FilePath{filePath}.getFileName().getPtr() : filePath;

                        ImGui::TableNextRow();
                        ImGui::TableNextColumn();
                        ImGui::Text("%.01f", writeTime);

                        ImGui::TableNextColumn();
                        ImGui::Text("%s", line);
                        ImGui::SetItemTooltip("%f\n%s%s:%u", writeTime, line, filePath, fileLine);

                        ImGui::TableNextColumn();
                        ImGui::Text("%u", fileLine);

                        ImGui::TableNextColumn();
                        ImGui::Text("%s", filePathRes);
                    }
                }
                ImGui::EndTable();
            }
            ImGui::End();
            if (ImGui::Begin("Rendering"))
            {
                if (rendering.LastShaderLoadTime >= 0.0f)
                {
                    ImGui::TextColored({0.2f, 0.9f, 0.2f, 1.0f},
                                       "Shader loaded %.0f seconds ago",
                                       time.Now - rendering.LastShaderLoadTime);
                }
                else
                {
                    ImGui::TextColored({0.9f, 0.2f, 0.2f, 1.0f}, "Shader load Failiure!");
                }
                if (ImGui::Button("Reload Meshes"))
                {
                    LoadModels(rendering.Models, rendering.ModelCount);
                }
                ImGui::SameLine();
                if (ImGui::Button("Reload Level"))
                {
                    level = {};
                    level.Setup(shared.Game);
                }
                ImGui::Checkbox("Show ImGui Demo", &debug.ShowImguiDemo);
                if (debug.ShowImguiDemo) ImGui::ShowDemoWindow(&debug.ShowImguiDemo);
                ImGui::Separator();

                ImGui::Checkbox("Cubes", &level.Cubes.IsEnabled);
                ImGui::Checkbox("Tests", &level.Tests.IsEnabled);
                ImGui::Checkbox("PuzzleTiles", &level.PuzzleTiles.IsEnabled);
                ImGui::Checkbox("UIQuads", &level.UIQuads.IsEnabled);

                if (ImGui::Button("Dithergen"))
                {
                    DitherGen(rendering.DitherTextures, rendering.DitherRecursion);
                }
                ImGui::SameLine();
                ImGui::SliderInt("Recursion", &rendering.DitherRecursion, 1, 4);
                ImGui::Text("%ux%ux%u",
                            rendering.DitherTextures.DitherTexWH,
                            rendering.DitherTextures.DitherTexWH,
                            rendering.DitherTextures.DitherTexDepth);
                if (!isValid(rendering.DitherTextures.PreviewTex))
                {
                    ImGui::Text("Invalid Texture");
                }
                else
                {
                    ImGui::Image(
                        rendering.DitherTextures.PreviewTex.idx,
                        {(float)rendering.DitherTextures.DitherTexWH,
                         (float)rendering.DitherTextures.DitherTexWH * rendering.DitherTextures.DitherTexDepth});
                }
                if (isValid(rendering.DitherTextures.RampTex))
                {
                    ImGui::Image(rendering.DitherTextures.RampTex.idx,
                                 {BX_COUNTOF(rendering.DitherTextures.BrightnessRamp), 8});
                }
                Vec3 quadPos = level.UIQuads.Get({0}).EData.Transform.GetPosition();
                ImGui::Text("%f %f %f", quadPos.x, quadPos.y, quadPos.z);

                if (ImGui::ColorEdit3("Base Color", &rendering.DefaultBaseColor.x))
                {
                    auto& tiles = level.PuzzleTiles;
                    for (int32_t i = 0; i < tiles.Count; ++i)
                    {
                        tiles.Data[i].EData.BaseColor = rendering.DefaultBaseColor;
                    }
                }
                if (ImGui::ColorEdit3("Dot Color", &rendering.DefaultTileColor.x))
                {
                    auto& tiles = level.PuzzleTiles;
                    for (int32_t i = 0; i < tiles.Count; ++i)
                    {
                        tiles.Data[i].EData.TestColor = rendering.DefaultTileColor;
                    }
                }

                ImGui::Text("Shader log:");
                ImGui::TextWrapped("%s", Game::GetShared().Dev.ShaderLog);
            }
            ImGui::End();
            if (ImGui::Begin("Textures"))
            {
                if (ImGui::Button("Reload"))
                {
                    rendering.LoadTextures();
                }
                for (int32_t i = 0; i < rendering.MaxTextures; ++i)
                {
                    if (!isValid(rendering.Textures[i].RenderHandle)) continue;
                    ImGui::Text("%i", i);
                    float width = bx::min<float>(ImGui::GetContentRegionAvail().x, rendering.Textures[i].Info.width);
                    float height = bx::min<float>(ImGui::GetContentRegionAvail().x, rendering.Textures[i].Info.height);
                    ImGui::Image(rendering.Textures[i].RenderHandle.idx, {width, height});
                }
            }
            ImGui::End();
            if (ImGui::Begin("Puzzles"))
            {
                if (ImGui::Button("Add"))
                {
                    bool found = false;
                    for (int32_t i = 0; i < BX_COUNTOF(level.Puzzles); ++i)
                    {
                        auto& puz = level.Puzzles[i].Data;
                        if (puz.ID == UINT16_MAX)
                        {
                            bx::strCopy(puz.PuzzleName, sizeof(puz.PuzzleName), "Unnamed Puzzle");
                            puz.ID = i;
                            found = true;
                            break;
                        }
                    }
                    if (!found)
                    {
                        LOG_ERROR("Too many puzzles!");
                    }
                }
                ImGui::Separator();
                for (int32_t i = 0; i < BX_COUNTOF(level.Puzzles); ++i)
                {
                    auto& puzzleData = level.Puzzles[i].Data;
                    if (puzzleData.ID == UINT16_MAX) continue;

                    bool isSelected = debug.SelectedDebugLevel == i;
                    ImGui::PushID("selectable");
                    if (ImGui::Selectable(puzzleData.PuzzleName, isSelected))
                    {
                        debug.SelectedDebugLevel = isSelected ? UINT16_MAX : i;
                    }
                    ImGui::PopID();
                }
            }
            ImGui::End();
            if (debug.SelectedDebugLevel < BX_COUNTOF(level.Puzzles))
            {
                if (!Puzzle::RenderDebugUI(level.Puzzles[debug.SelectedDebugLevel].Data))
                {
                    debug.SelectedDebugLevel = UINT16_MAX;
                }
            }
            if (ImGui::Begin("Cards"))
            {
                Generated::StaticPuzzleData& staticData = Puzzle::GetStaticPuzzleData();
                if (ImGui::Button("Save"))
                {
                    Puzzle::SaveStaticPuzzleData();
                }
                ImGui::SameLine();
                if (ImGui::Button("Reload"))
                {
                    Puzzle::LoadStaticPuzzleData();
                }

                for (int32_t i = 0; i < BX_COUNTOF(staticData.Cards); ++i)
                {
                    ImGui::Separator();

                    Generated::StaticPuzzleCard& card = staticData.Cards[i];
                    ImGui::PushID(i);
                    char cardName[64]{0};
                    bx::snprintf(cardName, sizeof(cardName), "%i", i);
                    ImGui::Selectable(cardName);
                    if (ImGui::BeginDragDropSource())
                    {
                        Puzzle::DrawCard(card, debug.DebugCardRotation, ImGui::GetCursorScreenPos());
                        ImGui::SetDragDropPayload("cardtype", &i, sizeof(i));
                        ImGui::EndDragDropSource();
                    }

                    Tools::ModelDropdown(card.ModelHandle);
                    Tools::TextureDropdown(card.BoardTextureHandle);
                    for (int8_t y = 0; y < Puzzle::Config::CardSize; ++y)
                    {
                        ImGui::PushID(y);
                        for (int8_t x = 0; x < Puzzle::Config::CardSize; ++x)
                        {
                            if (x > 0) ImGui::SameLine();
                            ImGui::PushID(x);
                            auto& node = Puzzle::EditCardNodeAt(card, 0, x, y);
                            if (ImGui::Button(Generated::PuzzleElementType::ShortName[node], {26, 24}))
                            {
                                int32_t newVal = int32_t(node) + 1;
                                if (newVal >= Generated::PuzzleElementType::EntryCount)
                                {
                                    newVal = 0;
                                }
                                node = Generated::PuzzleElementType::Enum(newVal);
                            }
                            ImGui::PopID();
                        }
                        ImGui::PopID();
                    }
                    ImGui::PopID();
                }
            }
            ImGui::End();
        }
        ImGui::SetNextWindowPos({0, 0});
        if (ImGui::Begin("Stats",
                         nullptr,
                         ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoInputs |
                             ImGuiWindowFlags_AlwaysAutoResize))
        {
            if (Game::GetInstance().Player.CameraM == Game::CameraMode::Freefly)
            {
                ImGui::PushStyleColor(ImGuiCol_Text, {0.8f, 0.1f, 0.1f, 1.0f});
                ImGui::Text("NOCLIP");
                ImGui::PopStyleColor();
            }
            ImGui::Text("Delta: %.01fms", time.Delta * 1000);
            ImGui::Text("FPS: %.0f", 1.0 / time.Delta);

            constexpr ImVec2 FpsPlotSize{200, 60};
            if (ImGui::BeginChild("FpsPlot", FpsPlotSize))
            {
                auto& drawList = *ImGui::GetWindowDrawList();
                ImVec2 pos = ImGui::GetWindowPos();
                drawList.AddRectFilled(pos, {pos.x + FpsPlotSize.x, pos.y + FpsPlotSize.y}, 0x22222233);

                float scale = 1000.0f;

                for (int32_t i = 0; i < FrameTimeBufSize; ++i)
                {
                    int32_t idx = FrameTimeIdx - i - 1;
                    int32_t prevIdx = idx - 1;
                    if (idx < 0) idx += FrameTimeBufSize;
                    if (prevIdx < 0) prevIdx += FrameTimeBufSize;

                    if (FrameTimes[idx] == 0 || FrameTimes[prevIdx] == 0) continue;

                    int64_t frameTime = FrameTimes[idx] - FrameTimes[prevIdx];
                    double frameTimeSec = (double)frameTime / bx::getHPFrequency();
                    drawList.AddLine(
                        {pos.x + (FpsPlotSize.x - i - 1), pos.y + FpsPlotSize.y},
                        {pos.x + (FpsPlotSize.x - i - 1), pos.y + FpsPlotSize.y - (float)frameTimeSec * scale},
                        0xFFFFFFFF);
                }
            }
            ImGui::EndChild();
        }
        ImGui::End();
    }
    void MeasureFrameEnd()
    {
        FrameTimes[FrameTimeIdx] = bx::getHPCounter();
        ++FrameTimeIdx;
        if (FrameTimeIdx >= FrameTimeBufSize) FrameTimeIdx = 0;
    }
} // namespace Tools