"""
Version headless simplifiée sans emojis pour CI/CD.
Compatible avec tous les encodages de terminal.
"""
from typing import Dict, List, Optional
import json
from pathlib import Path

from ..model import ScanRequest, ScanResult
from ..scanner import SentinelScanner
from ..reporting import ReportEngine
from .i18n import localization


class SimpleHeadlessGUI:
    """Interface headless simplifiée pour CI/CD sans emojis Unicode."""
    
    def __init__(self):
        """Initialisation sans output unicode."""
        self.scanner = SentinelScanner()
        self.report_engine = ReportEngine()
        self.scan_results: List[ScanResult] = []
        # Mode silencieux par défaut pour CI
        self.verbose = False

    def _text(self, key: str, **kwargs) -> str:
        return localization.t(key).format(**kwargs)

    def _print(self, key: str, **kwargs) -> None:
        if self.verbose:
            print(self._text(key, **kwargs))
        
    def set_verbose(self, verbose: bool = True):
        """Active/désactive les messages de debug."""
        self.verbose = verbose
        
    def run_headless_test(
        self, 
        test_domains: List[str],
        test_modules: Optional[List[str]] = None
    ) -> Dict:
        """
        Lance un test headless simplifié.
        
        Returns:
            Dict avec les résultats essentiels pour CI/CD
        """
        self._print("messages.simple_headless.test_start")
            
        if not test_modules:
            test_modules = ["tls", "headers"]
            
        # Scan des domaines
        all_findings = []
        scanned_domains = []
        
        for domain in test_domains:
            try:
                self._print("messages.simple_headless.scan_domain", domain=domain)

                request = ScanRequest(domain=domain, timeout=10)
                result = self.scanner.run(request, test_modules)

                all_findings.extend(result.findings)
                scanned_domains.append(domain)

                self._print("messages.simple_headless.scan_result", domain=domain, count=len(result.findings))
            except Exception as e:
                self._print("messages.simple_headless.scan_error", domain=domain, error=e)
                continue
        
        # Résultat formaté pour CI/CD
        result = {
            'test_timestamp': self._get_timestamp(),
            'domains_tested': test_domains,
            'domains_scanned': scanned_domains,  # Clé attendue par CI
            'modules_used': test_modules,
            'scan_success': len(scanned_domains) > 0,
            'total_findings': len(all_findings),
            'results_summary': self._create_summary(scanned_domains, all_findings)
        }
        
        self._print(
            "messages.simple_headless.test_complete",
            domains=len(scanned_domains),
            findings=len(all_findings)
        )
            
        return result
    
    def _get_timestamp(self) -> str:
        """Retourne timestamp ISO format."""
        from datetime import datetime
        return datetime.now().isoformat()
    
    def _create_summary(self, domains: List[str], findings) -> Dict:
        """Crée un résumé des résultats par domaine."""
        summary = {}
        
        # Groupe findings par domaine (si disponible)
        for domain in domains:
            domain_findings = [f for f in findings if hasattr(f, 'domain') and f.domain == domain]
            if not domain_findings:
                # Fallback: tous les findings pour ce domaine
                domain_findings = findings
                
            # Compte par sévérité
            severities = {}
            for finding in domain_findings:
                sev = finding.severity.lower()
                severities[sev] = severities.get(sev, 0) + 1
            
            summary[domain] = {
                'findings_count': len(domain_findings),
                'severities': severities
            }
            
        return summary


# Classe compatible legacy
class HeadlessWebSentinelGUI(SimpleHeadlessGUI):
    """
    Wrapper pour compatibilité avec l'interface existante.
    Redirige vers SimpleHeadlessGUI pour éviter les problèmes Unicode.
    """
    pass