// escena_joc.cpp - Implementació de la lògica del joc
// © 1999 Visente i Sergi (versió Pascal)
// © 2025 Port a C++20 amb SDL3

#include "escena_joc.hpp"
#include "../../core/system/gestor_escenes.hpp"
#include "../../core/system/global_events.hpp"
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>

EscenaJoc::EscenaJoc(SDLManager& sdl)
    : sdl_(sdl), nau_(sdl.obte_renderer()), itocado_(0), text_(sdl.obte_renderer()) {
  // Inicialitzar bales amb renderer
  for (auto &bala : bales_) {
    bala = Bala(sdl.obte_renderer());
  }

  // Inicialitzar enemics amb renderer
  for (auto &enemy : orni_) {
    enemy = Enemic(sdl.obte_renderer());
  }
}

void EscenaJoc::executar() {
  std::cout << "Escena Joc: Inicialitzant...\n";

  // Inicialitzar estat del joc
  inicialitzar();

  SDL_Event event;
  Uint64 last_time = SDL_GetTicks();

  while (GestorEscenes::actual == GestorEscenes::Escena::JOC) {
    // Calcular delta_time real
    Uint64 current_time = SDL_GetTicks();
    float delta_time = (current_time - last_time) / 1000.0f;
    last_time = current_time;

    // Limitar delta_time per evitar grans salts
    if (delta_time > 0.05f) {
      delta_time = 0.05f;
    }

    // Processar events SDL
    while (SDL_PollEvent(&event)) {
      // Manejo de finestra
      if (sdl_.handleWindowEvent(event)) {
        continue;
      }

      // Events globals (F1/F2/F3/ESC/QUIT)
      if (GlobalEvents::handle(event, sdl_)) {
        continue;
      }

      // Processament específic del joc (SPACE per disparar)
      processar_input(event);
    }

    // Actualitzar física del joc amb delta_time real
    actualitzar(delta_time);

    // Actualitzar colors oscil·lats
    sdl_.updateColors(delta_time);

    // Netejar pantalla (usa color oscil·lat)
    sdl_.neteja(0, 0, 0);

    // Dibuixar joc
    dibuixar();

    // Presentar renderer (swap buffers)
    sdl_.presenta();
  }

  std::cout << "Escena Joc: Finalitzant...\n";
}

void EscenaJoc::inicialitzar() {
  // Inicialitzar generador de números aleatoris
  // Basat en el codi Pascal original: line 376
  std::srand(static_cast<unsigned>(std::time(nullptr)));

  // Inicialitzar estat de col·lisió
  itocado_ = 0;

  // Inicialitzar nau
  nau_.inicialitzar();

  // Inicialitzar enemics (ORNIs)
  for (auto &enemy : orni_) {
    enemy.inicialitzar();
  }

  // Inicialitzar bales
  for (auto &bala : bales_) {
    bala.inicialitzar();
  }
}

void EscenaJoc::actualitzar(float delta_time) {
  // Actualitzar nau (input + física)
  nau_.processar_input(delta_time);
  nau_.actualitzar(delta_time);

  // Actualitzar moviment i rotació dels enemics (ORNIs)
  for (auto &enemy : orni_) {
    enemy.actualitzar(delta_time);
  }

  // Actualitzar moviment de bales (Fase 9)
  for (auto &bala : bales_) {
    bala.actualitzar(delta_time);
  }
}

void EscenaJoc::dibuixar() {
  // Dibuixar nau
  nau_.dibuixar();

  // Dibuixar ORNIs (enemics)
  for (const auto &enemy : orni_) {
    enemy.dibuixar();
  }

  // Dibuixar bales (Fase 9)
  for (const auto &bala : bales_) {
    bala.dibuixar();
  }

  // [PRUEBA] Text vectorial
  text_.render("0123456789", {10, 10}, 1.5f);
  text_.render("SCORE: 1234", {10, 40}, 1.0f);
  text_.render("10:45", {10, 70}, 2.0f);
  text_.render("LEVEL-3", {10, 110}, 1.5f);

  // TODO: Dibuixar marges (Fase 11)
}

void EscenaJoc::processar_input(const SDL_Event &event) {
  // Processament d'input per events puntuals (no continus)
  // L'input continu (fletxes) es processa en actualitzar() amb
  // SDL_GetKeyboardState()

  if (event.type == SDL_EVENT_KEY_DOWN) {
    switch (event.key.key) {
    case SDLK_SPACE:
      // Disparar (Fase 9)
      // Basat en el codi Pascal original: crear bala en posició de la nau
      // El joc original només permetia 1 bala activa alhora

      // Buscar primera bala inactiva
      for (auto &bala : bales_) {
        if (!bala.esta_activa()) {
          bala.disparar(nau_.get_centre(), nau_.get_angle());
          break;
        }
      }
      break;

    default:
      break;
    }
  }
}

void EscenaJoc::tocado() {
  // TODO: Implementar seqüència de mort
}