from __future__ import annotations

from types import SimpleNamespace
from typing import Optional

from ...logging_config import get_logger
from ...subscription import SubscriptionTier
from ...subscription.models import get_features_for_tier

LOGGER = get_logger("gui.license")


class LicenseSection:
    """Encapsule la logique licence / abonnement pour la GUI moderne."""

    def __init__(self, gui: "ModernWebSentinelGUI") -> None:
        self.gui = gui

    # ------------------------------------------------------------------
    # Synchronisation & état
    # ------------------------------------------------------------------
    def synchronize_with_auth(self) -> None:
        gui = self.gui
        user = gui.auth_manager.get_current_user()
        subscription_manager = gui.auth_manager.get_subscription_manager()
        owner_email = getattr(user, "email", None) if user else None

        gui.license_initialized = gui.license_bridge.apply_subscription(
            subscription_manager.tier,
            owner_email,
        )
        self.refresh_state()

    def refresh_state(self) -> None:
        gui = self.gui
        gui.subscription_manager = gui.license_bridge.get_runtime_manager()
        gui.license_validator = gui.license_bridge.get_runtime_validator()
        gui.license_status = gui.license_bridge.get_license_status()

    # ------------------------------------------------------------------
    # Lecture des fonctionnalités
    # ------------------------------------------------------------------
    def resolve_subscription_tier(self) -> SubscriptionTier:
        gui = self.gui
        tier = getattr(gui.subscription_manager, "tier", None)
        if isinstance(tier, SubscriptionTier):
            return tier
        if isinstance(tier, str):
            try:
                return SubscriptionTier(tier.lower())
            except ValueError:
                pass

        status = getattr(gui, "license_status", {}) or {}
        tier_label = status.get("tier")
        if isinstance(tier_label, str):
            try:
                return SubscriptionTier(tier_label.lower())
            except ValueError:
                pass
        return SubscriptionTier.FREE

    def get_runtime_features(self) -> SimpleNamespace:
        gui = self.gui
        user = gui.auth_manager.get_current_user()
        # Vérifier d'abord le tier, sinon le role (pour rétrocompatibilité)
        user_tier = str(getattr(user, "tier", "")).upper() if user else ""
        user_role = str(getattr(user, "role", "")).upper() if user else ""

        # SYSOP a toujours toutes les fonctionnalités activées.
        if "SYSOP" in user_tier or "SYSOP" in user_role:
            return SimpleNamespace(
                tier=SubscriptionTier.SYSOP,
                domain_limit=-1,
                max_users=-1,
                allow_invasive_tests=True,
                allow_html_export=True,
                allow_multi_user=True,
                allow_api_access=True,
                allow_source_scan=True,
                max_source_files=-1,
                max_source_size_mb=-1,
                advanced_rules=True,
            )

        features_obj: Optional[SimpleNamespace] = None
        if gui.subscription_manager:
            try:
                features_obj = gui.subscription_manager.get_features()
            except Exception as exc:
                LOGGER.debug("Unable to retrieve features via SubscriptionManager: %s", exc)

        if features_obj is None:
            base_features = get_features_for_tier(self.resolve_subscription_tier())
            features_obj = SimpleNamespace(**base_features.__dict__)
        elif not isinstance(features_obj, SimpleNamespace):
            features_obj = SimpleNamespace(**features_obj.__dict__)

        # Appliquer les overrides fournis par license_status.
        status = getattr(gui, "license_status", {}) or {}
        features_enabled = status.get("features_enabled", {})
        if isinstance(features_enabled, dict):
            if "source_scan" in features_enabled:
                features_obj.allow_source_scan = bool(features_enabled["source_scan"])
            if "advanced_rules" in features_enabled:
                features_obj.advanced_rules = bool(features_enabled["advanced_rules"])
            if "invasive_tests" in features_enabled:
                features_obj.allow_invasive_tests = bool(features_enabled["invasive_tests"])
            if "html_export" in features_enabled:
                features_obj.allow_html_export = bool(features_enabled["html_export"])

        if status.get("max_source_files") is not None:
            features_obj.max_source_files = status["max_source_files"]
        if status.get("max_source_size_mb") is not None:
            features_obj.max_source_size_mb = status["max_source_size_mb"]

        return features_obj