const database = require('../config/database');
const { Op } = require('sequelize');

/**
 * Service-Klasse für Krankheitseinträge
 * Enthält die gesamte Business-Logik für Sick
 */
class SickService {
  constructor() {
    this.defaultUserId = 1;
  }

  /**
   * Holt alle Krankheitseinträge für einen User
   * Zeigt dieses Jahr und die letzten 3 Monate
   * @param {number} userId - Benutzer-ID
   * @returns {Promise<Array>} Array von Krankheitseinträgen
   */
  async getAllSickEntries(userId) {
    const { Sick, SickType } = database.getModels();
    
    const now = new Date();
    const currentYear = now.getFullYear();
    
    // Berechne das Datum von vor 3 Monaten
    const threeMonthsAgo = new Date(now);
    threeMonthsAgo.setMonth(now.getMonth() - 3);
    
    // Nimm das frühere Datum (was weiter zurück liegt): Entweder Jahresanfang oder 3 Monate zurück
    const yearStart = new Date(currentYear, 0, 1); // 1. Januar dieses Jahres
    const startDate = yearStart < threeMonthsAgo ? yearStart : threeMonthsAgo;
    
    const startDateStr = `${startDate.getFullYear()}-${String(startDate.getMonth() + 1).padStart(2, '0')}-${String(startDate.getDate()).padStart(2, '0')}`;
    
    const sickEntries = await Sick.findAll({
      where: {
        user_id: userId,
        first_day: {
          [Op.gte]: startDateStr
        }
      },
      include: [
        {
          model: SickType,
          as: 'sickType',
          attributes: ['id', 'description']
        }
      ],
      order: [['first_day', 'DESC']],
      raw: true,
      nest: true
    });
    
    // Mapping: Englisch -> Deutsch
    const typeNames = {
      'self': 'Selbst',
      'child': 'Kinder',
      'parents': 'Eltern',
      'partner': 'Partner'
    };
    
    // Formatiere die Daten
    return sickEntries.map(sick => ({
      id: sick.id,
      startDate: sick.first_day,
      endDate: sick.last_day,
      sickTypeId: sick.sick_type_id,
      sickTypeName: typeNames[sick.sickType?.description] || sick.sickType?.description || 'Unbekannt'
    }));
  }

  /**
   * Holt alle verfügbaren Krankheitstypen
   * @returns {Promise<Array>} Array von Krankheitstypen
   */
  async getSickTypes() {
    const { SickType } = database.getModels();
    
    const types = await SickType.findAll({
      order: [['id', 'ASC']],
      raw: true
    });
    
    // Mapping: Englisch -> Deutsch
    const typeNames = {
      'self': 'Selbst',
      'child': 'Kinder',
      'parents': 'Eltern',
      'partner': 'Partner'
    };
    
    return types.map(type => ({
      id: type.id,
      name: typeNames[type.description] || type.description
    }));
  }

  /**
   * Erstellt einen neuen Krankheitseintrag
   * @param {number} userId - Benutzer-ID
   * @param {number} sickTypeId - Krankheitstyp-ID
   * @param {string} startDate - Startdatum (YYYY-MM-DD)
   * @param {string} endDate - Enddatum (YYYY-MM-DD)
   * @returns {Promise<Object>} Erstellter Krankheitseintrag
   */
  async createSickEntry(userId, sickTypeId, startDate, endDate) {
    const { Sick, SickType } = database.getModels();
    
    if (!endDate) {
      endDate = startDate; // Falls kein Enddatum: Single-Day
    }
    
    // Prüfe ob SickType existiert
    const sickType = await SickType.findByPk(sickTypeId);
    if (!sickType) {
      throw new Error('Ungültiger Krankheitstyp');
    }
    
    const sick = await Sick.create({
      user_id: userId,
      sick_type_id: sickTypeId,
      first_day: startDate,
      last_day: endDate,
      version: 0
    });
    
    // Mapping: Englisch -> Deutsch
    const typeNames = {
      'self': 'Selbst',
      'child': 'Kinder',
      'parents': 'Eltern',
      'partner': 'Partner'
    };
    
    return {
      id: sick.id,
      startDate: sick.first_day,
      endDate: sick.last_day,
      sickTypeId: sick.sick_type_id,
      sickTypeName: typeNames[sickType.description] || sickType.description
    };
  }

  /**
   * Löscht einen Krankheitseintrag
   * @param {number} userId - Benutzer-ID
   * @param {number} sickId - Sick-ID
   * @returns {Promise<void>}
   */
  async deleteSickEntry(userId, sickId) {
    const { Sick } = database.getModels();
    
    const sick = await Sick.findByPk(sickId);
    
    if (!sick) {
      throw new Error('Krankheitseintrag nicht gefunden');
    }
    
    // Prüfe Berechtigung
    if (sick.user_id !== userId) {
      throw new Error('Keine Berechtigung für diesen Eintrag');
    }
    
    await sick.destroy();
  }
}

module.exports = new SickService();

