"""
Android net.wifi.hotspot2 包 — PasspointConfiguration, HomeSp, PasspointManager,
OsuProvider, WifiPasspointInfo, ProvisionCallback
方法签名完全对齐 Android SDK
"""

from __future__ import annotations

import sys
from typing import Any, Dict, List, Optional, Tuple

from .._core import Stub, AndroidOnlyError
from ..java.lang import RuntimeException

IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {})

__all__ = [
    "PasspointConfiguration",
    "HomeSp",
    "PasspointManager",
    "OsuProvider",
    "WifiPasspointInfo",
    "ProvisionCallback",
]


# ═══════════════════════════════════════════════════════════════
# HomeSp
# ═══════════════════════════════════════════════════════════════

class HomeSp(Stub):
    """HomeSp — 家庭服务提供商 (桌面存根)"""

    def __init__(self, fqdn: str = "", friendly_name: str = ""):
        super().__init__()
        self._fqdn = fqdn
        self._friendly_name = friendly_name
        self._friendly_name_list: List[str] = [friendly_name] if friendly_name else []
        self._match_all_ois: List[int] = []
        self._match_any_ois: List[int] = []
        self._other_home_provider_networks: List["HomeSp"] = []
        self._roaming_consortium_ois: List[int] = []
        self._icon_url = ""
        self._icon: Any = None

    def getFqdn(self) -> str:
        """获取 FQDN"""
        return self._fqdn

    def getFriendlyName(self) -> str:
        """获取友好名称"""
        return self._friendly_name

    def getFriendlyNameList(self) -> List[str]:
        """获取友好名称列表"""
        return self._friendly_name_list.copy()

    def getMatchAllOis(self) -> List[int]:
        """获取匹配所有 OI"""
        return self._match_all_ois.copy()

    def getMatchAnyOis(self) -> List[int]:
        """获取匹配任意 OI"""
        return self._match_any_ois.copy()

    def getOtherHomeProviderNetworks(self) -> List["HomeSp"]:
        """获取其他家庭提供商网络"""
        return self._other_home_provider_networks.copy()

    def getRoamingConsortiumOis(self) -> List[int]:
        """获取漫游联盟 OI"""
        return self._roaming_consortium_ois.copy()

    def getIconUrl(self) -> str:
        """获取图标 URL"""
        return self._icon_url

    def getIcon(self) -> Any:
        """获取图标"""
        return self._icon

    def toString(self) -> str:
        return f"HomeSp(fqdn={self._fqdn}, name={self._friendly_name})"


# ═══════════════════════════════════════════════════════════════
# PasspointConfiguration
# ═══════════════════════════════════════════════════════════════

class PasspointConfiguration(Stub):
    """PasspointConfiguration — Passpoint 配置 (桌面存根)"""

    def __init__(self):
        super().__init__()
        self._home_sp: Optional[HomeSp] = None
        self._credential: Optional[Any] = None
        self._update_identifier: Optional[int] = None
        self._unique_id = ""
        self._osu_provisioned = False
        self._osu_provider_id = ""
        self._service_friendly_name = ""
        self._service_description = ""
        self._service_icon_url = ""
        self._user_intervention_required = False
        self._create_time: Optional[int] = None
        self._expiration_time: Optional[int] = None

    def getHomeSp(self) -> Optional[HomeSp]:
        """获取家庭 SP"""
        return self._home_sp

    def setHomeSp(self, home_sp: HomeSp) -> None:
        """设置家庭 SP"""
        self._home_sp = home_sp

    def getCredential(self) -> Optional[Any]:
        """获取凭据"""
        return self._credential

    def setCredential(self, credential: Any) -> None:
        """设置凭据"""
        self._credential = credential

    def getUpdateIdentifier(self) -> Optional[int]:
        """获取更新标识符"""
        return self._update_identifier

    def setUpdateIdentifier(self, identifier: Optional[int]) -> None:
        """设置更新标识符"""
        self._update_identifier = identifier

    def getUniqueId(self) -> str:
        """获取唯一 ID"""
        return self._unique_id

    def isOsuProvisioned(self) -> bool:
        """检查是否为 OSU 配置"""
        return self._osu_provisioned

    def getOsuProviderId(self) -> str:
        """获取 OSU 提供商 ID"""
        return self._osu_provider_id

    def setOsuProviderId(self, provider_id: str) -> None:
        """设置 OSU 提供商 ID"""
        self._osu_provider_id = provider_id

    def getServiceFriendlyName(self) -> str:
        """获取服务友好名称"""
        return self._service_friendly_name

    def setServiceFriendlyName(self, name: str) -> None:
        """设置服务友好名称"""
        self._service_friendly_name = name

    def getServiceDescription(self) -> str:
        """获取服务描述"""
        return self._service_description

    def setServiceDescription(self, description: str) -> None:
        """设置服务描述"""
        self._service_description = description

    def getServiceIconUrl(self) -> str:
        """获取服务图标 URL"""
        return self._service_icon_url

    def setServiceIconUrl(self, url: str) -> None:
        """设置服务图标 URL"""
        self._service_icon_url = url

    def isUserInterventionRequired(self) -> bool:
        """检查是否需要用户干预"""
        return self._user_intervention_required

    def setUserInterventionRequired(self, required: bool) -> None:
        """设置用户干预"""
        self._user_intervention_required = required

    def getCreateTime(self) -> Optional[int]:
        """获取创建时间"""
        return self._create_time

    def setCreateTime(self, time_millis: int) -> None:
        """设置创建时间"""
        self._create_time = time_millis

    def getExpirationTime(self) -> Optional[int]:
        """获取过期时间"""
        return self._expiration_time

    def setExpirationTime(self, time_millis: int) -> None:
        """设置过期时间"""
        self._expiration_time = time_millis

    def toString(self) -> str:
        return f"PasspointConfiguration(fqdn={self._home_sp.getFqdn() if self._home_sp else 'none'})"

    def equals(self, other: Any) -> bool:
        if not isinstance(other, PasspointConfiguration):
            return False
        return self._unique_id == other._unique_id

    def hashCode(self) -> int:
        return hash(self._unique_id) & 0x7FFFFFFF


