"""
Android net.wifi.aware 组件 — WifiAwareManager, WifiAwareSession, PublishConfig, SubscribeConfig 等
方法签名完全对齐 Android SDK
"""

from __future__ import annotations

import threading
import uuid
from typing import Any, Callable, Dict, List, Optional, Set

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

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


# ═══════════════════════════════════════════════════════════════
# Characteristics
# ═══════════════════════════════════════════════════════════════

class Characteristics(Stub):
    """Characteristics — Wi-Fi Aware 特性"""

    def __init__(self):
        super().__init__()
        self._max_service_name_length: int = 255
        self._max_service_specific_info_length: int = 255
        self._max_match_filter_length: int = 255
        self._max_number_of_publish_service_sessions: int = 10
        self._max_number_of_subscribe_service_sessions: int = 10
        self._max_message_length: int = 2048
        self._max_peers: int = 10

    def getMaxServiceNameLength(self) -> int:
        return self._max_service_name_length

    def getMaxServiceSpecificInfoLength(self) -> int:
        return self._max_service_specific_info_length

    def getMaxMatchFilterLength(self) -> int:
        return self._max_match_filter_length

    def getMaxNumberOfPublishServiceSessions(self) -> int:
        return self._max_number_of_publish_service_sessions

    def getMaxNumberOfSubscribeServiceSessions(self) -> int:
        return self._max_number_of_subscribe_service_sessions

    def getMaxMessageLength(self) -> int:
        return self._max_message_length

    def getMaxPeers(self) -> int:
        return self._max_peers

    def toString(self) -> str:
        return f"Characteristics@{hex(id(self))}"


# ═══════════════════════════════════════════════════════════════
# AttachCallback
# ═══════════════════════════════════════════════════════════════

class AttachCallback(Stub):
    """AttachCallback — 连接回调"""

    def onAttached(self, session: "WifiAwareSession"):
        pass

    def onAttachFailed(self):
        pass


# ═══════════════════════════════════════════════════════════════
# IdentityChangedListener
# ═══════════════════════════════════════════════════════════════

class IdentityChangedListener(Stub):
    """IdentityChangedListener — 身份变更监听器"""

    def onIdentityChanged(self, macAddress: bytes):
        pass


# ═══════════════════════════════════════════════════════════════
# DiscoverySessionCallback
# ═══════════════════════════════════════════════════════════════

class DiscoverySessionCallback(Stub):
    """DiscoverySessionCallback — 发现会话回调"""

    def onServiceDiscovered(self, peerHandle: Any, serviceSpecificInfo: bytes,
                            matchFilter: bytes):
        pass

    def onServiceDiscoveredWithinRange(self, peerHandle: Any,
                                       serviceSpecificInfo: bytes,
                                       matchFilter: bytes, rangeMm: int):
        pass

    def onMessageReceived(self, peerHandle: Any, message: bytes):
        pass

    def onMessageSendSucceeded(self, messageId: int):
        pass

    def onMessageSendFailed(self, messageId: int):
        pass

    def onSessionConfigUpdated(self):
        pass

    def onSessionConfigFailed(self):
        pass

    def onSessionTerminated(self):
        pass

    def onMatch(self, peerHandle: Any, serviceSpecificInfo: bytes,
                matchFilter: bytes, rangeMm: int):
        pass


# ═══════════════════════════════════════════════════════════════
# PublishConfig
# ═══════════════════════════════════════════════════════════════

