"""
Android net.wifi.rtt 包 — RttManager, RangingRequest, RangingResult,
ResponderLocation, WifiRttManager
方法签名完全对齐 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__ = [
    "RttManager",
    "RangingResultCallback",
    "RangingRequest",
    "RangingResult",
    "ResponderLocation",
    "WifiRttManager",
]


# ═══════════════════════════════════════════════════════════════
# RangingResultCallback
# ═══════════════════════════════════════════════════════════════

class RangingResultCallback(Stub):
    """RangingResultCallback — 测距结果回调"""

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

    def onRangingResults(self, results: List["RangingResult"]) -> None:
        """测距结果回调"""
        pass

    def onRangingFailure(self, reason: int) -> None:
        """测距失败回调"""
        pass

    def onRangingAborted(self) -> None:
        """测距中止回调"""
        pass


# ═══════════════════════════════════════════════════════════════
# RangingRequest
# ═══════════════════════════════════════════════════════════════

class RangingRequest(Stub):
    """RangingRequest — 测距请求"""

    class Builder(Stub):
        """Builder — 测距请求构建器"""

        def __init__(self):
            super().__init__()
            self._access_points: List[Any] = []
            self._channel_width = 0
            self._preamble = 0

        def addAccessPoint(self, access_point: Any) -> "RangingRequest.Builder":
            """添加接入点"""
            self._access_points.append(access_point)
            return self

        def addAccessPoints(self, access_points: List[Any]) -> "RangingRequest.Builder":
            """添加多个接入点"""
            self._access_points.extend(access_points)
            return self

        def setChannelWidth(self, channel_width: int) -> "RangingRequest.Builder":
            """设置信道宽度"""
            self._channel_width = channel_width
            return self

        def setPreamble(self, preamble: int) -> "RangingRequest.Builder":
            """设置前导码"""
            self._preamble = preamble
            return self

        def build(self) -> "RangingRequest":
            """构建测距请求"""
            req = RangingRequest()
            req._access_points = self._access_points.copy()
            req._channel_width = self._channel_width
            req._preamble = self._preamble
            return req

    def __init__(self):
        super().__init__()
        self._access_points: List[Any] = []
        self._channel_width = 0
        self._preamble = 0


# ═══════════════════════════════════════════════════════════════
# RangingResult
# ═══════════════════════════════════════════════════════════════

class RangingResult(Stub):
    """RangingResult — 测距结果"""

    STATUS_SUCCESS = 0
    STATUS_FAIL = 1
    STATUS_RESPONDER_DOES_NOT_SUPPORT_IEEE80211MC = 2

    def __init__(self, mac_address: str = "00:00:00:00:00:00", status: int = STATUS_SUCCESS,
                 rssi: int = 0, distance_mm: int = 0, distance_std_dev_mm: int = 0,
                 timestamp: int = 0, num_attempted: int = 0, num_successful: int = 0,
                 is_80211mc: bool = False):
        super().__init__()
        self._mac_address = mac_address
        self._status = status
        self._rssi = rssi
        self._distance_mm = distance_mm
        self._distance_std_dev_mm = distance_std_dev_mm
        self._timestamp = timestamp
        self._num_attempted = num_attempted
        self._num_successful = num_successful
        self._is_80211mc = is_80211mc
        self._responder_location: Optional["ResponderLocation"] = None
        self._unconfirmed_location: Optional["ResponderLocation"] = None
        self._location_timestamp = 0

    def getMacAddress(self) -> str:
        """获取 MAC 地址"""
        return self._mac_address

    def getStatus(self) -> int:
        """获取状态"""
        return self._status

    def getRssi(self) -> int:
        """获取 RSSI"""
        return self._rssi

    def getDistanceMm(self) -> int:
        """获取距离（毫米）"""
        return self._distance_mm

    def getDistanceStdDevMm(self) -> int:
        """获取距离标准差（毫米）"""
        return self._distance_std_dev_mm

    def getTimestamp(self) -> int:
        """获取时间戳"""
        return self._timestamp

    def getNumAttemptedMeasurements(self) -> int:
        """获取尝试测量次数"""
        return self._num_attempted

    def getNumSuccessfulMeasurements(self) -> int:
        """获取成功测量次数"""
        return self._num_successful

    def is80211mcMeasurement(self) -> bool:
        """检查是否为 802.11mc 测量"""
        return self._is_80211mc

    def getResponderLocation(self) -> Optional["ResponderLocation"]:
        """获取响应者位置"""
        return self._responder_location

    def getUnconfirmedLocation(self) -> Optional["ResponderLocation"]:
        """获取未确认的位置"""
        return self._unconfirmed_location

    def getLocationTimestamp(self) -> int:
        """获取位置时间戳"""
        return self._location_timestamp


# ═══════════════════════════════════════════════════════════════
# ResponderLocation
# ═══════════════════════════════════════════════════════════════

class ResponderLocation(Stub):
    """ResponderLocation — 响应者位置"""

    def __init__(self):
        super().__init__()
        self._lci = False
        self._lcr = False
        self._latitude = 0.0
        self._longitude = 0.0
        self._altitude = 0.0
        self._floor_number = 0
        self._height_above_floor = 0.0
        self._height_floor = 0.0
        self._expected_to_move = False
        self._location_accuracy_micros = 0
        self._altitude_accuracy = 0.0

    def isLci(self) -> bool:
        """检查是否为 LCI"""
        return self._lci

    def isLcr(self) -> bool:
        """检查是否为 LCR"""
        return self._lcr

    def getLatitude(self) -> float:
        """获取纬度"""
        return self._latitude

    def getLongitude(self) -> float:
        """获取经度"""
        return self._longitude

    def getAltitude(self) -> float:
        """获取海拔"""
        return self._altitude

    def getFloorNumber(self) -> int:
        """获取楼层号"""
        return self._floor_number

    def getHeightAboveFloorMeters(self) -> float:
        """获取距离本层地面高度（米）"""
        return self._height_above_floor

    def getHeightFloorMeters(self) -> float:
        """获取本层高度（米）"""
        return self._height_floor

    def getExpectedToMove(self) -> bool:
        """检查是否预期移动"""
        return self._expected_to_move

    def getLocationAccuracyMicros(self) -> int:
        """获取位置精度（微秒）"""
        return self._location_accuracy_micros

    def getAltitudeAccuracy(self) -> float:
        """获取海拔精度"""
        return self._altitude_accuracy

    def toString(self) -> str:
        return f"ResponderLocation(lat={self._latitude}, lon={self._longitude})"


# ═══════════════════════════════════════════════════════════════
# RttManager (original/deprecated)
# ═══════════════════════════════════════════════════════════════

class RttManager(Stub):
    """RttManager — RTT 管理器（已废弃）(桌面存根)"""

    def __init__(self):
        super().__init__()
        self._callbacks: Dict[int, RangingResultCallback] = {}

    def startRanging(self, request: RangingRequest, callback: RangingResultCallback) -> None:
        """开始测距"""
        pass

    def stopRanging(self, request: RangingRequest) -> None:
        """停止测距"""
        pass

    def registerCallback(self, callback: RangingResultCallback) -> None:
        """注册回调"""
        callback_id = id(callback)
        self._callbacks[callback_id] = callback

    def unregisterCallback(self, callback: RangingResultCallback) -> None:
        """注销回调"""
        callback_id = id(callback)
        self._callbacks.pop(callback_id, None)


# ═══════════════════════════════════════════════════════════════
# WifiRttManager (newer replacement API)
# ═══════════════════════════════════════════════════════════════

class WifiRttManager(Stub):
    """WifiRttManager — Wi-Fi RTT 管理器 (桌面存根)"""

    def __init__(self, context: Any = None):
        super().__init__()
        self._context = context
        self._available = False
        self._results: List[RangingResult] = []

    def startRanging(self, request: RangingRequest, executor: Any,
                     callback: RangingResultCallback) -> None:
        """开始测距"""
        pass

    def cancelRanging(self, request: RangingRequest) -> None:
        """取消测距"""
        pass

    def registerRangingResultCallback(self, executor: Any,
                                       callback: RangingResultCallback) -> None:
        """注册测距结果回调"""
        pass

    def unregisterRangingResultCallback(self, callback: RangingResultCallback) -> None:
        """注销测距结果回调"""
        pass

    def isAvailable(self) -> bool:
        """检查 RTT 是否可用"""
        return self._available

    def setRangingResultCallback(self, callback: RangingResultCallback) -> None:
        """设置测距结果回调"""
        pass

    def getRangingResults(self) -> List[RangingResult]:
        """获取测距结果"""
        return self._results.copy()