#!/usr/bin/env python3
"""
Test Simple de la Palette VWB
Auteur : Dom, Alice, Kiro - 10 janvier 2026

Ce script teste les composants de base pour diagnostiquer pourquoi 
les actions du catalogue ne s'affichent pas dans la palette.
"""

import requests
import json
import time
from datetime import datetime

def test_frontend_backend_communication():
    """Tester la communication entre frontend et backend"""
    print("🔗 Test de communication Frontend ↔ Backend...")
    
    # Test 1: Backend accessible
    try:
        backend_response = requests.get("http://localhost:5004/health", timeout=5)
        backend_ok = backend_response.status_code == 200
        print(f"🖥️ Backend (port 5004): {'✅' if backend_ok else '❌'}")
    except:
        backend_ok = False
        print("🖥️ Backend (port 5004): ❌")
    
    # Test 2: Frontend accessible
    try:
        frontend_response = requests.get("http://localhost:3000", timeout=5)
        frontend_ok = frontend_response.status_code == 200
        print(f"🌐 Frontend (port 3000): {'✅' if frontend_ok else '❌'}")
    except:
        frontend_ok = False
        print("🌐 Frontend (port 3000): ❌")
    
    # Test 3: API Catalogue accessible
    try:
        catalog_response = requests.get("http://localhost:5004/api/vwb/catalog/actions", timeout=5)
        catalog_ok = catalog_response.status_code == 200
        if catalog_ok:
            catalog_data = catalog_response.json()
            action_count = len(catalog_data.get('actions', []))
            print(f"📋 API Catalogue: ✅ ({action_count} actions)")
        else:
            print("📋 API Catalogue: ❌")
            action_count = 0
    except Exception as e:
        catalog_ok = False
        action_count = 0
        print(f"📋 API Catalogue: ❌ ({e})")
    
    return backend_ok, frontend_ok, catalog_ok, action_count

def test_cors_headers():
    """Tester les en-têtes CORS"""
    print("\n🔒 Test des en-têtes CORS...")
    
    try:
        response = requests.get(
            "http://localhost:5004/api/vwb/catalog/actions",
            headers={'Origin': 'http://localhost:3000'},
            timeout=5
        )
        
        cors_headers = {
            'Access-Control-Allow-Origin': response.headers.get('Access-Control-Allow-Origin'),
            'Access-Control-Allow-Methods': response.headers.get('Access-Control-Allow-Methods'),
            'Access-Control-Allow-Headers': response.headers.get('Access-Control-Allow-Headers'),
        }
        
        print("📋 En-têtes CORS reçus:")
        for header, value in cors_headers.items():
            status = "✅" if value else "❌"
            print(f"   {header}: {status} {value or 'Non défini'}")
        
        # Vérifier si CORS permet localhost:3000
        origin_ok = cors_headers['Access-Control-Allow-Origin'] in ['*', 'http://localhost:3000']
        return origin_ok
        
    except Exception as e:
        print(f"❌ Erreur lors du test CORS: {e}")
        return False

def test_catalog_service_structure():
    """Tester la structure du service catalogue"""
    print("\n🔍 Test de la structure du service catalogue...")
    
    try:
        # Lire le fichier catalogService.ts
        with open('visual_workflow_builder/frontend/src/services/catalogService.ts', 'r', encoding='utf-8') as f:
            content = f.read()
        
        # Vérifier les éléments clés
        checks = {
            'Classe CatalogService': 'class CatalogService' in content,
            'Méthode getActions': 'async getActions(' in content,
            'Export catalogService': 'export const catalogService' in content,
            'URL API correcte': 'localhost:5004' in content or '/api/vwb/catalog' in content,
            'Gestion d\'erreurs': 'catch' in content and 'error' in content,
        }
        
        print("📋 Structure du catalogService:")
        for check, result in checks.items():
            status = "✅" if result else "❌"
            print(f"   {check}: {status}")
        
        return all(checks.values())
        
    except Exception as e:
        print(f"❌ Erreur lors de la lecture du catalogService: {e}")
        return False

def test_palette_component_structure():
    """Tester la structure du composant Palette"""
    print("\n🎨 Test de la structure du composant Palette...")
    
    try:
        # Lire le fichier Palette/index.tsx
        with open('visual_workflow_builder/frontend/src/components/Palette/index.tsx', 'r', encoding='utf-8') as f:
            content = f.read()
        
        # Vérifier les éléments clés
        checks = {
            'Import catalogService': 'catalogService' in content,
            'Import types catalogue': 'VWBCatalogAction' in content,
            'Hook useCatalogActions': 'useCatalogActions' in content,
            'État catalogState': 'catalogState' in content,
            'Fonction loadCatalogActions': 'loadCatalogActions' in content,
            'Rendu actions catalogue': 'catalogCategories' in content,
        }
        
        print("📋 Structure du composant Palette:")
        for check, result in checks.items():
            status = "✅" if result else "❌"
            print(f"   {check}: {status}")
        
        return all(checks.values())
        
    except Exception as e:
        print(f"❌ Erreur lors de la lecture du composant Palette: {e}")
        return False