class PublishConfig(Stub):
    """PublishConfig — 发布配置"""

    PUBLISH_TYPE_UNSOLICITED = 0
    PUBLISH_TYPE_SOLICITED = 1

    def __init__(self, service_name: str = "", service_specific_info: bytes = b"",
                 match_filter: bytes = b"", terminate_notification_enabled: bool = True,
                 ranging_enabled: bool = False, publish_type: int = PUBLISH_TYPE_UNSOLICITED):
        super().__init__()
        self._service_name = service_name
        self._service_specific_info = service_specific_info
        self._match_filter = match_filter
        self._terminate_notification_enabled = terminate_notification_enabled
        self._ranging_enabled = ranging_enabled
        self._publish_type = publish_type

    class Builder(Stub):
        """PublishConfig.Builder — 构建器"""

        def __init__(self):
            super().__init__()
            self._service_name: str = ""
            self._service_specific_info: bytes = b""
            self._match_filter: bytes = b""
            self._terminate_notification_enabled: bool = True
            self._ranging_enabled: bool = False
            self._publish_type: int = PublishConfig.PUBLISH_TYPE_UNSOLICITED

        def setServiceName(self, serviceName: str) -> "PublishConfig.Builder":
            self._service_name = serviceName
            return self

        def setServiceSpecificInfo(self, info: bytes) -> "PublishConfig.Builder":
            self._service_specific_info = info
            return self

        def setMatchFilter(self, matchFilter: bytes) -> "PublishConfig.Builder":
            self._match_filter = matchFilter
            return self

        def setTerminateNotificationEnabled(self, enabled: bool) -> "PublishConfig.Builder":
            self._terminate_notification_enabled = enabled
            return self

        def setRangingEnabled(self, enabled: bool) -> "PublishConfig.Builder":
            self._ranging_enabled = enabled
            return self

        def setPublishType(self, publishType: int) -> "PublishConfig.Builder":
            self._publish_type = publishType
            return self

        def build(self) -> "PublishConfig":
            return PublishConfig(
                self._service_name, self._service_specific_info,
                self._match_filter, self._terminate_notification_enabled,
                self._ranging_enabled, self._publish_type,
            )

    def toString(self) -> str:
        return f"PublishConfig{{service={self._service_name}, type={self._publish_type}}}"


# ═══════════════════════════════════════════════════════════════
# SubscribeConfig
# ═══════════════════════════════════════════════════════════════

class SubscribeConfig(Stub):
    """SubscribeConfig — 订阅配置"""

    SUBSCRIBE_TYPE_PASSIVE = 0
    SUBSCRIBE_TYPE_ACTIVE = 1

    def __init__(self, service_name: str = "", service_specific_info: bytes = b"",
                 match_filter: bytes = b"", terminate_notification_enabled: bool = True,
                 ranging_enabled: bool = False, subscribe_type: int = SUBSCRIBE_TYPE_PASSIVE):
        super().__init__()
        self._service_name = service_name
        self._service_specific_info = service_specific_info
        self._match_filter = match_filter
        self._terminate_notification_enabled = terminate_notification_enabled
        self._ranging_enabled = ranging_enabled
        self._subscribe_type = subscribe_type

    class Builder(Stub):
        """SubscribeConfig.Builder — 构建器"""

        def __init__(self):
            super().__init__()
            self._service_name: str = ""
            self._service_specific_info: bytes = b""
            self._match_filter: bytes = b""
            self._terminate_notification_enabled: bool = True
            self._ranging_enabled: bool = False
            self._subscribe_type: int = SubscribeConfig.SUBSCRIBE_TYPE_PASSIVE

        def setServiceName(self, serviceName: str) -> "SubscribeConfig.Builder":
            self._service_name = serviceName
            return self

        def setServiceSpecificInfo(self, info: bytes) -> "SubscribeConfig.Builder":
            self._service_specific_info = info
            return self

        def setMatchFilter(self, matchFilter: bytes) -> "SubscribeConfig.Builder":
            self._match_filter = matchFilter
            return self

        def setTerminateNotificationEnabled(self, enabled: bool) -> "SubscribeConfig.Builder":
            self._terminate_notification_enabled = enabled
            return self

        def setRangingEnabled(self, enabled: bool) -> "SubscribeConfig.Builder":
            self._ranging_enabled = enabled
            return self

        def setSubscribeType(self, subscribeType: int) -> "SubscribeConfig.Builder":
            self._subscribe_type = subscribeType
            return self

        def build(self) -> "SubscribeConfig":
            return SubscribeConfig(
                self._service_name, self._service_specific_info,
                self._match_filter, self._terminate_notification_enabled,
                self._ranging_enabled, self._subscribe_type,
            )

    def toString(self) -> str:
        return f"SubscribeConfig{{service={self._service_name}, type={self._subscribe_type}}}"


# ═══════════════════════════════════════════════════════════════
# DiscoverySession
# ═══════════════════════════════════════════════════════════════

class DiscoverySession(Stub):
    """DiscoverySession — 发现会话基类"""

    def __init__(self, service_name: str = ""):
        super().__init__()
        self._service_name = service_name
        self._terminate_notification_enabled: bool = True
        self._open: bool = True

    def sendMessage(self, peerHandle: Any, message: bytes, messageId: int):
        pass

    def close(self):
        self._open = False

    def setTerminateNotificationEnabled(self, enabled: bool):
        self._terminate_notification_enabled = enabled

    def toString(self) -> str:
        return f"DiscoverySession{{service={self._service_name}}}"


