#include "Resources.h"
#include "App.h"
#include <iostream>
#include <sys/resource.h>
#include "Tools/Tool.h" 
#include "Version.h"


App::App(int argc, char* argv[]) {
    // PARAMS
    for (int i = 0; i < argc; i++) {
        std::printf("%s ", argv[i]);
    }
    std::cout << "\n";
    std::printf("%s ver.%d.%d.%d (%s)\n", APP_NAME, APP_VERSION_MAJOR, APP_VERSION_MINOR, APP_VERSION_PATCH, APP_VERSION_LEVEL);
    execName = argv[0];
    std::string projectPath = "untitled.grdn";
    for (int i = 0; i < argc; i++) {
        if (strcmp(argv[i], "--test") == 0) {
            testMode = true;
            std::printf("Running in test/automated mode\n");
        }
        if (strcmp(argv[i], "--memcheck") == 0) {
            memCheck = true;
        }
        if (strcmp(argv[i], "--help") == 0) {
            std::printf("Usage: %s [options] [project]\n", argv[0]);
            std::printf("Options:\n");
            std::printf("  --test                Run in test/automated mode\n");
            std::printf("  --memcheck            Enable memory quota check\n");
            std::printf("  --help                Show this help message\n");
            std::printf("Environment variables:\n");
            std::printf("  GRADIEN_GPU_DEBUG     Enable GPU validation layers (1 = true, 0 = false)\n");
            std::printf("  GRADIEN_FRAMETIME     Show frametime (1 = true, 0 = false)\n");
            std::exit(0);
        }
    }
    bootTime = SDL_GetTicksNS();
    // SDL INIT
    if (!SDL_Init(SDL_INIT_VIDEO)) {
        std::printf("SDL Initialization failed\n");
        std::exit(1);
    }

    // Hints
    SDL_SetHintWithPriority(SDL_HINT_PEN_TOUCH_EVENTS, "0", SDL_HINT_OVERRIDE);

    Resources::Init();

    window = SDL_CreateWindow("Gradien", 800, 600, SDL_WINDOW_RESIZABLE | SDL_WINDOW_VULKAN);

    if (!window) {
        std::printf("Window creation failed: %s\n", SDL_GetError());
        SDL_Quit();
        std::exit(1);
    }

    if (!GPU::Init()) {
        const char* err = SDL_GetError();
        std::printf("Graphics device creation failed: %s\n", err ? err : "Unknown Error");
        std::string errorMessagegGPU = "Failed to start the app because the graphics device is not usable, Details: " + 
        (std::string)(err ? err : "Result from SDL_GetError() unavailable") +
        " Device information: " + GPU::GetDetails() +
        " The Application will now close.";
        SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Error", errorMessagegGPU.c_str(), window);
        SDL_Quit();
        std::exit(1);
    }

    if (!GPU::ClaimWindow(window)) {
        std::printf("Window claim failed: %s\n", SDL_GetError());
        SDL_Quit();
        std::exit(1);
    }


    // INPUT
    input = new InputHandler();

    // IMGUI
    imGuiApp = new DearImGuiApp(window);

    History = new HistoryManager();
    AppLayer::SetHistory(History);
    Tool::SetHistory(History);

    
    initLayers();
    initPanels();
}

void App::activateLayers(std::vector<std::shared_ptr<AppLayer>> layers) {
    for (auto& layer : layers) {
        layer->OnActivate();
    }
}

void App::deactivateLayers(std::vector<std::shared_ptr<AppLayer>> layers) {
    for (auto& layer : layers) {
        layer->OnDeactivate();
    }
}

bool App::areAllLayersActive(std::vector<std::shared_ptr<AppLayer>> layers) {
    for (auto& layer : layers) {
        if (!layer->IsActive()) {
            return false;
        }
    }
    return true;
}

#include "AppLayers/CanvasLayer.h"
#include "AppLayers/ToolbarLayer.h"
#include "AppLayers/NotifyLayer.h"
#include "AppLayers/ProjectsLayer.h"
#include <unistd.h>


void App::initLayers() {
    auto canvasLayer = std::make_shared<CanvasAppLayer>();
    auto toolbarLayer = std::make_shared<ToolbarAppLayer>();
    auto notifyLayer = std::make_shared<NotifyAppLayer>();
    auto projectsLayer = std::make_shared<ProjectsAppLayer>();

    layers.push_back(notifyLayer);
    layers.push_back(canvasLayer);
    layers.push_back(toolbarLayer);
    layers.push_back(projectsLayer);

    projectsLayers.push_back(projectsLayer);
    editorLayers.push_back(canvasLayer);
    editorLayers.push_back(toolbarLayer);

    activateLayers(projectsLayers);

    Tool::SetColor(0.0f, 0.0f, 0.0f);

    input->RegisterOnDown(canvasLayer);
    notifyLayer->SetMessage("Welcome to Gradien!");

}

void App::initPanels()
{
    panelContext = new PanelManagementContext();
}

App::~App() {
    delete imGuiApp;
    GPU::Shutdown();
    SDL_DestroyWindow(window);
    SDL_Quit();
}



