let moment = require('moment');

module.exports = {
  friendlyName: 'Login',
  description: 'Standard user login',

  inputs: {
    username: {
      type: 'string',
      required: true
    },
    password: {
      type: 'string',
      required: true
    },
    // Paramètres FCM optionnels
    fcmToken: {
      type: 'string',
      allowNull: true
    },
    deviceId: {
      type: 'string',
      allowNull: true
    },
    platform: {
      type: 'string',
      isIn: ['android', 'ios'],
      allowNull: true
    },
    appVersion: {
      type: 'string',
      allowNull: true
    },
    lang: {
      type: 'string',
      allowNull: true
    }
  },

  exits: {
    success: {
    },
    invalidInput: {

      description: 'Invalid input data'
    },
    userNotFound: {

      description: 'User not found or invalid credentials'
    },
    serverError: {

      description: 'Server error occurred'
    }
  },

  fn: async function ({ username, password, fcmToken, deviceId, platform, appVersion, lang }, exits) {
    console.log("login mobile", username, password, fcmToken, deviceId, platform, appVersion, lang);
    const ouestDate = moment.utc(new Date()).utcOffset('+01:00');
    const date = ouestDate.format('YYYY-MM-DD');
    const heure = ouestDate.format('HH:mm:ss');
    try {
      // 1. Validation des entrées
      if (!username || !password) {
        await ActivityLogs.create({
          date,
          heure,
          username,
          action: "CONNEXION_MOBILE",
          status: "failed",
          errorMessage: "Nom d'utilisateur et mot de passe requis",
          device: "Mobile"
        });
        return exits.invalidInput({
          success: false,
          message: 'Nom d\'utilisateur et mot de passe requis',
          code: 'MISSING_FIELDS'
        });
      }
      console.log("login mobil 2")
      // 2. Chiffrement du mot de passe
      let encryptedPassword;
      try {
        encryptedPassword = await new Promise((resolve, reject) => {
          sails.config.cryptoUtils.encrypt(password, (err, result) => {
            if (err) reject(err);
            else resolve(result);
          });
        });
      } catch (encryptError) {
        console.log("login mobil 2.1", encryptError);
        await ActivityLogs.create({
          date,
          heure,
          username,
          action: "CONNEXION_MOBILE",
          status: "failed",
          errorMessage: "Erreur de chiffrement",
          device: "Mobile"
        });
        return exits.serverError({
          success: false,
          message: 'Erreur de chiffrement',
          code: 'ENCRYPTION_ERROR'
        });
      }
      console.log("login mobil 3")

      // 3. Recherche de l'utilisateur avec gestion de migration automatique
      let user = await Utilisateurs.findOne({
        login: username.toLowerCase().trim(),
        password: encryptedPassword,
        desactiverCompte: false
      });

      // Si l'utilisateur n'est pas trouvé, essayer avec l'ancien format DES
      if (!user) {
        try {
          // Essayer de déchiffrer avec l'ancien algorithme DES
          const oldEncryptedPassword = await new Promise((resolve, reject) => {
            // Utiliser l'ancienne configuration DES
            const oldCryptoConfig = {
              password: 'EsupportL@chef@2020',
              iterations: 20,
              salt: Buffer.from('de331012de331012', 'hex'),

              KDF: function (password, salt, iterations) {
                var pwd = Buffer.from(password, 'utf-8');
                var key = Buffer.concat([pwd, salt]);
                var i;
                for (i = 0; i < iterations; i += 1) {
                  key = require('crypto').createHash("md5").update(key).digest();
                }
                return key;
              },

              getKeyIV: function (password, salt, iterations) {
                var key = this.KDF(password, salt, iterations);
                var keybuf = Buffer.from(key, 'binary').slice(0, 8);
                var ivbuf = Buffer.from(key, 'binary').slice(8, 16);
                return [keybuf, ivbuf];
              },

              encrypt: function (payload) {
                var kiv = this.getKeyIV(this.password, this.salt, this.iterations);
                var cipher = require('crypto').createCipheriv('des', kiv[0], kiv[1]);
                var encrypted = [];
                encrypted.push(cipher.update(payload, 'utf-8', 'hex'));
                encrypted.push(cipher.final('hex'));
                return Buffer.from(encrypted.join(''), 'hex').toString('base64');
              }
            };

            resolve(oldCryptoConfig.encrypt(password));
          });

          // Rechercher avec l'ancien format
          user = await Utilisateurs.findOne({
            login: username.toLowerCase().trim(),
            password: oldEncryptedPassword,
            desactiverCompte: false
          });

          // Si trouvé, migrer automatiquement vers AES
          if (user) {
            console.log(`🔄 Migration automatique du mot de passe pour ${user.login}`);

            // Mettre à jour le mot de passe avec le nouveau format AES
            await Utilisateurs.updateOne({ id: user.id })
              .set({ password: encryptedPassword });

            console.log(`✅ Mot de passe migré avec succès pour ${user.login}`);
          }
        } catch (migrationError) {
          console.log(`⚠️  Erreur lors de la migration automatique:`, migrationError.message);
          // Continuer sans migration automatique
        }
      }

      if (!user) {
        await ActivityLogs.create({
          date,
          heure,
          username,
          action: "CONNEXION_MOBILE",
          status: "failed",
          errorMessage: "Identifiants incorrects",
          device: "Mobile"
        });
        return exits.userNotFound({
          success: false,
          message: 'mot de passe incorrects',
          code: 'INVALID_CREDENTIALS'
        });
      }

      // 4. Génération du token JWT
      const token = await sails.helpers.jwt.sign.with({ payload: user });
      if (!token) {
        await ActivityLogs.create({
          date,
          heure,
          username,
          action: "CONNEXION_MOBILE",
          status: "failed",
          errorMessage: "Token non généré",
          device: "Mobile"
        });
        throw new Error('Token generation failed');
      }

      // 5. Enregistrement du token
      await Token.create({
        token_salt: token,
        owner: user.id
      });

      // 6. Récupération des infos école
      const ecole = await Ecoles.findOne({ codeEcole: user.codeEcole });
      console.log("login mobil 4", fcmToken, deviceId, platform);
      // 7. Enregistrement du token FCM (si fourni)
      if (fcmToken && deviceId && platform) {
        try {
          // Utiliser le helper upsert-fcm-token
          await sails.helpers.upsertFcmToken.with({
            codeUser: user.codeUser,
            deviceId: deviceId,
            platform: platform,
            fcmToken: fcmToken,
            codeEcole: user.codeEcole,
            appVersion: appVersion || '1.0.0',
            lang: lang || 'fr'
          });

          sails.log.info(`FCM token registered for user ${user.codeUser} on ${platform}`);
        } catch (fcmError) {
          sails.log.warn(`Failed to register FCM token for user ${user.codeUser}:`, fcmError.message);
          // On ne fait pas échouer la connexion si FCM échoue
        }
      }

      // 8. Journalisation (succès)
      await ActivityLogs.create({
        date,
        heure,
        username: user.login,
        action: "CONNEXION_MOBILE",
        status: "success",
        errorMessage: null,
        device: "Mobile"
      });

      // 9. Préparation de la réponse
      const response = {
        success: true,
        message: 'Connexion réussie',
        token: token,
        user: {
          id: user.id,
          login: user.login,
          email: user.email,
          //firstName: user.prenom,
          lastName: user.nom,
          isUpdate: user.isUpdate,
          typeUser: user.typeUser
        },
        school: ecole ? {
          id: ecole.id,
          name: ecole.nom,
          code: ecole.codeEcole
        } : null
      };
      console.log('TEST 8 code', response)

      return exits.success(response);

    } catch (error) {
      sails.log.error('Login error:', error);
      await ActivityLogs.create({
        date,
        heure,
        username,
        action: "CONNEXION_MOBILE",
        status: "failed",
        errorMessage: (error && error.message) || 'Erreur inconnue',
        device: "Mobile"
      });
      return exits.serverError({
        success: false,
        message: 'Une erreur est survenue',
        code: 'SERVER_ERROR',
        details: error.message
      });
    }
  }
};