#!/usr/bin/env python3
"""
Script de test simple sans pytest pour environnements basiques.
Lance les tests unitaires essentiels directement.
"""

import sys
import traceback
from pathlib import Path

def test_imports():
    """Test des imports de base."""
    print("🧪 Test des imports...")
    
    try:
        # Test imports principaux
        from web_sentinel.model import ScanRequest, Finding, ScanResult
        from web_sentinel.orchestrator import build_default_modules, CheckModule
        from web_sentinel.gui.i18n import LocalizationManager
        print("✅ Imports principaux")
        
        # Test import headless
        from web_sentinel.gui.headless import HeadlessWebSentinelGUI, MockVar
        print("✅ Interface headless")
        
        return True
        
    except Exception as e:
        print(f"❌ Erreur d'import: {e}")
        traceback.print_exc()
        return False

def test_model_classes():
    """Test des classes du modèle."""
    print("🧪 Test des classes modèle...")
    
    try:
        from web_sentinel.model import ScanRequest, Finding, ScanResult
        
        # Test ScanRequest
        request = ScanRequest(domain="example.com")
        assert request.domain == "example.com"
        assert request.timeout == 5.0
        assert request.allow_invasive is False
        
        request_dict = request.to_dict()
        assert isinstance(request_dict, dict)
        assert request_dict["domain"] == "example.com"
        print("✅ ScanRequest")
        
        # Test Finding
        finding = Finding(
            check="test",
            title="Test Issue",
            severity="medium",
            description="Test description",
            remediation="Fix it"
        )
        assert finding.check == "test"
        assert finding.severity == "medium"
        
        finding_dict = finding.to_dict()
        assert isinstance(finding_dict, dict)
        assert finding_dict["title"] == "Test Issue"
        print("✅ Finding")
        
        # Test ScanResult
        result = ScanResult(request=request, findings=[finding])
        assert result.request == request
        assert len(result.findings) == 1
        assert result.findings[0] == finding
        print("✅ ScanResult")
        
        return True
        
    except Exception as e:
        print(f"❌ Erreur modèle: {e}")
        traceback.print_exc()
        return False

def test_orchestrator():
    """Test de l'orchestrateur.""" 
    print("🧪 Test de l'orchestrateur...")
    
    try:
        from web_sentinel.orchestrator import build_default_modules, CheckModule
        
        # Test construction des modules
        modules = build_default_modules()
        assert isinstance(modules, list)
        assert len(modules) >= 4  # Au moins les modules principaux
        
        # Vérifier structure des modules
        for module in modules:
            assert isinstance(module, CheckModule)
            assert isinstance(module.name, str)
            assert len(module.name) > 0
            assert isinstance(module.description, str)
            assert callable(module.runner)
            assert hasattr(module.tags, '__iter__')
        
        # Vérifier modules essentiels
        module_names = [m.name for m in modules]
        assert "tls" in module_names
        assert "headers" in module_names
        assert "injection" in module_names
        assert "third-party" in module_names
        
        print(f"✅ Orchestrateur ({len(modules)} modules)")
        return True
        
    except Exception as e:
        print(f"❌ Erreur orchestrateur: {e}")
        traceback.print_exc()
        return False

def test_localization():
    """Test du système de localisation."""
    print("🧪 Test de la localisation...")
    
    try:
        from web_sentinel.gui.i18n import LocalizationManager
        from web_sentinel.model import Finding
        
        # Test création et langue par défaut
        loc = LocalizationManager()
        assert loc.get_current_language() == "fr"
        
        # Test traduction basique
        title_fr = loc.t("app_title")
        assert isinstance(title_fr, str)
        assert len(title_fr) > 0
        
        # Test changement de langue
        loc.set_language("en")
        assert loc.get_current_language() == "en"
        
        title_en = loc.t("app_title")
        assert isinstance(title_en, str)
        assert title_en != title_fr  # Doit être différent
        
        # Test traduction de sévérité
        assert loc.translate_severity("critical") == "CRITICAL"
        assert loc.translate_severity("medium") == "MEDIUM"
        
        # Test traduction de module
        assert "TLS" in loc.translate_module("tls")
        assert "Headers" in loc.translate_module("headers")
        
        # Test traduction de finding
        finding = Finding(
            check="tls",
            title="Certificat SSL expiré",
            severity="high",
            description="Le certificat SSL a expiré.",
            remediation="Renouveler le certificat SSL immédiatement."
        )
        
        translated = loc.translate_finding_content(finding)
        assert translated.title == "SSL certificate expired"
        assert "ssl certificate" in translated.description.lower()
        
        print("✅ Localisation")
        return True
        
    except Exception as e:
        print(f"❌ Erreur localisation: {e}")
        traceback.print_exc()
        return False

