// IAEngine: 2D Game Engine by IA
// Copyright (C) 2025 IASoft (PVT) LTD (oss@iasoft.dev)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

#include <IAEngine/IAEngine.hpp>
#include <RenderCore/RenderCore.hpp>
#include <SDL3/SDL.h>

#include <Vendor/imgui/backends/imgui_impl_sdl3.h>
#include <Vendor/imgui/backends/imgui_impl_sdlgpu3.h>
#include <Vendor/imgui/imgui.h>

#include <UI.hpp>

namespace ia::iae::editor
{
    CONST IVec2 gamePreviewResolution = {800, 608};

    IVec2 g_windowExtent{800, 600};
    RDC_Texture *g_gamePreviewTexture{};

    VOID UI::Initialize()
    {
    }

    VOID UI::Terminate()
    {
    }

    VOID UI::Update()
    {
    }

    VOID UI::Draw()
    {
        ImVec2 gamePreviewViewSize = {(FLOAT32) gamePreviewResolution.x, (FLOAT32) gamePreviewResolution.y};

        { // Scene Nodes View
            ImGui::Begin("Nodes", nullptr,
                         ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse);
            ImGui::SetWindowPos({0.0f, 0.0f});
            ImGui::SetWindowSize({g_windowExtent.x / 2.0f - gamePreviewViewSize.x / 2.0f, gamePreviewViewSize.y + 35});
            ImGui::End();
        }

        { // Scene View
            ImGui::Begin("Scene", nullptr,
                         ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse);
            ImGui::SetWindowPos({g_windowExtent.x / 2.0f - gamePreviewViewSize.x / 2.0f, 0.0f});
            ImGui::Image(g_gamePreviewTexture->GetHandle(), gamePreviewViewSize);
            ImGui::End();
        }

        { // Properties View
            ImGui::Begin("Properties", nullptr,
                         ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse);
            ImGui::SetWindowSize({g_windowExtent.x / 2.0f - gamePreviewViewSize.x / 2.0f - 15.0f, gamePreviewViewSize.y + 35});
            ImGui::SetWindowPos({g_windowExtent.x - ImGui::GetWindowSize().x, 0.0f});
            ImGui::End();
        }

        { // Tileset View
            ImGui::Begin("Tilesets", nullptr,
                         ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse);
            ImGui::SetWindowPos({0.0f, gamePreviewViewSize.y + 35});
            ImGui::SetWindowSize({(FLOAT32)g_windowExtent.x, (FLOAT32)g_windowExtent.y - gamePreviewViewSize.y - 35});
            ImGui::End();
        }
    }
} // namespace ia::iae::editor

namespace ia::iae
{
    EXTERN Vec2 g_designViewport;
    EXTERN SDL_Window *g_windowHandle;
} // namespace ia::iae

namespace ia::iae::editor
{
    ImDrawData *g_imDrawData{};

