#!/usr/bin/env node

/**
 * Démonstration du SDK Vault 4NK en action
 * Utilise l'API réelle pour récupérer et déchiffrer des fichiers
 */

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

async function demo() {
  console.log('🚀 Démonstration du SDK Vault 4NK');
  console.log('=' .repeat(50));
  console.log('📡 Connexion à l\'API: https://vault.4nkweb.com:6666');
  console.log('🔐 Chiffrement: ChaCha20-Poly1305 (quantique résistant)');
  console.log('');

  try {
    // 1. Création du client avec la clé de déchiffrement
    console.log('🔑 Initialisation du client...');
    const client = new VaultClient(
      {
        baseUrl: 'https://vault.4nkweb.com:6666',
        verifySsl: false, // Certificats auto-signés
        timeout: 15000,   // 15 secondes de timeout
      }
      // Plus de clé de déchiffrement nécessaire - clés dynamiques utilisées
    );

    // 2. Test de connectivité
    console.log('🌐 Test de connectivité...');
    const isConnected = await client.ping();
    if (!isConnected) {
      throw new Error('❌ Impossible de se connecter à l\'API Vault');
    }
    console.log('✅ Connecté à l\'API Vault');

    // 3. Informations sur l'API
    console.log('\n📋 Informations sur l\'API...');
    const info = await client.info();
    console.log(`   Nom: ${info.name}`);
    console.log(`   Version: ${info.version}`);
    console.log(`   Domaine: ${info.domain}:${info.port}`);
    console.log(`   Protocole: ${info.protocol}`);
    console.log(`   Chiffrement: ${info.encryption}`);

    // 4. État de santé
    console.log('\n🏥 État de santé...');
    const health = await client.health();
    console.log(`   Statut: ${health.status}`);
    console.log(`   Service: ${health.service}`);
    console.log(`   Algorithme: ${health.algorithm}`);

    // 5. Récupération et déchiffrement de fichiers
    console.log('\n📁 Récupération de fichiers chiffrés...');

    const filesToGet = [
      { env: 'dev', path: 'bitcoin/bitcoin.conf', description: 'Configuration Bitcoin' },
      { env: 'dev', path: 'tor/torrc', description: 'Configuration Tor' },
      { env: 'dev', path: 'sdk_relay/sdk_relay.conf', description: 'Configuration SDK Relay' }
    ];

    for (const fileInfo of filesToGet) {
      console.log(`\n   📄 ${fileInfo.description} (${fileInfo.path})`);

      try {
        const startTime = Date.now();
        const file = await client.getFile(fileInfo.env, fileInfo.path);
        const endTime = Date.now();

        console.log(`      ✅ Récupéré en ${endTime - startTime}ms`);
        console.log(`      📦 Taille: ${file.size} caractères`);
        console.log(`      🔐 Chiffré: ${file.encrypted ? 'Oui' : 'Non'}`);
        console.log(`      🔧 Algorithme: ${file.algorithm || 'N/A'}`);

        // 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) {
          const uniqueVars = [...new Set(envVars)];
          console.log(`      🔧 Variables env: ${uniqueVars.length} (${uniqueVars.slice(0, 3).join(', ')}...)`);
        }

        // Affichage d'un échantillon du contenu déchiffré
        const sample = file.content.substring(0, 150).replace(/\n/g, '\\n');
        console.log(`      📖 Échantillon: ${sample}...`);

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

    // 6. Test de récupération parallèle
    console.log('\n⚡ Test de récupération parallèle...');
    const parallelStartTime = 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' }
    ];

    try {
      const files = await client.getFiles(parallelRequests);
      const parallelEndTime = Date.now();

      console.log(`   ✅ ${files.length} fichiers récupérés en ${parallelEndTime - parallelStartTime}ms`);
      console.log(`   📊 Temps moyen: ${Math.round((parallelEndTime - parallelStartTime) / files.length)}ms par fichier`);

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

      // Statistiques
      const encryptedCount = files.filter(f => f.encrypted).length;
      console.log(`   🔐 Fichiers chiffrés: ${encryptedCount}/${files.length}`);

    } catch (error) {
      console.log(`   ❌ Erreur récupération parallèle: ${error instanceof Error ? error.message : error}`);
    }

    // 7. Test des utilitaires crypto
    console.log('\n🔐 Test des utilitaires de chiffrement...');

    // Génération d'une clé aléatoire
    const randomKey = VaultCrypto.generateKey();
    console.log(`   🔑 Clé générée: ${randomKey.substring(0, 10)}... (${randomKey.length} chars)`);
    console.log(`   ✅ Clé valide: ${VaultCrypto.validateKey(randomKey) ? 'Oui' : 'Non'}`);

    // Dérivation depuis un mot de passe
    const password = 'mon-mot-de-passe-secret-demo';
    const derivedKey = VaultCrypto.hashToKey(password);
    console.log(`   🔐 Mot de passe: ${password}`);
    console.log(`   🔑 Clé dérivée: ${derivedKey.substring(0, 10)}...`);
    console.log(`   ✅ Clé dérivée valide: ${VaultCrypto.validateKey(derivedKey) ? 'Oui' : 'Non'}`);

    // 8. Test de gestion d'erreurs
    console.log('\n🛡️  Test de gestion d\'erreurs...');

    // Fichier inexistant
    try {
      await client.getFile('dev', 'fichier-inexistant.conf');
      console.log('   ❌ Erreur: Devrait échouer');
    } catch (error) {
      console.log(`   ✅ Fichier inexistant: ${error instanceof Error ? error.message : error}`);
    }

    // Environnement inexistant
    try {
      await client.getFile('prod', 'bitcoin/bitcoin.conf');
      console.log('   ❌ Erreur: Devrait échouer');
    } catch (error) {
      console.log(`   ✅ Environnement inexistant: ${error instanceof Error ? error.message : error}`);
    }

    console.log('\n🎉 Démonstration terminée avec succès!');
    console.log('');
    console.log('📋 Résumé:');
    console.log('   ✅ API Vault opérationnelle');
    console.log('   ✅ Chiffrement quantique résistant fonctionnel');
    console.log('   ✅ Déchiffrement côté client réussi');
    console.log('   ✅ Variables d\'environnement traitées');
    console.log('   ✅ Récupération parallèle efficace');
    console.log('   ✅ Gestion d\'erreurs robuste');

  } catch (error) {
    console.error('\n❌ Erreur fatale:', error instanceof Error ? error.message : error);
    console.error('');
    console.error('🔍 Vérifications possibles:');
    console.error('   • L\'API Vault est-elle démarrée ?');
    console.error('   • Le port 6666 est-il accessible ?');
    console.error('   • Les certificats SSL sont-ils valides ?');
    console.error('   • La clé de déchiffrement est-elle correcte ?');
    process.exit(1);
  }
}

// Exécution de la démonstration
if (require.main === module) {
  demo().catch(error => {
    console.error('❌ Erreur inattendue:', error);
    process.exit(1);
  });
}

export { demo };