import taxiHighscoreService from '../services/taxiHighscoreService.js';

class TaxiHighscoreController {
  /**
   * Erstellt oder aktualisiert einen Highscore-Eintrag
   */
  async createHighscore(req, res) {
    try {
      const { userId, nickname, passengersDelivered, playtime, points, mapId, mapName } = req.body;

      // Validierung der erforderlichen Felder
      if (!userId || !nickname || passengersDelivered === undefined || playtime === undefined || points === undefined || !mapId || !mapName) {
        return res.status(400).json({
          success: false,
          message: 'Alle Felder sind erforderlich: userId, nickname, passengersDelivered, playtime, points, mapId, mapName'
        });
      }

      const highscoreData = {
        userId: parseInt(userId),
        nickname,
        passengersDelivered: parseInt(passengersDelivered),
        playtime: parseInt(playtime),
        points: parseInt(points),
        mapId: parseInt(mapId),
        mapName
      };

      const highscore = await taxiHighscoreService.createHighscore(highscoreData);

      res.status(200).json({
        success: true,
        data: highscore,
        message: 'Highscore erfolgreich gespeichert'
      });
    } catch (error) {
      console.error('Fehler beim Erstellen des Highscores:', error);
      res.status(500).json({
        success: false,
        message: 'Fehler beim Speichern des Highscores',
        error: error.message
      });
    }
  }

  /**
   * Holt die Top-Highscores
   */
  async getTopHighscores(req, res) {
    try {
      const { mapId, limit = 10, orderBy = 'points' } = req.query;

      const highscores = await taxiHighscoreService.getTopHighscores(
        mapId ? parseInt(mapId) : null,
        parseInt(limit),
        orderBy
      );

      res.status(200).json({
        success: true,
        data: highscores
      });
    } catch (error) {
      console.error('Fehler beim Laden der Top-Highscores:', error);
      res.status(500).json({
        success: false,
        message: 'Fehler beim Laden der Highscores',
        error: error.message
      });
    }
  }

  /**
   * Holt die persönlichen Bestleistungen eines Users
   */
  async getUserBestScores(req, res) {
    try {
      const { userId } = req.params;
      const { mapId } = req.query;

      if (!userId) {
        return res.status(400).json({
          success: false,
          message: 'userId ist erforderlich'
        });
      }

      const bestScores = await taxiHighscoreService.getUserBestScores(
        parseInt(userId),
        mapId ? parseInt(mapId) : null
      );

      res.status(200).json({
        success: true,
        data: bestScores
      });
    } catch (error) {
      console.error('Fehler beim Laden der User-Bestleistungen:', error);
      res.status(500).json({
        success: false,
        message: 'Fehler beim Laden der Bestleistungen',
        error: error.message
      });
    }
  }

  /**
   * Holt alle Highscores eines Users
   */
  async getUserHighscores(req, res) {
    try {
      const { userId } = req.params;
      const { limit = 20 } = req.query;

      if (!userId) {
        return res.status(400).json({
          success: false,
          message: 'userId ist erforderlich'
        });
      }

      const highscores = await taxiHighscoreService.getUserHighscores(
        parseInt(userId),
        parseInt(limit)
      );

      res.status(200).json({
        success: true,
        data: highscores
      });
    } catch (error) {
      console.error('Fehler beim Laden der User-Highscores:', error);
      res.status(500).json({
        success: false,
        message: 'Fehler beim Laden der User-Highscores',
        error: error.message
      });
    }
  }

  /**
   * Holt die Rangliste-Position eines Users
   */
  async getUserRank(req, res) {
    try {
      const { userId } = req.params;
      const { mapId, orderBy = 'points' } = req.query;

      if (!userId) {
        return res.status(400).json({
          success: false,
          message: 'userId ist erforderlich'
        });
      }

      const rank = await taxiHighscoreService.getUserRank(
        parseInt(userId),
        mapId ? parseInt(mapId) : null,
        orderBy
      );

      res.status(200).json({
        success: true,
        data: { rank }
      });
    } catch (error) {
      console.error('Fehler beim Berechnen der User-Rangliste:', error);
      res.status(500).json({
        success: false,
        message: 'Fehler beim Berechnen der Rangliste',
        error: error.message
      });
    }
  }

  /**
   * Holt Statistiken über die Highscores
   */
  async getHighscoreStats(req, res) {
    try {
      const stats = await taxiHighscoreService.getHighscoreStats();

      res.status(200).json({
        success: true,
        data: stats
      });
    } catch (error) {
      console.error('Fehler beim Laden der Highscore-Statistiken:', error);
      res.status(500).json({
        success: false,
        message: 'Fehler beim Laden der Statistiken',
        error: error.message
      });
    }
  }
}

export default new TaxiHighscoreController();