#!/usr/bin/env python3
"""
⚙️ Configurateur Mode Test - Web Sentinel

Configure Web Sentinel pour utiliser notre API locale de subscription
au lieu de l'API cloud, permettant de tester les tiers modifiés.
"""

import os
import sys
import json
import time
import subprocess
from pathlib import Path
from typing import Optional

# Ajouter le chemin
sys.path.insert(0, str(Path(__file__).parent))
sys.path.insert(0, str(Path(__file__).parent.parent))

from local_subscription_api import LocalSubscriptionAPI


class WebSentinelTestConfigurator:
    """Configurateur pour le mode test de Web Sentinel."""
    
    def __init__(self):
        self.api_service = LocalSubscriptionAPI()
        self.ws_root = Path(__file__).parent.parent
        self.config_dir = Path.home() / ".web-sentinel"
        self.test_config_file = self.config_dir / "test_mode.json"
    
    def start_local_api(self):
        """Démarrer l'API locale."""
        if not self.api_service.is_running():
            self.api_service.start()
            time.sleep(1)  # Attendre que le service démarre
            return self.api_service.is_running()
        return True
    
    def stop_local_api(self):
        """Arrêter l'API locale."""
        self.api_service.stop()
    
    def configure_test_mode(self):
        """Configurer Web Sentinel en mode test."""
        # S'assurer que le répertoire de config existe
        self.config_dir.mkdir(exist_ok=True)
        
        # Configuration de test
        test_config = {
            "mode": "test",
            "local_api_url": self.api_service.get_url(),
            "offline_mode": False,  # On utilise l'API locale, pas le mode offline
            "test_user": "bruno@taaazzz-prog.fr",
            "created_at": time.time()
        }
        
        # Sauvegarder la config de test
        with open(self.test_config_file, 'w') as f:
            json.dump(test_config, f, indent=2)
        
        print(f"⚙️ Configuration test sauvegardée: {self.test_config_file}")
        return test_config
    
    def set_environment_variables(self):
        """Définir les variables d'environnement pour le mode test."""
        env_vars = {
            "WS_TEST_MODE": "1",
            "WEB_SENTINEL_AUTH_URL": self.api_service.get_url(),  # Variable utilisée par AuthManager
            "WS_OFFLINE_MODE": "false"  # On utilise l'API locale
        }
        
        for key, value in env_vars.items():
            os.environ[key] = value
            print(f"🔧 Variable d'environnement: {key}={value}")
        
        return env_vars
    
    def launch_web_sentinel_cli(self, domain: str = "example.com", modules: str = "headers"):
        """Lancer Web Sentinel CLI en mode test."""
        print(f"\n🚀 LANCEMENT WEB SENTINEL CLI EN MODE TEST")
        print("=" * 50)
        
        # S'assurer que l'API locale est démarrée
        if not self.start_local_api():
            print("❌ Impossible de démarrer l'API locale")
            return False
        
        # Configurer l'environnement
        env_vars = self.set_environment_variables()
        
        # Préparer la commande
        cmd = [
            sys.executable, "-m", "web_sentinel.cli",
            domain,
            "--modules", modules
        ]
        
        print(f"🔧 Commande: {' '.join(cmd)}")
        print(f"🌐 API locale: {self.api_service.get_url()}")
        
        try:
            # Créer l'environnement avec nos variables
            env = os.environ.copy()
            env.update(env_vars)
            
            # Lancer Web Sentinel
            result = subprocess.run(
                cmd,
                cwd=self.ws_root,
                env=env,
                capture_output=True,
                text=True,
                timeout=30
            )
            
            print(f"\n📊 RÉSULTATS:")
            print(f"Code de retour: {result.returncode}")
            
            if result.stdout:
                print(f"\n📄 STDOUT:")
                print(result.stdout)
            
            if result.stderr:
                print(f"\n⚠️ STDERR:")
                print(result.stderr)
            
            return result.returncode == 0
            
        except subprocess.TimeoutExpired:
            print("⏰ Timeout: Web Sentinel CLI a pris trop de temps")
            return False
        except Exception as e:
            print(f"❌ Erreur: {e}")
            return False
        finally:
            # Nettoyer
            self.stop_local_api()
    
    def launch_web_sentinel_gui(self):
        """Lancer Web Sentinel GUI en mode test."""
        print(f"\n🖥️ LANCEMENT WEB SENTINEL GUI EN MODE TEST")
        print("=" * 50)
        
        # S'assurer que l'API locale est démarrée
        if not self.start_local_api():
            print("❌ Impossible de démarrer l'API locale")
            return False
        
        # Configurer l'environnement
        env_vars = self.set_environment_variables()
        
        try:
            # Créer l'environnement avec nos variables
            env = os.environ.copy()
            env.update(env_vars)
            
            # Vérifier si le module GUI existe
            gui_module = self.ws_root / "web_sentinel" / "gui"
            if not gui_module.exists():
                print(f"⚠️ Module GUI non trouvé: {gui_module}")
                print(f"💡 Essayez de lancer directement le CLI avec --launch-cli")
                return False
            
            # Lancer la GUI en arrière-plan
            print(f"🔧 Démarrage GUI avec API locale: {self.api_service.get_url()}")
            print(f"💡 La GUI va utiliser les tiers de notre base de données")
            print(f"💡 Laissez cette fenêtre ouverte pour maintenir l'API locale")
            
            subprocess.Popen([
                sys.executable, "-m", "web_sentinel.gui.main"
            ], cwd=self.ws_root, env=env)
            
            print(f"✅ GUI lancée en arrière-plan")
            print(f"🔄 API locale en cours sur {self.api_service.get_url()}")
            
            # Maintenir l'API en vie
            try:
                print(f"\n💡 Appuyez sur Ctrl+C pour arrêter l'API locale et fermer")
                while self.api_service.is_running():
                    time.sleep(1)
            except KeyboardInterrupt:
                print(f"\n🛑 Arrêt de l'API locale...")
                
            return True
            
        except Exception as e:
            print(f"❌ Erreur: {e}")
            return False
        finally:
            self.stop_local_api()
    
    def test_subscription_integration(self):
        """Tester l'intégration des abonnements."""
        print(f"\n🧪 TEST D'INTÉGRATION DES ABONNEMENTS")
        print("=" * 50)
        
        # Démarrer l'API
        if not self.start_local_api():
            print("❌ Impossible de démarrer l'API locale")
            return False
        
        try:
            # Tester avec requests
            import requests
            
            print(f"🌐 Test de l'API: {self.api_service.get_url()}")
            
            # Test 1: Health check
            health_response = requests.get(f"{self.api_service.get_url()}/health", timeout=5)
            if health_response.status_code == 200:
                print(f"✅ Health check OK")
            else:
                print(f"❌ Health check échoué: {health_response.status_code}")
                return False
            
            # Test 2: Subscription status
            headers = {'Authorization': 'Bearer test-token'}
            sub_response = requests.get(
                f"{self.api_service.get_url()}/subscription/status", 
                headers=headers, 
                timeout=5
            )
            
            if sub_response.status_code == 200:
                data = sub_response.json()
                print(f"✅ Subscription API OK:")
                print(f"   📊 Tier: {data['tier']}")
                print(f"   📋 Features: {json.dumps(data['features'], indent=4)}")
                
                # Test 3: Simuler Web Sentinel AuthManager
                print(f"\n🔗 Test avec AuthManager simulation...")
                self.set_environment_variables()
                
                # Simuler _get_cloud_subscription_tier
                from web_sentinel.subscription.manager import SubscriptionTier, SubscriptionManager
                
                tier = SubscriptionTier(data['tier'])
                manager = SubscriptionManager(user_id="test-user", tier=tier)
                
                print(f"✅ SubscriptionManager créé avec tier: {manager.tier.value}")
                print(f"   📊 Tests invasifs: {manager.can_use_invasive_tests()}")
                print(f"   📊 Export HTML: {manager.can_export_html()}")
                print(f"   📊 API: {manager.can_use_api()}")
                
                return True
            else:
                print(f"❌ Subscription API échoué: {sub_response.status_code}")
                return False
                
        except Exception as e:
            print(f"❌ Erreur test: {e}")
            return False
        finally:
            self.stop_local_api()


