#include <app/application.h>
#include <context/context.h>
#include <event/events.h>
#include <module/module_registry.h>
#include <platform/input_module.h>
#include <platform/window_module.h>
#include <utils/logger.h>

#include <SDL.h>

namespace extra2d {

std::unique_ptr<Application> Application::create() {
  return std::unique_ptr<Application>(new Application());
}

Application::Application() = default;

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

Application::Application(Application &&) noexcept = default;
Application &Application::operator=(Application &&) noexcept = default;

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

  config_ = config;

  // 创建引擎上下文
  context_ = Context::create();
  if (!context_) {
    E2D_LOG_ERROR("Failed to create context");
    return false;
  }

  // 初始化引擎
  if (!context_->init()) {
    E2D_LOG_ERROR("Failed to initialize context");
    return false;
  }

  // 自动创建所有已注册的模块
  initModules();

  // 通过事件总线发送配置给所有监听模块
  events::OnModuleConfig<AppConfig>::emit(config);

  initialized_ = true;
  running_ = true;

  events::OnInit::emit();

  E2D_LOG_INFO("Application initialized successfully");
  E2D_LOG_INFO("Window: {}x{}, Fullscreen: {}, VSync: {}", config.width,
               config.height, config.fullscreen, config.vsync);
  return true;
}

void Application::initModules() {
  // 从注册表自动创建所有模块
  modules_ = ModuleRegistry::instance().createModules();

  // 初始化所有模块
  for (auto &module : modules_) {
    if (!module->init()) {
      E2D_LOG_ERROR("Failed to initialize module: {}", module->getName());
    } else {
      E2D_LOG_INFO("Module initialized: {} (priority: {})", module->getName(),
                   module->getPriority());
    }
  }
}

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

  events::OnShutdown::emit();

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

  // 按相反顺序销毁模块
  for (auto it = modules_.rbegin(); it != modules_.rend(); ++it) {
    (*it)->shutdown();
  }
  modules_.clear();

  // 关闭上下文
  context_.reset();

  initialized_ = false;
  running_ = false;

  E2D_LOG_INFO("Application shutdown complete");
}

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

  // 使用 SDL 的高精度计时器
  Uint64 perfFreq = SDL_GetPerformanceFrequency();
  Uint64 lastPerfCounter = SDL_GetPerformanceCounter();

  WindowModule *window = getWindow();
  InputModule *input = getInput();

  while (running_) {
    // 处理窗口事件
    if (window) {
      if (!window->pollEvents()) {
        quit();
        break;
      }
    }

    // 计算 deltaTime
    Uint64 currentPerfCounter = SDL_GetPerformanceCounter();
    deltaTime_ =
        static_cast<float>(currentPerfCounter - lastPerfCounter) / perfFreq;
    lastPerfCounter = currentPerfCounter;

    totalTime_ += deltaTime_;

    // 更新
    if (!paused_) {
      update();
    }

    // 交换缓冲区
    if (window) {
      window->swapBuffers();
    }

    // FPS 限制 - 使用 SDL_Delay
    if (!config_.vsync && config_.fpsLimit > 0) {
      Uint64 frameEndCounter = SDL_GetPerformanceCounter();
      float frameTime =
          static_cast<float>(frameEndCounter - currentPerfCounter) / perfFreq;
      float targetTime = 1.0f / config_.fpsLimit;
      if (frameTime < targetTime) {
        SDL_Delay(static_cast<Uint32>((targetTime - frameTime) * 1000));
      }
    }
  }
}

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

void Application::pause() {
  if (!paused_) {
    paused_ = true;
    events::OnPause::emit();
    E2D_LOG_INFO("Application paused");
  }
}

void Application::resume() {
  if (paused_) {
    paused_ = false;
    events::OnResume::emit();
    E2D_LOG_INFO("Application resumed");
  }
}

void Application::update() {
  // 更新所有模块
  for (auto &module : modules_) {
    module->update(deltaTime_);
  }

  // 通过上下文更新引擎
  if (context_) {
    context_->tick(deltaTime_);
  }
}

WindowModule *Application::getWindow() const {
  return getModule<WindowModule>();
}

InputModule *Application::getInput() const { return getModule<InputModule>(); }

int32 Application::getWindowWidth() const {
  if (WindowModule *window = getWindow()) {
    Size size = window->getSize();
    return static_cast<int32>(size.w);
  }
  return config_.width;
}

int32 Application::getWindowHeight() const {
  if (WindowModule *window = getWindow()) {
    Size size = window->getSize();
    return static_cast<int32>(size.h);
  }
  return config_.height;
}

const char *Application::getWindowTitle() const {
  return config_.title.c_str();
}

} // namespace extra2d