/**
 * Exemple d'utilisation avancée du SDK Vault 4NK
 * Démontre les fonctionnalités avancées et la gestion d'erreurs
 */

import { VaultClient, VaultCrypto, VaultApiError, VaultDecryptionError } from '../src/index';

async function advancedExample() {
  console.log('🚀 Exemple d\'utilisation avancée du SDK Vault 4NK');
  console.log('=' .repeat(60));

  try {
    // 1. Génération d'une clé de chiffrement personnalisée
    console.log('🔑 Génération d\'une clé de chiffrement...');
    const customKey = VaultCrypto.generateKey();
    console.log(`   Clé générée: ${customKey.substring(0, 10)}...`);

    // Validation de la clé
    const isValid = VaultCrypto.validateKey(customKey);
    console.log(`   Clé valide: ${isValid ? 'Oui' : 'Non'}`);

    // 2. Création du client avec configuration personnalisée
    console.log('\n⚙️  Configuration du client...');
    const client = new VaultClient(
      {
        baseUrl: 'https://vault.4nkweb.com:6666',
        verifySsl: false, // Désactivé pour les certificats auto-signés
        timeout: 10000,   // Timeout de 10 secondes
      },
      // Plus de clé de déchiffrement nécessaire - clés dynamiques utilisées
    );

    // 3. Gestion d'erreurs avancée
    console.log('\n🛡️  Test de gestion d\'erreurs...');

    // Test avec un fichier inexistant
    try {
      await client.getFile('dev', 'fichier-inexistant.conf');
    } catch (error) {
      if (error instanceof VaultApiError) {
        console.log(`   ✅ Erreur API capturée: ${error.message} (${error.statusCode})`);
      } else {
        console.log(`   ❌ Erreur inattendue: ${error}`);
      }
    }

    // Test avec un environnement inexistant
    try {
      await client.getFile('prod', 'bitcoin/bitcoin.conf');
    } catch (error) {
      if (error instanceof VaultApiError) {
        console.log(`   ✅ Erreur environnement: ${error.message} (${error.statusCode})`);
      }
    }

    // 4. Récupération de fichiers avec analyse de contenu
    console.log('\n📊 Analyse de contenu des fichiers...');

    const filePaths = [
      'bitcoin/bitcoin.conf',
      'tor/torrc',
      'sdk_relay/sdk_relay.conf'
    ];

    for (const filePath of filePaths) {
      try {
        const file = await client.getFile('dev', filePath);

        console.log(`\n   📄 ${file.filename}:`);
        console.log(`      Taille: ${file.size} caractères`);
        console.log(`      Chiffré: ${file.encrypted ? 'Oui' : 'Non'}`);

        // Analyse du contenu
        const lines = file.content.split('\n');
        const configLines = lines.filter(line =>
          line.trim() && !line.trim().startsWith('#')
        );

        console.log(`      Lignes totales: ${lines.length}`);
        console.log(`      Lignes de config: ${configLines.length}`);

        // Recherche de variables d'environnement
        const envVars = file.content.match(/\$\{[^}]+\}/g) || [];
        if (envVars.length > 0) {
          console.log(`      Variables env: ${envVars.length} (${envVars.slice(0, 3).join(', ')}...)`);
        }

      } catch (error) {
        console.log(`   ❌ Erreur pour ${filePath}: ${error instanceof Error ? error.message : error}`);
      }
    }

    // 5. Test de performance avec récupération parallèle
    console.log('\n⚡ Test de performance...');
    const startTime = Date.now();

    const parallelRequests = [
      { env: 'dev', filePath: 'bitcoin/bitcoin.conf' },
      { env: 'dev', filePath: 'tor/torrc' },
      { env: 'dev', filePath: 'sdk_relay/sdk_relay.conf' },
      { env: 'dev', filePath: 'supervisor/supervisord.conf' }
    ];

    const files = await client.getFiles(parallelRequests);
    const endTime = Date.now();

    console.log(`   Fichiers récupérés: ${files.length}`);
    console.log(`   Temps total: ${endTime - startTime}ms`);
    console.log(`   Temps moyen par fichier: ${Math.round((endTime - startTime) / files.length)}ms`);

    const totalSize = files.reduce((sum, file) => sum + file.size, 0);
    console.log(`   Taille totale: ${totalSize} caractères`);

    // 6. Monitoring et métriques
    console.log('\n📈 Monitoring et métriques...');

    // Test de connectivité répété
    const pingTests = 5;
    const pingResults: boolean[] = [];

    for (let i = 0; i < pingTests; i++) {
      const isConnected = await client.ping();
      pingResults.push(isConnected);
      await new Promise(resolve => setTimeout(resolve, 100)); // Délai de 100ms
    }

    const successRate = (pingResults.filter(r => r).length / pingTests) * 100;
    console.log(`   Tests de connectivité: ${pingTests}`);
    console.log(`   Taux de succès: ${successRate}%`);

    // 7. Utilisation de clés dérivées
    console.log('\n🔐 Test de clés dérivées...');
    const password = 'mon-mot-de-passe-secret';
    const derivedKey = VaultCrypto.hashToKey(password);
    console.log(`   Mot de passe: ${password}`);
    console.log(`   Clé dérivée: ${derivedKey.substring(0, 10)}...`);
    console.log(`   Clé valide: ${VaultCrypto.validateKey(derivedKey) ? 'Oui' : 'Non'}`);

    console.log('\n🎉 Exemple avancé terminé avec succès!');

  } catch (error) {
    console.error('❌ Erreur fatale:', error instanceof Error ? error.message : error);

    if (error instanceof VaultApiError) {
      console.error(`   Code d'erreur: ${error.statusCode}`);
      console.error(`   Endpoint: ${error.endpoint}`);
    } else if (error instanceof VaultDecryptionError) {
      console.error('   Type: Erreur de déchiffrement');
    }

    process.exit(1);
  }
}

// Fonction utilitaire pour les tests de performance
async function performanceTest(client: VaultClient, iterations: number = 10) {
  console.log(`\n🏃 Test de performance (${iterations} itérations)...`);

  const times: number[] = [];

  for (let i = 0; i < iterations; i++) {
    const start = Date.now();
    await client.getFile('dev', 'bitcoin/bitcoin.conf');
    const end = Date.now();
    times.push(end - start);
  }

  const avgTime = times.reduce((sum, time) => sum + time, 0) / times.length;
  const minTime = Math.min(...times);
  const maxTime = Math.max(...times);

  console.log(`   Temps moyen: ${Math.round(avgTime)}ms`);
  console.log(`   Temps min: ${minTime}ms`);
  console.log(`   Temps max: ${maxTime}ms`);

  return { avgTime, minTime, maxTime };
}

// Exécution de l'exemple
if (require.main === module) {
  advancedExample();
}

export { advancedExample, performanceTest };