<?php

/**
 * Script de migration pour la table users
 * Transfert les données de la base source (geosector) vers la base cible (geosector_app)
 * Gère le chiffrement des données sensibles
 */

require_once dirname(__DIR__) . '/config.php';
require_once __DIR__ . '/MigrationConfig.php';
require_once dirname(dirname(__DIR__)) . '/src/Services/ApiService.php';

try {
    // Création du tunnel SSH si nécessaire
    createSshTunnel();

    // Connexion aux bases de données
    $sourceDb = getSourceConnection();
    $targetDb = getTargetConnection();

    // Récupération des utilisateurs depuis la base source
    $stmt = $sourceDb->query("SELECT * FROM users");
    $users = $stmt->fetchAll(PDO::FETCH_ASSOC);

    echo "Nombre d'utilisateurs à migrer: " . count($users) . PHP_EOL;

    // Préparation de la requête d'insertion
    $insertQuery = "INSERT INTO users (
                        id, 
                        fk_entite, 
                        fk_role, 
                        fk_titre, 
                        encrypted_name, 
                        first_name, 
                        sect_name, 
                        encrypted_user_name, 
                        user_pass_hash, 
                        encrypted_phone, 
                        encrypted_mobile, 
                        encrypted_email, 
                        chk_alert_email, 
                        chk_suivi, 
                        date_naissance, 
                        date_embauche, 
                        fk_user_creat, 
                        fk_user_modif, 
                        chk_active
                    ) VALUES (
                        :id, 
                        :fk_entite, 
                        :fk_role, 
                        :fk_titre, 
                        :encrypted_name, 
                        :first_name, 
                        :sect_name, 
                        :encrypted_user_name, 
                        :user_pass_hash, 
                        :encrypted_phone, 
                        :encrypted_mobile, 
                        :encrypted_email, 
                        :chk_alert_email, 
                        :chk_suivi, 
                        :date_naissance, 
                        :date_embauche, 
                        :fk_user_creat, 
                        :fk_user_modif, 
                        :chk_active
                    ) ON DUPLICATE KEY UPDATE 
                        fk_entite = VALUES(fk_entite),
                        fk_role = VALUES(fk_role),
                        fk_titre = VALUES(fk_titre),
                        encrypted_name = VALUES(encrypted_name),
                        first_name = VALUES(first_name),
                        sect_name = VALUES(sect_name),
                        encrypted_user_name = VALUES(encrypted_user_name),
                        user_pass_hash = VALUES(user_pass_hash),
                        encrypted_phone = VALUES(encrypted_phone),
                        encrypted_mobile = VALUES(encrypted_mobile),
                        encrypted_email = VALUES(encrypted_email),
                        chk_alert_email = VALUES(chk_alert_email),
                        chk_suivi = VALUES(chk_suivi),
                        date_naissance = VALUES(date_naissance),
                        date_embauche = VALUES(date_embauche),
                        fk_user_modif = VALUES(fk_user_modif),
                        chk_active = VALUES(chk_active)";

    $insertStmt = $targetDb->prepare($insertQuery);
    
    // Préparation de la requête pour vérifier si un utilisateur existe
    $checkQuery = "SELECT COUNT(*) FROM users WHERE id = ?";
    $checkStmt = $targetDb->prepare($checkQuery);
    
    // Préparation de la requête pour la mise à jour
    $updateQuery = "UPDATE users SET 
                    fk_entite = :fk_entite,
                    fk_role = :fk_role,
                    fk_titre = :fk_titre,
                    encrypted_name = :encrypted_name,
                    first_name = :first_name,
                    sect_name = :sect_name,
                    encrypted_user_name = :encrypted_user_name,
                    user_pass_hash = :user_pass_hash,
                    encrypted_phone = :encrypted_phone,
                    encrypted_mobile = :encrypted_mobile,
                    encrypted_email = :encrypted_email,
                    chk_alert_email = :chk_alert_email,
                    chk_suivi = :chk_suivi,
                    date_naissance = :date_naissance,
                    date_embauche = :date_embauche,
                    fk_user_modif = :fk_user_modif,
                    chk_active = :chk_active
                WHERE id = :id";
    $updateStmt = $targetDb->prepare($updateQuery);

    // Compteurs
    $successCount = 0;
    $errorCount = 0;

    // Compteur pour les 100 premiers utilisateurs
    $counter = 0;
    $maxTestUsers = 100;
    
    // Traitement de chaque utilisateur
    foreach ($users as $user) {
        try {
            // Mappage des champs
            $id = isset($user['rowid']) ? $user['rowid'] : $user['id'];
            $chkActive = isset($user['active']) ? $user['active'] : (isset($user['chk_active']) ? $user['chk_active'] : 1);

            // Test de déchiffrement pour les 100 premiers utilisateurs
            if ($counter < $maxTestUsers) {
                $counter++;
                
                // Test pour l'email
                $email = $user['email'] ?? '';
                $encryptedEmail = !empty($email) ? ApiService::encryptSearchableData($email) : '';
                $decryptedEmail = !empty($encryptedEmail) ? ApiService::decryptSearchableData($encryptedEmail) : '';
                
                // Test pour le nom d'utilisateur
                $username = $user['username'] ?? '';
                $encryptedUsername = !empty($username) ? ApiService::encryptSearchableData($username) : '';
                $decryptedUsername = !empty($encryptedUsername) ? ApiService::decryptSearchableData($encryptedUsername) : '';
                
                // Afficher les résultats pour tous les utilisateurs testés
                echo "===== TEST UTILISATEUR ID $id =====\n";
                
                // Toujours afficher les informations d'email
                echo "Email original: $email\n";
                echo "Email chiffré: $encryptedEmail\n";
                echo "Email déchiffré: $decryptedEmail\n";
                
                // Toujours afficher les informations de nom d'utilisateur
                echo "Username original: $username\n";
                echo "Username chiffré: $encryptedUsername\n";
                echo "Username déchiffré: $decryptedUsername\n";
                
                echo "=================================================\n";
            }

            // Gestion du rôle utilisateur
            $fkRole = isset($user['fk_role']) ? $user['fk_role'] : 1;
            // Forcer fk_role=1 pour les utilisateurs avec fk_role=0
            if ($fkRole == 0) {
                $fkRole = 1;
            }

            // Gestion du titre utilisateur
            $fkTitre = isset($user['fk_titre']) ? $user['fk_titre'] : 1;
            // Forcer fk_titre=1 si différent de 1 ou 2
            if ($fkTitre != 1 && $fkTitre != 2) {
                $fkTitre = 1;
            }

            // Chiffrement des données sensibles (uniquement si non vides)
            $libelle = $user['libelle'] ?? '';
            $encryptedName = !empty($libelle) ? ApiService::encryptData($libelle) : '';

            // Traitement du prénom
            $prenom = $user['prenom'] ?? '';

            // Traitement du nom de tournée (sect_name)
            $sectName = $user['nom_tournee'] ?? '';

            // Traitement du nom d'utilisateur
            $username = $user['username'] ?? '';
            // Utiliser encryptSearchableData car le nom d'utilisateur est utilisé comme clé de recherche
            $encryptedUserName = !empty($username) ? ApiService::encryptSearchableData($username) : '';

            // Traitement du mot de passe
            // Utiliser userpswd s'il existe, sinon userpass
            $userPassHash = $user['userpswd'] ?? ($user['userpass'] ?? '');

            // Traitement des numéros de téléphone
            $telephone = $user['telephone'] ?? '';
            $mobile = $user['mobile'] ?? '';

            $encryptedPhone = !empty($telephone) ? ApiService::encryptData($telephone) : '';
            $encryptedMobile = !empty($mobile) ? ApiService::encryptData($mobile) : '';

            // Chiffrement de l'email
            $email = $user['email'] ?? '';
            $encryptedEmail = !empty($email) ? ApiService::encryptSearchableData($email) : '';

            // Préparation des données pour l'insertion
            $userData = [
                'id' => $id,
                'fk_entite' => $user['fk_entite'] ?? 1,
                'fk_role' => $fkRole,
                'fk_titre' => $fkTitre,
                'encrypted_name' => $encryptedName,
                'first_name' => $prenom,
                'sect_name' => $sectName,
                'encrypted_user_name' => $encryptedUserName,
                'user_pass_hash' => $userPassHash,
                'encrypted_phone' => $encryptedPhone,
                'encrypted_mobile' => $encryptedMobile,
                'encrypted_email' => $encryptedEmail,
                'chk_alert_email' => $user['alert_email'] ?? 1,
                'chk_suivi' => $user['chk_suivi'] ?? 0,
                'date_naissance' => $user['date_naissance'] ?? null,
                'date_embauche' => $user['date_embauche'] ?? null,
                'fk_user_creat' => $user['fk_user_creat'] ?? null,
                'fk_user_modif' => $user['fk_user_modif'] ?? null,
                'chk_active' => $chkActive
            ];

            // Vérifier si l'utilisateur existe déjà
            $checkStmt->execute([$id]);
            $exists = $checkStmt->fetchColumn() > 0;

            if ($exists) {
                
                // Mise à jour de l'utilisateur existant - utiliser insertStmt avec ON DUPLICATE KEY UPDATE
                $insertStmt->execute($userData);
                $successCount++;
            } else {
                // L'utilisateur n'existe pas, on ne peut pas le mettre à jour
                $errorCount++;
            }
        } catch (Exception $e) {
            $errorCount++;
            echo "Erreur lors de la migration de l'utilisateur ID {$id}: " . $e->getMessage() . PHP_EOL;
        }
    }

    echo "Migration terminée. Succès: $successCount, Erreurs: $errorCount" . PHP_EOL;

    // Fermer le tunnel SSH
    closeSshTunnel();
} catch (Exception $e) {
    echo "Erreur critique: " . $e->getMessage() . PHP_EOL;

    // Fermer le tunnel SSH en cas d'erreur
    closeSshTunnel();

    exit(1);
}