void App::Run() {

    bootTime = SDL_GetTicksNS() - bootTime;
    std::printf("Init in %lu ns (%.3f s)\n", bootTime, (double)(bootTime) / 1.0E9);
    int counter = 0;

    const char* frametimeEnv = std::getenv("GRADIEN_FRAMETIME");
    bool frametime = (frametimeEnv != nullptr && std::string(frametimeEnv) == "1");
    long lastTicks = frametime ? SDL_GetTicksNS() : 0;

    bool running = true;
    SDL_Event event;

    while (running) {
        // switch layers (ts lowk sucks, TODO: figure out a better way to handle screens, we'll need this eventually)
        if (CurrentArtwork && areAllLayersActive(projectsLayers)) {
            History->Clear();
            deactivateLayers(projectsLayers);
            activateLayers(editorLayers);
        } else if (!CurrentArtwork && areAllLayersActive(editorLayers)) {
            History->Clear();
            deactivateLayers(editorLayers);
            activateLayers(projectsLayers);
            PanelManagementContext::CloseAll();
        }

        // Parse SDL Events
        while (SDL_PollEvent(&event)) {
            if (imGuiApp->ProcessEvent(event)) {
                SDL_SetHintWithPriority(SDL_HINT_PEN_MOUSE_EVENTS, "1", SDL_HINT_OVERRIDE);
                continue;
            }
            else {
                SDL_SetHintWithPriority(SDL_HINT_PEN_MOUSE_EVENTS, "0", SDL_HINT_OVERRIDE); // TODO: UI V2
            }
            if (input->OnSDLEvent(event)) {
                continue;
            }
            switch (event.type) {
            case SDL_EVENT_QUIT:
                running = false;
                break;
            default:
                break;
            }
        }
        counter++;

        SDL_GetWindowSizeInPixels(GPU::GetWindow(), &Width, &Height);

        imGuiApp->StartFrame();


        if (!GPU::WaitAquireSwapchainWithCommandBuffer()) {
            std::printf("Swapchain aquire failed: %s\n", SDL_GetError());
            SDL_Quit();
            std::exit(1);
        }

        if (input->IsKeyHeld(SDLK_LCTRL)) {
            if (input->IsKeyDown(SDLK_Z)) {
                History->Undo();
            }
            if (input->IsKeyDown(SDLK_Y)) {
                History->Redo();
            }
            if (input->IsKeyDown(SDLK_S)) {
                CurrentArtwork->SaveProject();
                NotifyAppLayer::SetMessage("Saved!");
            }
        }

        SDL_GPUColorTargetInfo color_target_info;
        SDL_zero(color_target_info);
        color_target_info.texture = GPU::GetSwapchain();
        color_target_info.clear_color.r = 0.75f;
        color_target_info.clear_color.g = 0.75f;
        color_target_info.clear_color.b = 0.75f;
        color_target_info.clear_color.a = 1.0f;
        color_target_info.load_op = SDL_GPU_LOADOP_CLEAR;
        color_target_info.store_op = SDL_GPU_STOREOP_STORE;

        GPU::BeginRendering({ &color_target_info }, nullptr);

        GPU::EndRendering();


        for (auto& layer : layers) {
            if (layer->IsActive()) {
                layer->OnRender();
            }
        }

        if (PanelManagementContext::GetMode() == PanelManagementMode::DEFAULT && Tool::GetActive()) {
            Tool::GetActive()->OnGuiRender();
        }

        panelContext->OnRender();

        if (memCheck) {
            const int limitMB = 300; // mb
            long pages = 0;
            FILE* f = fopen("/proc/self/statm", "r");
            if (f) {
                long dummy;
                fscanf(f, "%ld %ld", &dummy, &pages); // field 2 = resident pages
                fclose(f);
            }
            long int kbytes = pages * sysconf(_SC_PAGESIZE) / 1024;

            ImGui::Begin("Memory usage", (bool*)NULL, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_AlwaysAutoResize);
            ImGui::Text("Memory usage: %ld kB (%ld MB)", kbytes, kbytes / 1024);
            ImGui::ProgressBar((float)kbytes / (limitMB * 1024), ImVec2(0.0f, 0.0f));
            ImGui::End();

            if (!(counter % 36)) { // every approx quarter second
                std::printf("Memory usage: %ld kB (%ld MB)\n", kbytes, kbytes / 1024);
                if (kbytes >= (limitMB * 1024)) {
                    SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "High memory usage", "Memory usage is higher than expected and may indicate memory leaks are still present, check logs and refactor until this no longer occurs.", nullptr);
                    running = false;
                }
            }
        }

        #ifdef __ANDROID__
        #ifndef NDEBUG
        static long ticks = 0;
        ticks = SDL_GetTicksNS() - ticks;
        ImGui::SetNextWindowPos(ImVec2(0, 128)); // statusbar still shows current despite fullscreen mode, offsetting into definitily readable territory
        ImGui::Begin("##FPSCounter", (bool*)NULL, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoMove);
        ImGui::Text("FPS: %f", 1000000000.0 / (double)ticks);
        ImGui::End();
        ticks = SDL_GetTicksNS();
        #endif
        #endif

        imGuiApp->Render();

        GPU::SubmitCommandsPopCommandBuffer();

        if (testMode && counter > 144 * 3) { // give approx 3 seconds for input
            running = false;
        }

        if (lastTicks != 0) {
            // calculate frame time
            long currentTicks = SDL_GetTicksNS();
            long deltaTicks = currentTicks - lastTicks;
            lastTicks = currentTicks;
            double deltaTime = (double)deltaTicks / 1.0E9;
            std::printf("Frame time: %.3f ms\n", deltaTime * 1000.0);
        }
    }

    // exit
    if (CurrentArtwork) {
        CurrentArtwork->SaveProject();
    }
}

int App::Width = 800;
int App::Height = 600;
HistoryManager* App::History = nullptr;
Artwork* App::CurrentArtwork = nullptr;