def main():
    """Fonction principale."""
    import argparse
    
    parser = argparse.ArgumentParser(description="⚙️ Configurateur Mode Test Web Sentinel")
    parser.add_argument("--launch-cli", help="Lancer CLI avec domaine spécifié")
    parser.add_argument("--launch-gui", action="store_true", help="Lancer GUI en mode test")
    parser.add_argument("--test-integration", action="store_true", help="Tester l'intégration")
    parser.add_argument("--modules", default="headers", help="Modules pour CLI (défaut: headers)")
    
    args = parser.parse_args()
    
    configurator = WebSentinelTestConfigurator()
    
    if args.launch_cli:
        success = configurator.launch_web_sentinel_cli(args.launch_cli, args.modules)
        print(f"\n{'✅ SUCCÈS' if success else '❌ ÉCHEC'}")
        
    elif args.launch_gui:
        configurator.launch_web_sentinel_gui()
        
    elif args.test_integration:
        success = configurator.test_subscription_integration()
        print(f"\n{'✅ SUCCÈS' if success else '❌ ÉCHEC'}")
        
    else:
        print("⚙️ Configurateur Mode Test Web Sentinel")
        print("=" * 40)
        print("💡 Exemples d'utilisation:")
        print("   python test_configurator.py --test-integration")
        print("   python test_configurator.py --launch-cli example.com")
        print("   python test_configurator.py --launch-gui")
        print("   python test_configurator.py --launch-cli test.com --modules 'headers,tls'")


if __name__ == "__main__":
    main()