import Season from '../models/Season.js';
import { devLog } from '../utils/logger.js';

class SeasonService {
  /**
   * Ermittelt die aktuelle Saison basierend auf dem aktuellen Datum
   * @returns {string} Saison im Format "2023/2024"
   */
  static getCurrentSeasonString() {
    const now = new Date();
    const currentYear = now.getFullYear();
    const currentMonth = now.getMonth() + 1; // getMonth() ist 0-basiert
    
    // Ab 1. Juli: neue Saison beginnt
    if (currentMonth >= 7) {
      return `${currentYear}/${currentYear + 1}`;
    } else {
      return `${currentYear - 1}/${currentYear}`;
    }
  }

  /**
   * Holt oder erstellt die aktuelle Saison
   * @returns {Promise<Season>} Die aktuelle Saison
   */
  static async getOrCreateCurrentSeason() {
    try {
      const currentSeasonString = this.getCurrentSeasonString();
      
      // Versuche die aktuelle Saison zu finden
      let season = await Season.findOne({
        where: { season: currentSeasonString }
      });
      
      // Falls nicht vorhanden, erstelle sie
      if (!season) {
        season = await Season.create({
          season: currentSeasonString
        });
      }
      
      return season;
    } catch (error) {
      console.error('[SeasonService.getOrCreateCurrentSeason] - Error:', error);
      throw error;
    }
  }

  /**
   * Holt alle verfügbaren Saisons
   * @returns {Promise<Array<Season>>} Alle Saisons sortiert nach Name
   */
  static async getAllSeasons() {
    try {
      const seasons = await Season.findAll({
        order: [['season', 'DESC']] // Neueste zuerst
      });
      return seasons;
    } catch (error) {
      console.error('[SeasonService.getAllSeasons] - Error:', error);
      throw error;
    }
  }

  /**
   * Erstellt eine neue Saison
   * @param {string} seasonString - Saison im Format "2023/2024"
   * @returns {Promise<Season>} Die erstellte Saison
   */
  static async createSeason(seasonString) {
    try {
      
      // Prüfe ob Saison bereits existiert
      const existingSeason = await Season.findOne({
        where: { season: seasonString }
      });
      
      if (existingSeason) {
        throw new Error('Season already exists');
      }
      
      const season = await Season.create({
        season: seasonString
      });
      
      return season;
    } catch (error) {
      console.error('[SeasonService.createSeason] - Error:', error);
      throw error;
    }
  }

  /**
   * Holt eine Saison nach ID
   * @param {number} seasonId - Die Saison-ID
   * @returns {Promise<Season|null>} Die Saison oder null
   */
  static async getSeasonById(seasonId) {
    try {
      const season = await Season.findByPk(seasonId);
      return season;
    } catch (error) {
      console.error('[SeasonService.getSeasonById] - Error:', error);
      throw error;
    }
  }

  /**
   * Löscht eine Saison (nur wenn keine Teams/Ligen damit verknüpft sind)
   * @param {number} seasonId - Die Saison-ID
   * @returns {Promise<boolean>} True wenn gelöscht, false wenn nicht möglich
   */
  static async deleteSeason(seasonId) {
    try {
      
      // Prüfe ob Saison verwendet wird
      const season = await Season.findByPk(seasonId, {
        include: [
          { association: 'teams' },
          { association: 'leagues' }
        ]
      });
      
      if (!season) {
        return false;
      }
      
      // Prüfe ob Saison verwendet wird
      if (season.teams && season.teams.length > 0) {
        throw new Error('Season is used by teams');
      }
      
      if (season.leagues && season.leagues.length > 0) {
        throw new Error('Season is used by leagues');
      }
      
      await Season.destroy({
        where: { id: seasonId }
      });
      
      return true;
    } catch (error) {
      console.error('[SeasonService.deleteSeason] - Error:', error);
      throw error;
    }
  }
}

export default SeasonService;