def test_hook_catalog_actions():
    """Tester le hook useCatalogActions"""
    print("\n🪝 Test du hook useCatalogActions...")
    
    try:
        # Lire le fichier useCatalogActions.ts
        with open('visual_workflow_builder/frontend/src/hooks/useCatalogActions.ts', 'r', encoding='utf-8') as f:
            content = f.read()
        
        # Vérifier les éléments clés
        checks = {
            'Hook useCatalogActions': 'useCatalogActions' in content,
            'Import catalogService': 'catalogService' in content,
            'État actions': 'actions' in content,
            'Fonction loadActions': 'loadActions' in content or 'getActions' in content,
            'useEffect pour chargement': 'useEffect' in content,
            'Export du hook': 'export' in content,
        }
        
        print("📋 Structure du hook useCatalogActions:")
        for check, result in checks.items():
            status = "✅" if result else "❌"
            print(f"   {check}: {status}")
        
        return all(checks.values())
        
    except FileNotFoundError:
        print("❌ Fichier useCatalogActions.ts non trouvé")
        return False
    except Exception as e:
        print(f"❌ Erreur lors de la lecture du hook: {e}")
        return False

def test_types_catalog():
    """Tester les types du catalogue"""
    print("\n📝 Test des types du catalogue...")
    
    try:
        # Lire le fichier catalog.ts
        with open('visual_workflow_builder/frontend/src/types/catalog.ts', 'r', encoding='utf-8') as f:
            content = f.read()
        
        # Vérifier les types essentiels
        checks = {
            'VWBCatalogAction': 'VWBCatalogAction' in content,
            'VWBActionCategory': 'VWBActionCategory' in content,
            'VWBActionParameter': 'VWBActionParameter' in content,
            'VWBVisualAnchor': 'VWBVisualAnchor' in content,
            'Export des types': 'export' in content,
        }
        
        print("📋 Types du catalogue:")
        for check, result in checks.items():
            status = "✅" if result else "❌"
            print(f"   {check}: {status}")
        
        return all(checks.values())
        
    except Exception as e:
        print(f"❌ Erreur lors de la lecture des types: {e}")
        return False

def main():
    """Fonction principale de diagnostic"""
    print("=" * 60)
    print("🔍 DIAGNOSTIC SIMPLE - PALETTE CATALOGUE VWB")
    print("=" * 60)
    print(f"📅 Date: {datetime.now().strftime('%d/%m/%Y %H:%M:%S')}")
    print()
    
    # Tests séquentiels
    results = {}
    
    # 1. Communication Frontend-Backend
    backend_ok, frontend_ok, catalog_ok, action_count = test_frontend_backend_communication()
    results['communication'] = backend_ok and frontend_ok and catalog_ok
    
    # 2. CORS
    cors_ok = test_cors_headers()
    results['cors'] = cors_ok
    
    # 3. Structure catalogService
    service_ok = test_catalog_service_structure()
    results['service'] = service_ok
    
    # 4. Structure Palette
    palette_ok = test_palette_component_structure()
    results['palette'] = palette_ok
    
    # 5. Hook useCatalogActions
    hook_ok = test_hook_catalog_actions()
    results['hook'] = hook_ok
    
    # 6. Types
    types_ok = test_types_catalog()
    results['types'] = types_ok
    
    # Résumé
    print("\n" + "=" * 60)
    print("📊 RÉSUMÉ DU DIAGNOSTIC")
    print("=" * 60)
    
    success_count = sum(results.values())
    total_tests = len(results)
    
    for test_name, result in results.items():
        status = "✅ OK" if result else "❌ PROBLÈME"
        print(f"{test_name.capitalize():20} : {status}")
    
    print(f"\n📈 Score: {success_count}/{total_tests} ({success_count/total_tests*100:.1f}%)")
    
    # Diagnostic final
    print("\n🔧 DIAGNOSTIC FINAL:")
    
    if not results['communication']:
        print("❌ PROBLÈME CRITIQUE: Communication Frontend-Backend défaillante")
        print("   → Vérifier que les deux services sont démarrés")
    elif not results['cors']:
        print("⚠️ PROBLÈME CORS: Le frontend ne peut pas accéder au backend")
        print("   → Configurer les en-têtes CORS sur le backend")
    elif not results['service']:
        print("⚠️ PROBLÈME SERVICE: Le catalogService a des problèmes de structure")
        print("   → Vérifier l'implémentation du catalogService.ts")
    elif not results['palette']:
        print("⚠️ PROBLÈME PALETTE: Le composant Palette ne charge pas le catalogue")
        print("   → Vérifier l'intégration du catalogue dans Palette/index.tsx")
    elif not results['hook']:
        print("⚠️ PROBLÈME HOOK: Le hook useCatalogActions est manquant ou défaillant")
        print("   → Implémenter ou corriger le hook useCatalogActions")
    elif not results['types']:
        print("⚠️ PROBLÈME TYPES: Les types TypeScript du catalogue sont manquants")
        print("   → Vérifier les définitions de types dans catalog.ts")
    else:
        print("✅ STRUCTURE OK: Tous les composants semblent en place")
        print(f"🎯 {action_count} actions disponibles dans le catalogue")
        print("   → Le problème peut être dans l'exécution JavaScript côté client")
        print("   → Vérifier la console navigateur pour les erreurs")
    
    # Recommandations spécifiques
    print("\n💡 PROCHAINES ÉTAPES:")
    if results['communication'] and results['service'] and results['palette']:
        print("1. Ouvrir http://localhost:3000 dans un navigateur")
        print("2. Ouvrir les outils de développement (F12)")
        print("3. Vérifier la console pour les erreurs JavaScript")
        print("4. Vérifier l'onglet Réseau pour les requêtes vers le catalogue")
        print("5. Chercher la palette dans l'interface et voir si elle contient les actions VisionOnly")
    else:
        print("1. Corriger les problèmes de structure identifiés ci-dessus")
        print("2. Redémarrer le frontend après les corrections")
        print("3. Relancer ce diagnostic")
    
    return success_count == total_tests

if __name__ == "__main__":
    success = main()
    exit(0 if success else 1)