const authService = require('../services/AuthService');

/**
 * Authentication Controller
 * Verwaltet Auth-bezogene HTTP-Requests
 */
class AuthController {
  /**
   * Benutzer registrieren
   * POST /api/auth/register
   */
  async register(req, res) {
    try {
      const { email, password, full_name } = req.body;

      const result = await authService.register({
        email,
        password,
        full_name
      });

      res.status(201).json({
        success: true,
        message: 'Registrierung erfolgreich',
        user: result.user
      });
    } catch (error) {
      console.error('Registrierungsfehler:', error);
      
      res.status(400).json({
        success: false,
        error: error.message
      });
    }
  }

  /**
   * Benutzer einloggen
   * POST /api/auth/login
   */
  async login(req, res) {
    try {
      const { email, password, action } = req.body;

      if (!email || !password) {
        return res.status(400).json({
          success: false,
          error: 'E-Mail und Passwort sind erforderlich'
        });
      }

      const result = await authService.login(email, password, action);

      const response = {
        success: true,
        message: 'Login erfolgreich',
        token: result.token,
        user: result.user
      };

      // Füge Warnung hinzu, falls vorhanden
      if (result.actionWarning) {
        response.actionWarning = result.actionWarning;
      }

      res.json(response);
    } catch (error) {
      console.error('Login-Fehler:', error);
      
      res.status(401).json({
        success: false,
        error: error.message
      });
    }
  }

  /**
   * Ausloggen
   * POST /api/auth/logout
   */
  async logout(req, res) {
    try {
      const token = req.headers.authorization?.replace('Bearer ', '');

      if (token) {
        await authService.logout(token);
      }

      res.json({
        success: true,
        message: 'Logout erfolgreich'
      });
    } catch (error) {
      console.error('Logout-Fehler:', error);
      
      res.status(500).json({
        success: false,
        error: 'Fehler beim Logout'
      });
    }
  }

  /**
   * Aktuellen Benutzer abrufen
   * GET /api/auth/me
   */
  async getCurrentUser(req, res) {
    try {
      const userId = req.user.userId;

      const profile = await authService.getUserProfile(userId);

      res.json({
        success: true,
        user: profile
      });
    } catch (error) {
      console.error('Fehler beim Abrufen des Benutzers:', error);
      
      res.status(500).json({
        success: false,
        error: 'Fehler beim Abrufen der Benutzerdaten'
      });
    }
  }

  /**
   * Passwort-Reset anfordern
   * POST /api/auth/request-reset
   */
  async requestPasswordReset(req, res) {
    try {
      const { email } = req.body;

      if (!email) {
        return res.status(400).json({
          success: false,
          error: 'E-Mail ist erforderlich'
        });
      }

      const resetToken = await authService.requestPasswordReset(email);

      // Debug-Logs
      console.log('Reset-Token:', resetToken);
      console.log('NODE_ENV:', process.env.NODE_ENV);
      console.log('isDevelopment:', !process.env.NODE_ENV || process.env.NODE_ENV === 'development');

      // In Produktion: E-Mail mit Reset-Link senden
      // Für Entwicklung: Token zurückgeben (auch wenn E-Mail nicht existiert)
      const isDevelopment = !process.env.NODE_ENV || process.env.NODE_ENV === 'development';
      
      if (isDevelopment) {
        // Im Development-Modus immer einen Token zurückgeben für Testing
        const devToken = resetToken || 'dev-test-token-' + Date.now() + '-' + email;
        res.json({
          success: true,
          message: 'Reset-Link wurde gesendet (DEV)',
          resetToken: devToken // NUR FÜR ENTWICKLUNG!
        });
      } else {
        res.json({
          success: true,
          message: 'Falls ein Account mit dieser E-Mail existiert, wurde ein Reset-Link gesendet'
        });
      }
    } catch (error) {
      console.error('Fehler bei Passwort-Reset-Anfrage:', error);
      
      res.status(500).json({
        success: false,
        error: 'Fehler beim Senden des Reset-Links'
      });
    }
  }

  /**
   * Passwort zurücksetzen
   * POST /api/auth/reset-password
   */
  async resetPassword(req, res) {
    try {
      const { token, password } = req.body;

      if (!token || !password) {
        return res.status(400).json({
          success: false,
          error: 'Token und neues Passwort sind erforderlich'
        });
      }

      await authService.resetPassword(token, password);

      res.json({
        success: true,
        message: 'Passwort wurde erfolgreich zurückgesetzt'
      });
    } catch (error) {
      console.error('Fehler beim Passwort-Reset:', error);
      
      res.status(400).json({
        success: false,
        error: error.message
      });
    }
  }

  /**
   * Passwort ändern (eingeloggter Benutzer)
   * POST /api/auth/change-password
   */
  async changePassword(req, res) {
    try {
      const userId = req.user.userId;
      const { oldPassword, newPassword } = req.body;

      if (!oldPassword || !newPassword) {
        return res.status(400).json({
          success: false,
          error: 'Altes und neues Passwort sind erforderlich'
        });
      }

      await authService.changePassword(userId, oldPassword, newPassword);

      res.json({
        success: true,
        message: 'Passwort wurde erfolgreich geändert'
      });
    } catch (error) {
      console.error('Fehler beim Passwort-Ändern:', error);
      
      res.status(400).json({
        success: false,
        error: error.message
      });
    }
  }

  /**
   * Token validieren
   * GET /api/auth/validate
   */
  async validateToken(req, res) {
    try {
      // Wenn Middleware durchgelaufen ist, ist Token valid
      res.json({
        success: true,
        valid: true,
        user: req.user
      });
    } catch (error) {
      res.status(401).json({
        success: false,
        valid: false,
        error: 'Ungültiger Token'
      });
    }
  }

  /**
   * Eigenen Account und personenbezogene Daten löschen
   * DELETE /api/auth/account
   */
  async deleteAccount(req, res) {
    try {
      const userId = req.user.userId;
      const { confirmation } = req.body;

      await authService.deleteAccount(userId, confirmation);

      res.json({
        success: true,
        message: 'Account wurde gelöscht'
      });
    } catch (error) {
      console.error('Fehler beim Löschen des Accounts:', error);

      res.status(400).json({
        success: false,
        error: error.message
      });
    }
  }
}

module.exports = new AuthController();