// 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>

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

    EXTERN Vec2 g_designViewport;
    EXTERN SDL_Window *g_windowHandle;

    INT32 Run(IN INT32 argc, IN PCCHAR argv[])
    {
        INT32 frameCounter{0};
        IVec2 windowExtent{800, 600};
        g_designViewport = windowExtent;

        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", windowExtent.x, 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, &windowExtent.x, &windowExtent.y);

        IAEngine::__Initialize();

        auto gamePreviewTexture = new RDC_Texture(RDC_Texture::EType::SAMPLED, 800, 600);

        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);

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

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

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

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

            {
                ImGui::Begin("Scene");
                ImGui::Image(gamePreviewTexture->GetHandle(), {800, 600});
                ImGui::End();
            }

            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();
        }

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

        delete gamePreviewTexture;

        IAEngine::__Terminate();

        SDL_DestroyWindow(g_windowHandle);

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

int main(int argc, char *argv[])
{
    return ia::iae::Run(argc, (const char **) argv);
}

#include <IAEngine/LibInterface.hpp>

C_DECL(GameRequestedConfig *Game_GetConfigRequest())
{
    return nullptr;
}

C_DECL(VOID Game_OnInitialize())
{
}

C_DECL(VOID Game_OnTerminate())
{
}

C_DECL(VOID Game_OnDebugDraw())
{
    RDC::DrawRect({10, 10}, {700, 500}, {1.0f, 0.0f, 0.0f, 1.0f});
}

C_DECL(VOID Game_OnFixedUpdate())
{
}

C_DECL(VOID Game_OnUpdate(IN FLOAT32 deltaTime))
{
}

C_DECL(VOID Game_OnResize(IN INT32 newWidth, IN INT32 newHeight))
{
}