    INT32 UI::Run(IN INT32 argc, IN PCCHAR argv[])
    {
        INT32 frameCounter{0};

        if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_GAMEPAD))
            THROW_UNKNOWN("Failed to intialize SDL: ", SDL_GetError());

        if (!(g_windowHandle = SDL_CreateWindow("IAEngine", g_windowExtent.x, g_windowExtent.y,
                                                SDL_WINDOW_RESIZABLE | SDL_WINDOW_MAXIMIZED)))
            THROW_UNKNOWN("Failed to create the SDL window: ", SDL_GetError());
        SDL_MaximizeWindow(g_windowHandle);
        SDL_GetWindowSizeInPixels(g_windowHandle, &g_windowExtent.x, &g_windowExtent.y);

        g_designViewport = gamePreviewResolution;
        IAEngine::__Initialize();

        g_gamePreviewTexture = new RDC_Texture(RDC_Texture::EType::SAMPLED, g_designViewport.x, g_designViewport.y);

        const auto mainScale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());

        IMGUI_CHECKVERSION();
        ImGui::CreateContext();
        auto &imGUIIO = ImGui::GetIO();
        imGUIIO.IniFilename = nullptr;
        imGUIIO.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
        imGUIIO.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;

        ImGui::StyleColorsClassic();

        ImGuiStyle &style = ImGui::GetStyle();
        style.ScaleAllSizes(mainScale);
        style.FontScaleDpi = mainScale;

        ImGui_ImplSDLGPU3_InitInfo initInfo{.Device = RDC_Device::GetHandle(),
                                            .ColorTargetFormat = RDC_Device::GetSwapchainTextureFormat(),
                                            .PresentMode = SDL_GPU_PRESENTMODE_VSYNC};
        ImGui_ImplSDL3_InitForSDLGPU(g_windowHandle);
        ImGui_ImplSDLGPU3_Init(&initInfo);

        Initialize();

        SDL_Event event{};
        while (true)
        {
            SDL_PollEvent(&event);
            if (event.type == SDL_EVENT_QUIT)
                break;
            IAEngine::__ProcessEvent(&event);
            IAEngine::__Update();
            ImGui_ImplSDL3_ProcessEvent(&event);

            Update();

            frameCounter++;
            if (frameCounter >= 60)
            {
                frameCounter = 0;
                IAEngine::__FixedUpdate();
            }

            IAEngine::__RenderToTexture(g_gamePreviewTexture->GetHandle());

            ImGui_ImplSDLGPU3_NewFrame();
            ImGui_ImplSDL3_NewFrame();
            ImGui::NewFrame();

            Draw();

            ImGui::Render();

            STATIC SDL_GPURenderPass *ActiveRenderPass{};
            STATIC SDL_GPUCommandBuffer *ActiveCommandBuffer{};
            STATIC SDL_GPUColorTargetInfo ActiveColorTargetInfo{.clear_color = SDL_FColor{0.0f, 0.0f, 0.0f, 1.0f},
                                                                .load_op = SDL_GPU_LOADOP_CLEAR,
                                                                .store_op = SDL_GPU_STOREOP_STORE};

            if (!(ActiveCommandBuffer = SDL_AcquireGPUCommandBuffer(RDC_Device::GetHandle())))
                THROW_UNKNOWN("Failed to acquire SDL GPU command buffer: ", SDL_GetError());

            g_imDrawData = ImGui::GetDrawData();
            ImGui_ImplSDLGPU3_PrepareDrawData(g_imDrawData, ActiveCommandBuffer);

            SDL_GPUTexture *swapChainTexture{};
            if (!SDL_WaitAndAcquireGPUSwapchainTexture(ActiveCommandBuffer, g_windowHandle, &swapChainTexture, nullptr,
                                                       nullptr))
                THROW_UNKNOWN("Failed to acquire SDL GPU Swapchain texture: ", SDL_GetError());

            ActiveColorTargetInfo.texture = swapChainTexture;
            ActiveColorTargetInfo.clear_color = SDL_FColor{0.3f, 0.3f, 0.3f, 1.0f};
            ActiveRenderPass = SDL_BeginGPURenderPass(ActiveCommandBuffer, &ActiveColorTargetInfo, 1, nullptr);
            ImGui_ImplSDLGPU3_RenderDrawData(g_imDrawData, ActiveCommandBuffer, ActiveRenderPass);

            SDL_EndGPURenderPass(ActiveRenderPass);

            SDL_SubmitGPUCommandBuffer(ActiveCommandBuffer);

            RDC_Device::WaitForIdle();
        }

        Terminate();

        ImGui_ImplSDL3_Shutdown();
        ImGui_ImplSDLGPU3_Shutdown();
        ImGui::DestroyContext();

        delete g_gamePreviewTexture;

        IAEngine::__Terminate();

        SDL_DestroyWindow(g_windowHandle);

        return 0;
    }
} // namespace ia::iae::editor