#!/usr/bin/env python3
"""
Test Frontend Propriétés VWB - Validation de l'affichage dans l'interface
Auteur : Dom, Alice, Kiro - 10 janvier 2026

Ce script démarre le frontend avec le composant de test et valide
l'affichage des propriétés d'étapes VWB.
"""

import os
import sys
import json
import time
import requests
import subprocess
import webbrowser
from pathlib import Path
from typing import Dict, List, Any, Optional

# Configuration
VWB_BACKEND_URL = "http://localhost:5004"
VWB_FRONTEND_URL = "http://localhost:3000"
TEST_COMPONENT_URL = f"{VWB_FRONTEND_URL}/test-properties"

class VWBFrontendTesteur:
    """Testeur pour l'interface frontend VWB"""
    
    def __init__(self):
        self.backend_url = VWB_BACKEND_URL
        self.frontend_url = VWB_FRONTEND_URL
        self.backend_process = None
        self.frontend_process = None
    
    def verifier_backend(self) -> bool:
        """Vérifier que le backend est disponible"""
        print("🔍 Vérification du backend...")
        
        try:
            response = requests.get(f"{self.backend_url}/health", timeout=5)
            if response.status_code == 200:
                health_data = response.json()
                actions_count = health_data.get('services', {}).get('actions', 0)
                print(f"✅ Backend disponible - {actions_count} actions")
                return True
            else:
                print(f"❌ Backend répond avec code {response.status_code}")
                return False
        except Exception as e:
            print(f"❌ Backend non accessible: {e}")
            return False
    
    def demarrer_backend(self) -> bool:
        """Démarrer le backend si nécessaire"""
        if self.verifier_backend():
            return True
        
        print("🚀 Démarrage du backend VWB...")
        
        try:
            # Changer vers le répertoire VWB
            vwb_dir = Path("visual_workflow_builder")
            if not vwb_dir.exists():
                print("❌ Répertoire visual_workflow_builder non trouvé")
                return False
            
            # Démarrer le backend
            backend_script = vwb_dir / "backend" / "app_catalogue_simple.py"
            if not backend_script.exists():
                print("❌ Script backend non trouvé")
                return False
            
            # Commande pour démarrer le backend
            cmd = [
                sys.executable, "-m", "backend.app_catalogue_simple"
            ]
            
            print(f"Commande: {' '.join(cmd)}")
            print(f"Répertoire: {vwb_dir.absolute()}")
            
            # Démarrer en arrière-plan
            self.backend_process = subprocess.Popen(
                cmd,
                cwd=vwb_dir,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True
            )
            
            # Attendre que le backend démarre
            print("⏳ Attente du démarrage du backend...")
            for i in range(30):  # 30 secondes max
                time.sleep(1)
                if self.verifier_backend():
                    print("✅ Backend démarré avec succès")
                    return True
                print(f"   Tentative {i+1}/30...")
            
            print("❌ Timeout démarrage backend")
            return False
            
        except Exception as e:
            print(f"❌ Erreur démarrage backend: {e}")
            return False
    
    def modifier_app_pour_test(self) -> bool:
        """Modifier App.tsx pour inclure le composant de test"""
        print("🔧 Modification de App.tsx pour inclure le test...")
        
        app_file = Path("visual_workflow_builder/frontend/src/App.tsx")
        if not app_file.exists():
            print("❌ Fichier App.tsx non trouvé")
            return False
        
        try:
            # Lire le contenu actuel
            with open(app_file, 'r', encoding='utf-8') as f:
                content = f.read()
            
            # Vérifier si le test est déjà ajouté
            if 'TestPropertiesPanel' in content:
                print("✅ Composant de test déjà intégré")
                return True
            
            # Ajouter l'import du composant de test
            import_line = "import TestPropertiesPanel from './components/TestPropertiesPanel';"
            
            # Trouver la ligne d'import React
            lines = content.split('\n')
            import_index = -1
            for i, line in enumerate(lines):
                if line.startswith('import React') or line.startswith('import {'):
                    import_index = i
                    break
            
            if import_index >= 0:
                lines.insert(import_index + 1, import_line)
            else:
                lines.insert(0, import_line)
            
            # Ajouter la route de test
            route_addition = '''
          {/* Route de test pour les propriétés VWB */}
          <Route path="/test-properties" element={<TestPropertiesPanel />} />'''
            
            # Trouver où insérer la route
            route_inserted = False
            for i, line in enumerate(lines):
                if '<Routes>' in line and not route_inserted:
                    lines.insert(i + 1, route_addition)
                    route_inserted = True
                    break
            
            # Sauvegarder le fichier modifié
            modified_content = '\n'.join(lines)
            with open(app_file, 'w', encoding='utf-8') as f:
                f.write(modified_content)
            
            print("✅ App.tsx modifié avec succès")
            return True
            
        except Exception as e:
            print(f"❌ Erreur modification App.tsx: {e}")
            return False
    
    def demarrer_frontend(self) -> bool:
        """Démarrer le frontend"""
        print("🚀 Démarrage du frontend VWB...")
        
        try:
            frontend_dir = Path("visual_workflow_builder/frontend")
            if not frontend_dir.exists():
                print("❌ Répertoire frontend non trouvé")
                return False
            
            # Vérifier que node_modules existe
            node_modules = frontend_dir / "node_modules"
            if not node_modules.exists():
                print("⏳ Installation des dépendances npm...")
                subprocess.run(["npm", "install"], cwd=frontend_dir, check=True)
            
            # Démarrer le serveur de développement
            print("⏳ Démarrage du serveur de développement...")
            
            env = os.environ.copy()
            env['BROWSER'] = 'none'  # Empêcher l'ouverture automatique du navigateur
            
            self.frontend_process = subprocess.Popen(
                ["npm", "start"],
                cwd=frontend_dir,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True,
                env=env
            )
            
            # Attendre que le frontend démarre
            print("⏳ Attente du démarrage du frontend...")
            for i in range(60):  # 60 secondes max
                time.sleep(1)
                try:
                    response = requests.get(self.frontend_url, timeout=2)
                    if response.status_code == 200:
                        print("✅ Frontend démarré avec succès")
                        return True
                except:
                    pass
                print(f"   Tentative {i+1}/60...")
            
            print("❌ Timeout démarrage frontend")
            return False
            
        except Exception as e:
            print(f"❌ Erreur démarrage frontend: {e}")
            return False
    
    def ouvrir_page_test(self):
        """Ouvrir la page de test dans le navigateur"""
        print("🌐 Ouverture de la page de test...")
        
        test_url = f"{self.frontend_url}/test-properties"
        
        try:
            webbrowser.open(test_url)
            print(f"✅ Page de test ouverte: {test_url}")
        except Exception as e:
            print(f"⚠️ Impossible d'ouvrir automatiquement le navigateur: {e}")
            print(f"   Ouvrez manuellement: {test_url}")
    
    def afficher_instructions(self):
        """Afficher les instructions pour l'utilisateur"""
        print("\n" + "="*60)
        print("🎯 INSTRUCTIONS POUR TESTER LES PROPRIÉTÉS VWB")
        print("="*60)
        
        print(f"\n1. 🌐 OUVRIR LA PAGE DE TEST")
        print(f"   URL: {self.frontend_url}/test-properties")
        print(f"   La page devrait s'ouvrir automatiquement dans votre navigateur")
        
        print(f"\n2. 🧪 EXÉCUTER LES TESTS")
        print(f"   - Cliquez sur 'Exécuter les Tests'")
        print(f"   - Vérifiez que tous les tests sont verts ✅")
        print(f"   - Si des tests échouent ❌, vérifiez la console du navigateur")
        
        print(f"\n3. 👀 VÉRIFIER L'AFFICHAGE")
        print(f"   - L'aperçu du Properties Panel doit s'afficher")
        print(f"   - Les propriétés de l'action VWB doivent être visibles")
        print(f"   - Les paramètres requis et optionnels doivent être listés")
        
        print(f"\n4. 🎨 TESTER L'INTERACTION")
        print(f"   - Changez l'action à tester avec les boutons")
        print(f"   - Vérifiez que les propriétés changent selon l'action")
        print(f"   - Testez la sélection d'ancres visuelles")
        
        print(f"\n5. 🔧 DÉBOGUER SI NÉCESSAIRE")
        print(f"   - Ouvrez les outils de développement (F12)")
        print(f"   - Vérifiez la console pour les erreurs")
        print(f"   - Vérifiez l'onglet Network pour les requêtes API")
        
        print(f"\n📊 URLS IMPORTANTES:")
        print(f"   - Backend API: {self.backend_url}")
        print(f"   - Frontend: {self.frontend_url}")
        print(f"   - Page de test: {self.frontend_url}/test-properties")
        print(f"   - API Catalogue: {self.backend_url}/api/vwb/catalog/actions")
        
        print(f"\n⏹️  ARRÊTER LES SERVICES:")
        print(f"   - Appuyez sur Ctrl+C dans ce terminal")
        print(f"   - Ou fermez cette fenêtre de terminal")
        
        print("\n" + "="*60)
    
    def nettoyer(self):
        """Nettoyer les processus"""
        print("\n🧹 Nettoyage des processus...")
        
        if self.frontend_process:
            try:
                self.frontend_process.terminate()
                self.frontend_process.wait(timeout=5)
                print("✅ Frontend arrêté")
            except:
                try:
                    self.frontend_process.kill()
                    print("✅ Frontend forcé à s'arrêter")
                except:
                    print("⚠️ Impossible d'arrêter le frontend")
        
        if self.backend_process:
            try:
                self.backend_process.terminate()
                self.backend_process.wait(timeout=5)
                print("✅ Backend arrêté")
            except:
                try:
                    self.backend_process.kill()
                    print("✅ Backend forcé à s'arrêter")
                except:
                    print("⚠️ Impossible d'arrêter le backend")
    
    def executer_test_complet(self):
        """Exécuter le test complet"""
        print("🚀 TEST FRONTEND PROPRIÉTÉS VWB")
        print("=" * 50)
        
        try:
            # Étape 1: Vérifier/démarrer le backend
            if not self.demarrer_backend():
                print("❌ Impossible de démarrer le backend")
                return False
            
            # Étape 2: Modifier App.tsx pour inclure le test
            if not self.modifier_app_pour_test():
                print("❌ Impossible de modifier App.tsx")
                return False
            
            # Étape 3: Démarrer le frontend
            if not self.demarrer_frontend():
                print("❌ Impossible de démarrer le frontend")
                return False
            
            # Étape 4: Ouvrir la page de test
            self.ouvrir_page_test()
            
            # Étape 5: Afficher les instructions
            self.afficher_instructions()
            
            # Étape 6: Attendre l'arrêt manuel
            try:
                print("\n⏳ Services en cours d'exécution... Appuyez sur Ctrl+C pour arrêter")
                while True:
                    time.sleep(1)
            except KeyboardInterrupt:
                print("\n🛑 Arrêt demandé par l'utilisateur")
            
            return True
            
        except Exception as e:
            print(f"❌ Erreur: {e}")
            return False
        finally:
            self.nettoyer()

def main():
    """Fonction principale"""
    print("Test Frontend Propriétés VWB - 10 janvier 2026")
    print("Auteur : Dom, Alice, Kiro")
    print()
    
    # Vérifier qu'on est dans le bon répertoire
    if not os.path.exists('visual_workflow_builder'):
        print("❌ Erreur: Exécuter depuis la racine du projet RPA Vision V3")
        sys.exit(1)
    
    # Créer et exécuter le testeur
    testeur = VWBFrontendTesteur()
    succes = testeur.executer_test_complet()
    
    sys.exit(0 if succes else 1)

if __name__ == "__main__":
    main()