# ═══════════════════════════════════════════════════════════════
# PublishDiscoverySession
# ═══════════════════════════════════════════════════════════════

class PublishDiscoverySession(DiscoverySession):
    """PublishDiscoverySession — 发布发现会话"""

    def __init__(self, service_name: str = ""):
        super().__init__(service_name)

    def updatePublishConfig(self, publishConfig: PublishConfig):
        pass

    def toString(self) -> str:
        return f"PublishDiscoverySession{{service={self._service_name}}}"


# ═══════════════════════════════════════════════════════════════
# SubscribeDiscoverySession
# ═══════════════════════════════════════════════════════════════

class SubscribeDiscoverySession(DiscoverySession):
    """SubscribeDiscoverySession — 订阅发现会话"""

    def __init__(self, service_name: str = ""):
        super().__init__(service_name)

    def updateSubscribeConfig(self, subscribeConfig: SubscribeConfig):
        pass

    def toString(self) -> str:
        return f"SubscribeDiscoverySession{{service={self._service_name}}}"


# ═══════════════════════════════════════════════════════════════
# WifiAwareSession
# ═══════════════════════════════════════════════════════════════

class WifiAwareSession(Stub):
    """WifiAwareSession — Wi-Fi Aware 会话"""

    def __init__(self):
        super().__init__()
        self._open: bool = True
        self._publish_sessions: List[PublishDiscoverySession] = []
        self._subscribe_sessions: List[SubscribeDiscoverySession] = []

    def publish(self, publishConfig: PublishConfig,
                callback: DiscoverySessionCallback,
                handler: Any = None) -> PublishDiscoverySession:
        session = PublishDiscoverySession(publishConfig._service_name)
        self._publish_sessions.append(session)
        return session

    def subscribe(self, subscribeConfig: SubscribeConfig,
                  callback: DiscoverySessionCallback,
                  handler: Any = None) -> SubscribeDiscoverySession:
        session = SubscribeDiscoverySession(subscribeConfig._service_name)
        self._subscribe_sessions.append(session)
        return session

    def createNetworkSpecifier(self, role: int, service_name: str,
                               pmk: Optional[bytes] = None,
                               passphrase: Optional[str] = None) -> Any:
        return None

    def createNetworkSpecifier(self, role: int, service_name: str,
                               peer_handle: Any,
                               pmk: Optional[bytes] = None,
                               passphrase: Optional[str] = None) -> Any:
        return None

    def sendMessage(self, peerHandle: Any, message: bytes, messageId: int):
        pass

    def close(self):
        self._open = False

    def toString(self) -> str:
        return f"WifiAwareSession@{hex(id(self))}"


# ═══════════════════════════════════════════════════════════════
# WifiAwareManager
# ═══════════════════════════════════════════════════════════════

class WifiAwareManager(Stub):
    """WifiAwareManager — Wi-Fi Aware 管理器"""

    WIFI_AWARE_DATA_PATH_ROLE_INITIATOR = 0
    WIFI_AWARE_DATA_PATH_ROLE_RESPONDER = 1
    ACTION_WIFI_AWARE_STATE_CHANGED = "android.net.wifi.aware.action.WIFI_AWARE_STATE_CHANGED"

    def __init__(self):
        super().__init__()
        self._available: bool = True
        self._sessions: List[WifiAwareSession] = []

    # ── Attach ──

    def attach(self, callback: AttachCallback, handler: Any = None) -> None:
        session = WifiAwareSession()
        self._sessions.append(session)
        callback.onAttached(session)

    def attach(self, attachCallback: AttachCallback,
               identityChangedListener: IdentityChangedListener,
               handler: Any = None) -> None:
        session = WifiAwareSession()
        self._sessions.append(session)
        attachCallback.onAttached(session)

    # ── Characteristics ──

    def getCharacteristics(self) -> Characteristics:
        return Characteristics()

    # ── Available ──

    def isAvailable(self) -> bool:
        return self._available

    def toString(self) -> str:
        return f"WifiAwareManager{{available={self._available}}}"


# ═══════════════════════════════════════════════════════════════
# __all__
# ═══════════════════════════════════════════════════════════════

__all__ = [
    "WifiAwareManager",
    "WifiAwareSession",
    "PublishConfig",
    "SubscribeConfig",
    "DiscoverySession",
    "PublishDiscoverySession",
    "SubscribeDiscoverySession",
    "DiscoverySessionCallback",
    "Characteristics",
    "AttachCallback",
    "IdentityChangedListener",
]