# ═══════════════════════════════════════════════════════════════
# PasspointManager
# ═══════════════════════════════════════════════════════════════

class PasspointManager(Stub):
    """PasspointManager — Passpoint 管理器 (桌面存根)"""

    _instance: Optional["PasspointManager"] = None

    def __init__(self):
        super().__init__()
        self._providers: Dict[str, PasspointConfiguration] = {}
        self._matching_configs: List[Any] = []
        self._preferred_provider: Optional[str] = None

    @staticmethod
    def getInstance() -> "PasspointManager":
        if PasspointManager._instance is None:
            PasspointManager._instance = PasspointManager()
        return PasspointManager._instance

    def addOrUpdateProvider(self, config: PasspointConfiguration) -> None:
        """添加或更新提供商"""
        self._providers[config.getUniqueId()] = config

    def removeProvider(self, config: PasspointConfiguration) -> None:
        """移除提供商"""
        self._providers.pop(config.getUniqueId(), None)

    def getProviders(self) -> List[PasspointConfiguration]:
        """获取提供商列表"""
        return list(self._providers.values())

    def getMatchingWifiConfigs(self, fqdn: str) -> List[Any]:
        """获取匹配的 Wi-Fi 配置"""
        return self._matching_configs

    def queryPasspointIcon(self, config: PasspointConfiguration, icon_url: str) -> None:
        """查询 Passpoint 图标"""
        pass

    def abortQueryPasspointIcon(self, icon_url: str) -> None:
        """中止查询 Passpoint 图标"""
        pass

    def setIcon(self, config: PasspointConfiguration, icon: Any) -> None:
        """设置图标"""
        pass

    def getAnqpOsuProviders(self, config: PasspointConfiguration) -> List["OsuProvider"]:
        """获取 ANQP OSU 提供商"""
        return []

    def convertToWifiConfiguration(self, config: PasspointConfiguration) -> Optional[Any]:
        """转换为 Wi-Fi 配置"""
        return None

    def setPreferredProvider(self, config: PasspointConfiguration) -> None:
        """设置首选提供商"""
        self._preferred_provider = config.getUniqueId()

    def clearPreferredProvider(self) -> None:
        """清除首选提供商"""
        self._preferred_provider = None

    def getPasspointProviderWithPackage(self, package_name: str) -> Optional[PasspointConfiguration]:
        """获取指定包名的 Passpoint 提供商"""
        for config in self._providers.values():
            return config
        return None


# ═══════════════════════════════════════════════════════════════
# OsuProvider
# ═══════════════════════════════════════════════════════════════

class OsuProvider(Stub):
    """OsuProvider — OSU 提供商 (桌面存根)"""

    OS_METHOD_SOAP_XML = 0
    OS_METHOD_OMADM = 1

    def __init__(self, friendly_name: str = "", service_description: str = "",
                 server_uri: str = "", network_access_identifier: str = "",
                 method_list: Optional[List[int]] = None):
        super().__init__()
        self._friendly_name = friendly_name
        self._service_description = service_description
        self._server_uri = server_uri
        self._network_access_identifier = network_access_identifier
        self._method_list = method_list or []

    def getFriendlyName(self) -> str:
        """获取友好名称"""
        return self._friendly_name

    def getServiceDescription(self) -> str:
        """获取服务描述"""
        return self._service_description

    def getServerUri(self) -> str:
        """获取服务器 URI"""
        return self._server_uri

    def getNetworkAccessIdentifier(self) -> str:
        """获取网络接入标识符"""
        return self._network_access_identifier

    def getMethodList(self) -> List[int]:
        """获取方法列表"""
        return self._method_list.copy()


# ═══════════════════════════════════════════════════════════════
# WifiPasspointInfo
# ═══════════════════════════════════════════════════════════════

class WifiPasspointInfo(Stub):
    """WifiPasspointInfo — Wi-Fi Passpoint 信息"""

    def __init__(self, fqdn: str = "", provider_friendly_name: str = ""):
        super().__init__()
        self._fqdn = fqdn
        self._provider_friendly_name = provider_friendly_name
        self._roaming_consortium_ids: List[int] = []

    def getFqdn(self) -> str:
        """获取 FQDN"""
        return self._fqdn

    def getProviderFriendlyName(self) -> str:
        """获取提供商友好名称"""
        return self._provider_friendly_name

    def getRoamingConsortiumIds(self) -> List[int]:
        """获取漫游联盟 ID"""
        return self._roaming_consortium_ids.copy()

    def matchesFqdn(self, fqdn: str) -> bool:
        """检查是否匹配 FQDN"""
        return self._fqdn == fqdn

    def matchesRoamingConsortiumOis(self, ois: List[int]) -> bool:
        """检查是否匹配漫游联盟 OI"""
        return any(oi in self._roaming_consortium_ids for oi in ois)


# ═══════════════════════════════════════════════════════════════
# ProvisionCallback
# ═══════════════════════════════════════════════════════════════

class ProvisionCallback(Stub):
    """ProvisionCallback — 配置回调"""

    def __init__(self):
        super().__init__()

    def onProvisionFailure(self, failure_code: int) -> None:
        """配置失败回调"""
        pass

    def onProvisionSuccess(self) -> None:
        """配置成功回调"""
        pass

    def onProvisionAbort(self) -> None:
        """配置中止回调"""
        pass