#include <app/application.h>
#include <core/director.h>
#include <utils/logger.h>

#include <chrono>
#include <thread>

#ifdef __SWITCH__
#include <switch.h>
#endif

namespace extra2d {

static double getTimeSeconds() {
#ifdef __SWITCH__
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return static_cast<double>(ts.tv_sec) + static_cast<double>(ts.tv_nsec) / 1000000000.0;
#else
    using namespace std::chrono;
    auto now = steady_clock::now();
    auto duration = now.time_since_epoch();
    return duration_cast<std::chrono::duration<double>>(duration).count();
#endif
}

Application& Application::instance() {
    static Application instance;
    return instance;
}

Application::~Application() {
    shutdown();
}

bool Application::init(const AppConfig& config) {
    if (initialized_) {
        E2D_LOG_WARN("Application already initialized");
        return true;
    }

    config_ = config;

    PlatformType platform = config_.platform;
    if (platform == PlatformType::Auto) {
#ifdef __SWITCH__
        platform = PlatformType::Switch;
#else
        platform = PlatformType::PC;
#endif
    }

    if (platform == PlatformType::Switch) {
#ifdef __SWITCH__
        Result rc;
        rc = romfsInit();
        if (R_SUCCEEDED(rc)) {
            E2D_LOG_INFO("RomFS initialized successfully");
        } else {
            E2D_LOG_WARN("romfsInit failed: {:#08X}", rc);
        }

        rc = socketInitializeDefault();
        if (R_FAILED(rc)) {
            E2D_LOG_WARN("socketInitializeDefault failed");
        }
#endif
    }

    if (!DIRECTOR.init()) {
        E2D_LOG_ERROR("Failed to initialize Director");
        return false;
    }

    initialized_ = true;
    running_ = true;

    E2D_LOG_INFO("Application initialized successfully");
    return true;
}

void Application::shutdown() {
    if (!initialized_) return;

    E2D_LOG_INFO("Shutting down application...");

    DIRECTOR.shutdown();

    PlatformType platform = config_.platform;
    if (platform == PlatformType::Auto) {
#ifdef __SWITCH__
        platform = PlatformType::Switch;
#else
        platform = PlatformType::PC;
#endif
    }

    if (platform == PlatformType::Switch) {
#ifdef __SWITCH__
        romfsExit();
        socketExit();
#endif
    }

    initialized_ = false;
    running_ = false;

    E2D_LOG_INFO("Application shutdown complete");
}

void Application::run() {
    if (!initialized_) {
        E2D_LOG_ERROR("Application not initialized");
        return;
    }

    lastFrameTime_ = getTimeSeconds();

    while (running_) {
        mainLoop();
    }
}

void Application::quit() {
    shouldQuit_ = true;
    running_ = false;
}

void Application::pause() {
    if (!paused_) {
        paused_ = true;
        DIRECTOR.pause();
        E2D_LOG_INFO("Application paused");
    }
}

void Application::resume() {
    if (paused_) {
        paused_ = false;
        DIRECTOR.resume();
        lastFrameTime_ = getTimeSeconds();
        E2D_LOG_INFO("Application resumed");
    }
}

void Application::mainLoop() {
    double currentTime = getTimeSeconds();
    deltaTime_ = static_cast<float>(currentTime - lastFrameTime_);
    lastFrameTime_ = currentTime;

    totalTime_ += deltaTime_;

    frameCount_++;
    fpsTimer_ += deltaTime_;
    if (fpsTimer_ >= 1.0f) {
        currentFps_ = frameCount_;
        frameCount_ = 0;
        fpsTimer_ -= 1.0f;
    }

    if (!paused_) {
        update();
    }

    if (!config_.vsync && config_.fpsLimit > 0) {
        double frameEndTime = getTimeSeconds();
        double frameTime = frameEndTime - currentTime;
        double target = 1.0 / static_cast<double>(config_.fpsLimit);
        if (frameTime < target) {
            std::this_thread::sleep_for(std::chrono::duration<double>(target - frameTime));
        }
    }
}

void Application::update() {
    DIRECTOR.mainLoop(deltaTime_);
}

} // namespace extra2d