#!/usr/bin/env python3
"""
Vérifie que la CLI respecte la localisation FR/EN.
Exécuté dans la CI après les tests principaux.
"""

from __future__ import annotations

import contextlib
import io

from pathlib import Path
import sys
ROOT = Path(__file__).resolve().parent.parent
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from web_sentinel import cli as cli_module
from web_sentinel.model import ScanResult
from web_sentinel.subscription.models import SubscriptionTier
from web_sentinel.gui.i18n import localization


class _DummyManager:
    tier = SubscriptionTier.PRO

    def can_use_invasive_tests(self) -> bool:
        return True

    def can_export_html(self) -> bool:
        return True

    def can_use_api(self) -> bool:
        return True

    def can_manage_users(self) -> bool:
        return True

    def get_domain_limit(self) -> int:
        return -1

    def get_user_limit(self) -> int:
        return 5

    def get_features(self):
        from types import SimpleNamespace

        return SimpleNamespace(
            tier=self.tier,
            domain_limit=-1,
            max_users=self.get_user_limit(),
            allow_invasive_tests=True,
            allow_html_export=True,
            allow_multi_user=True,
            allow_api_access=True,
        )


class _DummyBridge:
    def get_runtime_manager(self) -> _DummyManager:
        return _DummyManager()

    def get_runtime_validator(self):
        class _DummyValidator:
            pass

        return _DummyValidator()

    def refresh(self) -> bool:
        return True

    def get_license_status(self) -> dict:
        return {
            "status": "LICENSED",
            "tier": "PRO",
            "valid": True,
            "license_id": "TEST-CLI",
            "expires_in_days": 10,
            "grace_hours": 168,
            "max_domains": -1,
            "max_users": 5,
            "features": {"html_export": True, "invasive_tests": True},
            "features_enabled": {
                "invasive_tests": True,
                "html_export": True,
                "api_access": True,
                "multi_user": True,
            },
            "alert_level": None,
            "alert_threshold": None,
            "backend": {"name": "ci-check", "verified": True},
        }

    def validate_feature_access(self, feature: str) -> bool:
        return True


class _DummyScanner:
    def __init__(self, *args, **kwargs):
        pass

    def run(self, request, enabled_modules=None) -> ScanResult:
        return ScanResult(request=request, findings=[])


def run_check(language: str, expected_snippet: str) -> None:
    cli_module.get_license_bridge = lambda: _DummyBridge()
    cli_module.initialize_license_system = lambda: True
    cli_module.SentinelScanner = _DummyScanner

    buffer = io.StringIO()
    with contextlib.redirect_stdout(buffer):
        exit_code = cli_module.main(["example.com", "--language", language])
    output = buffer.getvalue()

    if exit_code != 0:
        raise SystemExit(f"CLI exited with {exit_code} for language={language}")

    if expected_snippet not in output:
        raise AssertionError(
            f"Expected snippet '{expected_snippet}' not found for language={language}.\n\nOutput:\n{output}"
        )


def main() -> int:
    try:
        run_check("fr", "Aucun constat détecté.")
        run_check("en", "No findings detected.")
        print("✅ CLI localization check passed")
    finally:
        localization.set_language("fr")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())