def test_headless_gui():
    """Test de l'interface headless."""
    print("🧪 Test interface headless...")
    
    try:
        from web_sentinel.gui.headless import HeadlessWebSentinelGUI, MockVar, get_gui_class
        
        # Test MockVar
        var = MockVar("test")
        assert var.get() == "test"
        var.set("new_value")
        assert var.get() == "new_value"
        
        # Test HeadlessGUI
        gui = HeadlessWebSentinelGUI()
        assert gui.is_scanning is False
        assert len(gui.scan_results) == 0
        
        # Test gestion des domaines
        gui.set_domains(["example.com", "test.com"])
        domains = gui.get_domains()
        assert domains == ["example.com", "test.com"]
        
        # Test gestion des modules
        gui.set_selected_modules(["tls", "headers"])
        modules = gui.get_selected_modules()
        assert "tls" in modules
        assert "headers" in modules
        assert "third-party" not in modules
        
        # Test factory
        headless_class = get_gui_class(headless=True)
        assert headless_class == HeadlessWebSentinelGUI
        
        print("✅ Interface headless")
        return True
        
    except Exception as e:
        print(f"❌ Erreur interface headless: {e}")
        traceback.print_exc()
        return False

def test_optional_dependencies():
    """Test des dépendances optionnelles."""
    print("🧪 Test des dépendances optionnelles...")
    
    deps_status = {}
    
    # Test tkinter
    try:
        import tkinter
        deps_status["tkinter"] = True
        print("✅ tkinter disponible")
    except ImportError:
        deps_status["tkinter"] = False
        print("⚠️ tkinter non disponible")
    
    # Test BeautifulSoup4
    try:
        import bs4
        deps_status["bs4"] = True
        print("✅ BeautifulSoup4 disponible")
    except ImportError:
        deps_status["bs4"] = False
        print("⚠️ BeautifulSoup4 non disponible")
    
    # Test que l'orchestrateur fonctionne même sans bs4
    try:
        from web_sentinel.orchestrator import build_default_modules
        modules = build_default_modules()
        module_names = [m.name for m in modules]
        
        if deps_status["bs4"]:
            assert "static-analysis" in module_names
            print("✅ Module static-analysis disponible avec bs4")
        else:
            print("⚠️ Module static-analysis non disponible sans bs4 (normal)")
        
        # Dans tous les cas, autres modules doivent être disponibles
        assert "tls" in module_names
        assert "headers" in module_names
        
    except Exception as e:
        print(f"❌ Erreur test dépendances: {e}")
        return False
    
    return True

def run_all_tests():
    """Lancer tous les tests."""
    print("🚀 TESTS UNITAIRES WEB SENTINEL")
    print("=" * 50)
    
    tests = [
        ("Imports", test_imports),
        ("Classes modèle", test_model_classes),
        ("Orchestrateur", test_orchestrator),
        ("Localisation", test_localization),
        ("Interface headless", test_headless_gui),
        ("Dépendances optionnelles", test_optional_dependencies),
    ]
    
    passed = 0
    total = len(tests)
    
    for name, test_func in tests:
        print(f"\n--- {name} ---")
        try:
            if test_func():
                passed += 1
            else:
                print(f"❌ Test '{name}' échoué")
        except Exception as e:
            print(f"❌ Test '{name}' échoué avec exception: {e}")
    
    print("\n" + "=" * 50)
    print(f"📊 RÉSULTATS: {passed}/{total} tests réussis")
    
    if passed == total:
        print("🎉 Tous les tests sont passés!")
        return 0
    else:
        print("⚠️ Certains tests ont échoué")
        return 1

if __name__ == "__main__":
    sys.exit(run_all_tests())