"""
Android Telephony CDMA 组件 — CdmaCellLocation, SignalStrength (CDMA)
方法签名完全对齐 Android SDK (android.telephony.cdma 包)
"""

from __future__ import annotations

import time
from typing import Any, Callable, Dict, List, Optional, Set, Tuple

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


# ═══════════════════════════════════════════════════════════════
# CdmaCellLocation
# ═══════════════════════════════════════════════════════════════

class CdmaCellLocation(Stub):
    """CdmaCellLocation — CDMA 小区位置"""

    INVALID = -1

    def __init__(self):
        super().__init__()
        self._base_station_id: int = CdmaCellLocation.INVALID
        self._base_station_latitude: int = CdmaCellLocation.INVALID
        self._base_station_longitude: int = CdmaCellLocation.INVALID
        self._system_id: int = CdmaCellLocation.INVALID
        self._network_id: int = CdmaCellLocation.INVALID
        self._pseudo_network_id: int = CdmaCellLocation.INVALID
        self._pseudo_base_station_id: int = CdmaCellLocation.INVALID
        self._lac: int = CdmaCellLocation.INVALID
        self._cid: int = CdmaCellLocation.INVALID

    def getBaseStationId(self) -> int:
        return self._base_station_id

    def setBaseStationId(self, bsid: int):
        self._base_station_id = bsid

    def getBaseStationLatitude(self) -> int:
        return self._base_station_latitude

    def setBaseStationLatitude(self, latitude: int):
        self._base_station_latitude = latitude

    def getBaseStationLongitude(self) -> int:
        return self._base_station_longitude

    def setBaseStationLongitude(self, longitude: int):
        self._base_station_longitude = longitude

    def getSystemId(self) -> int:
        return self._system_id

    def setSystemId(self, sid: int):
        self._system_id = sid

    def getNetworkId(self) -> int:
        return self._network_id

    def setNetworkId(self, nid: int):
        self._network_id = nid

    def getLac(self) -> int:
        """获取位置区码 (仅 1xRTT)"""
        return self._lac

    def setLac(self, lac: int):
        self._lac = lac

    def getCid(self) -> int:
        """获取小区 ID (仅 1xRTT)"""
        return self._cid

    def setCid(self, cid: int):
        self._cid = cid

    def isEmpty(self) -> bool:
        """检查位置是否为空"""
        return (self._base_station_id == CdmaCellLocation.INVALID
                and self._base_station_latitude == CdmaCellLocation.INVALID
                and self._base_station_longitude == CdmaCellLocation.INVALID
                and self._system_id == CdmaCellLocation.INVALID
                and self._network_id == CdmaCellLocation.INVALID)

    def equals(self, other: Any) -> bool:
        if isinstance(other, CdmaCellLocation):
            return (self._base_station_id == other._base_station_id
                    and self._base_station_latitude == other._base_station_latitude
                    and self._base_station_longitude == other._base_station_longitude
                    and self._system_id == other._system_id
                    and self._network_id == other._network_id)
        return False

    def hashCode(self) -> int:
        return hash((self._base_station_id, self._base_station_latitude,
                      self._base_station_longitude, self._system_id,
                      self._network_id)) & 0x7FFFFFFF

    def fillInNotifierBundle(self, bundle: Any):
        """填充通知包"""
        if bundle is not None:
            bundle.putInt("base_station_id", self._base_station_id)
            bundle.putInt("base_station_latitude", self._base_station_latitude)
            bundle.putInt("base_station_longitude", self._base_station_longitude)
            bundle.putInt("system_id", self._system_id)
            bundle.putInt("network_id", self._network_id)

    def toString(self) -> str:
        return f"CdmaCellLocation(bsid={self._base_station_id}, sid={self._system_id}, nid={self._network_id})"


# ═══════════════════════════════════════════════════════════════
# SignalStrength — CDMA
# ═══════════════════════════════════════════════════════════════

class SignalStrength(Stub):
    """SignalStrength — CDMA 信号强度"""

    SIGNAL_STRENGTH_NONE_OR_UNKNOWN = 0
    SIGNAL_STRENGTH_POOR = 1
    SIGNAL_STRENGTH_MODERATE = 2
    SIGNAL_STRENGTH_GOOD = 3
    SIGNAL_STRENGTH_GREAT = 4

    INVALID = -1
    MAX_DBM = -25
    MIN_DBM = -120

    CDMA_RSSI_MAX = -75
    CDMA_RSSI_MIN = -120
    CDMA_ECIO_MAX = 0
    CDMA_ECIO_MIN = -30
    EVDO_DBM_MAX = -60
    EVDO_DBM_MIN = -120
    EVDO_ECIO_MAX = 0
    EVDO_ECIO_MIN = -20
    EVDO_SNR_MAX = 10
    EVDO_SNR_MIN = 0

    def __init__(self, cdma_dbm: int = 0, cdma_ecio: int = 0,
                 evdo_dbm: int = 0, evdo_ecio: int = 0, evdo_snr: int = 0):
        super().__init__()
        self._cdma_dbm = cdma_dbm
        self._cdma_ecio = cdma_ecio
        self._evdo_dbm = evdo_dbm
        self._evdo_ecio = evdo_ecio
        self._evdo_snr = evdo_snr
        self._is_gsm: bool = False
        self._lte_rssi: int = 0
        self._lte_rsrp: int = 0
        self._lte_rsrq: int = 0
        self._lte_rssnr: int = 0
        self._td_scdma_rscp: int = 0
        self._wcdma_rscp: int = 0
        self._wcdma_ecno: int = 0

    def getCdmaDbm(self) -> int:
        """获取 CDMA dBm"""
        return self._cdma_dbm

    def setCdmaDbm(self, dbm: int):
        self._cdma_dbm = dbm

    def getCdmaEcio(self) -> int:
        """获取 CDMA Ec/Io (0.5 dB 单位)"""
        return self._cdma_ecio

    def setCdmaEcio(self, ecio: int):
        self._cdma_ecio = ecio

    def getEvdoDbm(self) -> int:
        """获取 EVDO dBm"""
        return self._evdo_dbm

    def setEvdoDbm(self, dbm: int):
        self._evdo_dbm = dbm

    def getEvdoEcio(self) -> int:
        """获取 EVDO Ec/Io (0.5 dB 单位)"""
        return self._evdo_ecio

    def setEvdoEcio(self, ecio: int):
        self._evdo_ecio = ecio

    def getEvdoSnr(self) -> int:
        """获取 EVDO SNR"""
        return self._evdo_snr

    def setEvdoSnr(self, snr: int):
        self._evdo_snr = snr

    def getDbm(self) -> int:
        """获取整体 dBm"""
        if self._evdo_dbm > 0:
            return self._evdo_dbm
        return self._cdma_dbm

    def getLevel(self) -> int:
        """获取信号等级 (0-4)"""
        dbm = self.getDbm()
        if dbm >= -85:
            return SignalStrength.SIGNAL_STRENGTH_GREAT
        elif dbm >= -95:
            return SignalStrength.SIGNAL_STRENGTH_GOOD
        elif dbm >= -105:
            return SignalStrength.SIGNAL_STRENGTH_MODERATE
        elif dbm >= -115:
            return SignalStrength.SIGNAL_STRENGTH_POOR
        else:
            return SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN

    def getAsuLevel(self) -> int:
        """获取 ASU 等级"""
        dbm = self.getDbm()
        if dbm <= -120:
            return 0
        if dbm >= -25:
            return 96
        return int((dbm + 120) * (96.0 / 95.0))

    def getEvdoLevel(self) -> int:
        """获取 EVDO 等级"""
        evdo_dbm = self._evdo_dbm
        if evdo_dbm >= -65:
            return SignalStrength.SIGNAL_STRENGTH_GREAT
        elif evdo_dbm >= -75:
            return SignalStrength.SIGNAL_STRENGTH_GOOD
        elif evdo_dbm >= -90:
            return SignalStrength.SIGNAL_STRENGTH_MODERATE
        elif evdo_dbm >= -105:
            return SignalStrength.SIGNAL_STRENGTH_POOR
        else:
            return SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN

    def getCdmaLevel(self) -> int:
        """获取 CDMA 等级"""
        cdma_dbm = self._cdma_dbm
        if cdma_dbm >= -75:
            return SignalStrength.SIGNAL_STRENGTH_GREAT
        elif cdma_dbm >= -85:
            return SignalStrength.SIGNAL_STRENGTH_GOOD
        elif cdma_dbm >= -95:
            return SignalStrength.SIGNAL_STRENGTH_MODERATE
        elif cdma_dbm >= -105:
            return SignalStrength.SIGNAL_STRENGTH_POOR
        else:
            return SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN

    def isGsm(self) -> bool:
        return self._is_gsm

    def setGsm(self, gsm: bool):
        self._is_gsm = gsm

    def getCdmaRssi(self) -> int:
        """获取 CDMA RSSI (dBm)"""
        return self._cdma_dbm

    def getCdmaEcioDb(self) -> float:
        """获取 CDMA Ec/Io (dB)"""
        return self._cdma_ecio / 2.0

    def getEvdoEcioDb(self) -> float:
        """获取 EVDO Ec/Io (dB)"""
        return self._evdo_ecio / 2.0

    def isValid(self) -> bool:
        """检查是否有效"""
        return self._cdma_dbm > SignalStrength.INVALID

    def toString(self) -> str:
        return f"CDMA_SignalStrength(cdmaDbm={self._cdma_dbm}, evdoDbm={self._evdo_dbm})"


# ═══════════════════════════════════════════════════════════════
# CDMA SMS
# ═══════════════════════════════════════════════════════════════

class CdmaSmsMessage(Stub):
    """CdmaSmsMessage — CDMA 短信"""

    ENCODING_7BIT_ASCII = 2
    ENCODING_UNICODE = 4
    ENCODING_SHIFT_JIS = 5
    ENCODING_KOREAN = 6
    ENCODING_LATIN = 8
    ENCODING_LATIN_HEBREW = 9
    ENCODING_GSM_7BIT = 10
    ENCODING_GSM_DCS = 11

    PRIORITY_NORMAL = 0
    PRIORITY_INTERACTIVE = 1
    PRIORITY_URGENT = 2
    PRIORITY_EMERGENCY = 3

    PRIVACY_NORMAL = 0
    PRIVACY_RESTRICTED = 1
    PRIVACY_CONFIDENTIAL = 2
    PRIVACY_SECRET = 3

    def __init__(self):
        super().__init__()
        self._message_body: str = ""
        self._originating_address: str = ""
        self._destination_address: str = ""
        self._encoding: int = CdmaSmsMessage.ENCODING_7BIT_ASCII
        self._priority: int = CdmaSmsMessage.PRIORITY_NORMAL
        self._privacy: int = CdmaSmsMessage.PRIVACY_NORMAL
        self._timestamp: int = 0
        self._bearer_data: bytes = b""
        self._service_category: int = 0
        self._language: str = ""
        self._is_urgent: bool = False

    def getMessageBody(self) -> str:
        return self._message_body

    def setMessageBody(self, body: str):
        self._message_body = body

    def getOriginatingAddress(self) -> str:
        return self._originating_address

    def setOriginatingAddress(self, addr: str):
        self._originating_address = addr

    def getDestinationAddress(self) -> str:
        return self._destination_address

    def setDestinationAddress(self, addr: str):
        self._destination_address = addr

    def getEncoding(self) -> int:
        return self._encoding

    def setEncoding(self, encoding: int):
        self._encoding = encoding

    def getPriority(self) -> int:
        return self._priority

    def setPriority(self, priority: int):
        self._priority = priority

    def getPrivacy(self) -> int:
        return self._privacy

    def setPrivacy(self, privacy: int):
        self._privacy = privacy

    def getTimestamp(self) -> int:
        return self._timestamp

    def setTimestamp(self, ts: int):
        self._timestamp = ts

    def getBearerData(self) -> bytes:
        return self._bearer_data

    def setBearerData(self, data: bytes):
        self._bearer_data = data

    def toString(self) -> str:
        return f"CdmaSmsMessage(from={self._originating_address}, body={self._message_body[:20]})"


# ═══════════════════════════════════════════════════════════════
# CDMA 网络常量
# ═══════════════════════════════════════════════════════════════

class CdmaNetworkType(Stub):
    """CdmaNetworkType — CDMA 网络类型常量"""

    NETWORK_TYPE_CDMA = 4
    NETWORK_TYPE_EVDO_0 = 5
    NETWORK_TYPE_EVDO_A = 6
    NETWORK_TYPE_1xRTT = 7
    NETWORK_TYPE_EVDO_B = 12
    NETWORK_TYPE_EHRPD = 14

    @staticmethod
    def isCdma(network_type: int) -> bool:
        return network_type in (CdmaNetworkType.NETWORK_TYPE_CDMA,
                                 CdmaNetworkType.NETWORK_TYPE_EVDO_0,
                                 CdmaNetworkType.NETWORK_TYPE_EVDO_A,
                                 CdmaNetworkType.NETWORK_TYPE_1xRTT,
                                 CdmaNetworkType.NETWORK_TYPE_EVDO_B,
                                 CdmaNetworkType.NETWORK_TYPE_EHRPD)

    @staticmethod
    def toString(network_type: int) -> str:
        names = {
            CdmaNetworkType.NETWORK_TYPE_CDMA: "CDMA",
            CdmaNetworkType.NETWORK_TYPE_EVDO_0: "EVDO rev.0",
            CdmaNetworkType.NETWORK_TYPE_EVDO_A: "EVDO rev.A",
            CdmaNetworkType.NETWORK_TYPE_1xRTT: "1xRTT",
            CdmaNetworkType.NETWORK_TYPE_EVDO_B: "EVDO rev.B",
            CdmaNetworkType.NETWORK_TYPE_EHRPD: "eHRPD",
        }
        return names.get(network_type, f"UNKNOWN({network_type})")

    @staticmethod
    def getRatName(network_type: int) -> str:
        return CdmaNetworkType.toString(network_type)


# ═══════════════════════════════════════════════════════════════
# CDMA 补充业务
# ═══════════════════════════════════════════════════════════════

class CdmaServiceState(Stub):
    """CdmaServiceState — CDMA 服务状态"""

    STATE_IN_SERVICE = 0
    STATE_OUT_OF_SERVICE = 1
    STATE_EMERGENCY_ONLY = 2
    STATE_POWER_OFF = 3

    def __init__(self):
        super().__init__()
        self._state: int = CdmaServiceState.STATE_OUT_OF_SERVICE
        self._is_roaming: bool = False
        self._cdma_default_roaming_indicator: int = -1
        self._cdma_eri_icon_index: int = -1
        self._cdma_eri_icon_mode: int = -1
        self._cdma_roaming_indicator: int = -1
        self._system_id: int = -1
        self._network_id: int = -1
        self._base_station_id: int = -1
        self._base_station_latitude: int = -1
        self._base_station_longitude: int = -1
        self._operator_alpha_long: str = ""
        self._operator_alpha_short: str = ""
        self._operator_numeric: str = ""
        self._is_manual_selection: bool = False

    def getState(self) -> int:
        return self._state

    def setState(self, state: int):
        self._state = state

    def getRoaming(self) -> bool:
        return self._is_roaming

    def setRoaming(self, roaming: bool):
        self._is_roaming = roaming

    def getCdmaDefaultRoamingIndicator(self) -> int:
        return self._cdma_default_roaming_indicator

    def setCdmaDefaultRoamingIndicator(self, indicator: int):
        self._cdma_default_roaming_indicator = indicator

    def getCdmaEriIconIndex(self) -> int:
        return self._cdma_eri_icon_index

    def setCdmaEriIconIndex(self, index: int):
        self._cdma_eri_icon_index = index

    def getCdmaEriIconMode(self) -> int:
        return self._cdma_eri_icon_mode

    def setCdmaEriIconMode(self, mode: int):
        self._cdma_eri_icon_mode = mode

    def getCdmaRoamingIndicator(self) -> int:
        return self._cdma_roaming_indicator

    def setCdmaRoamingIndicator(self, indicator: int):
        self._cdma_roaming_indicator = indicator

    def getSystemId(self) -> int:
        return self._system_id

    def setSystemId(self, sid: int):
        self._system_id = sid

    def getNetworkId(self) -> int:
        return self._network_id

    def setNetworkId(self, nid: int):
        self._network_id = nid

    def getOperatorAlphaLong(self) -> str:
        return self._operator_alpha_long

    def setOperatorAlphaLong(self, op: str):
        self._operator_alpha_long = op

    def getOperatorAlphaShort(self) -> str:
        return self._operator_alpha_short

    def setOperatorAlphaShort(self, op: str):
        self._operator_alpha_short = op

    def getOperatorNumeric(self) -> str:
        return self._operator_numeric

    def setOperatorNumeric(self, op: str):
        self._operator_numeric = op

    def toString(self) -> str:
        return f"CdmaServiceState(state={self._state}, roaming={self._is_roaming})"


# ═══════════════════════════════════════════════════════════════
# CDMA ERI (Enhanced Roaming Indicator)
# ═══════════════════════════════════════════════════════════════

class CdmaEriInfo(Stub):
    """CdmaEriInfo — CDMA ERI 信息"""

    ERI_ON = 0
    ERI_OFF = 1
    ERI_FLASH = 2

    ROAMING_INDICATOR_NOT_ROAMING = 0
    ROAMING_INDICATOR_ROAMING = 1
    ROAMING_INDICATOR_SAMPLING = 2
    ROAMING_INDICATOR_AFFILIATED = 3
    ROAMING_INDICATOR_NOT_AFFILIATED = 4
    ROAMING_INDICATOR_FLASH = 5

    def __init__(self):
        super().__init__()
        self._icon_index: int = -1
        self._icon_mode: int = CdmaEriInfo.ERI_OFF
        self._roaming_indicator: int = CdmaEriInfo.ROAMING_INDICATOR_NOT_ROAMING
        self._eri_text: str = ""
        self._alert_show: bool = False
        self._call_guard: bool = False

    def getIconIndex(self) -> int:
        return self._icon_index

    def setIconIndex(self, index: int):
        self._icon_index = index

    def getIconMode(self) -> int:
        return self._icon_mode

    def setIconMode(self, mode: int):
        self._icon_mode = mode

    def getRoamingIndicator(self) -> int:
        return self._roaming_indicator

    def setRoamingIndicator(self, indicator: int):
        self._roaming_indicator = indicator

    def getEriText(self) -> str:
        return self._eri_text

    def setEriText(self, text: str):
        self._eri_text = text

    def isAlertShow(self) -> bool:
        return self._alert_show

    def setAlertShow(self, show: bool):
        self._alert_show = show

    def isCallGuard(self) -> bool:
        return self._call_guard

    def setCallGuard(self, guard: bool):
        self._call_guard = guard

    def isRoaming(self) -> bool:
        return self._roaming_indicator != CdmaEriInfo.ROAMING_INDICATOR_NOT_ROAMING

    def toString(self) -> str:
        return f"CdmaEriInfo(icon={self._icon_index}, roaming={self._roaming_indicator})"


# ═══════════════════════════════════════════════════════════════
# CDMA 语音/数据状态
# ═══════════════════════════════════════════════════════════════

class CdmaCallState(Stub):
    """CdmaCallState — CDMA 通话状态"""

    CALL_STATE_IDLE = 0
    CALL_STATE_ACTIVE = 1
    CALL_STATE_ALERTING = 2
    CALL_STATE_DIALING = 3
    CALL_STATE_INCOMING = 4
    CALL_STATE_HOLDING = 5
    CALL_STATE_DISCONNECTING = 6
    CALL_STATE_DISCONNECTED = 7
    CALL_STATE_CONFERENCE = 8

    CALL_TYPE_VOICE = 0
    CALL_TYPE_DATA = 1
    CALL_TYPE_FAX = 2
    CALL_TYPE_UNKNOWN = 3

    @staticmethod
    def toString(state: int) -> str:
        names = {
            CdmaCallState.CALL_STATE_IDLE: "IDLE",
            CdmaCallState.CALL_STATE_ACTIVE: "ACTIVE",
            CdmaCallState.CALL_STATE_ALERTING: "ALERTING",
            CdmaCallState.CALL_STATE_DIALING: "DIALING",
            CdmaCallState.CALL_STATE_INCOMING: "INCOMING",
            CdmaCallState.CALL_STATE_DISCONNECTED: "DISCONNECTED",
        }
        return names.get(state, f"UNKNOWN({state})")


# ═══════════════════════════════════════════════════════════════
# CDMA Data Connection
# ═══════════════════════════════════════════════════════════════

class CdmaDataConnectionState(Stub):
    """CdmaDataConnectionState — CDMA 数据连接状态"""

    DATA_STATE_DISCONNECTED = 0
    DATA_STATE_CONNECTING = 1
    DATA_STATE_CONNECTED = 2
    DATA_STATE_SUSPENDED = 3
    DATA_STATE_DORMANT = 4
    DATA_STATE_AUTHENTICATING = 5

    DATA_ACTIVITY_NONE = 0
    DATA_ACTIVITY_IN = 1
    DATA_ACTIVITY_OUT = 2
    DATA_ACTIVITY_INOUT = 3
    DATA_ACTIVITY_DORMANT = 4

    @staticmethod
    def toString(state: int) -> str:
        names = {
            CdmaDataConnectionState.DATA_STATE_DISCONNECTED: "DISCONNECTED",
            CdmaDataConnectionState.DATA_STATE_CONNECTING: "CONNECTING",
            CdmaDataConnectionState.DATA_STATE_CONNECTED: "CONNECTED",
            CdmaDataConnectionState.DATA_STATE_SUSPENDED: "SUSPENDED",
            CdmaDataConnectionState.DATA_STATE_DORMANT: "DORMANT",
        }
        return names.get(state, f"UNKNOWN({state})")

    @staticmethod
    def dataActivityToString(activity: int) -> str:
        names = {
            CdmaDataConnectionState.DATA_ACTIVITY_NONE: "NONE",
            CdmaDataConnectionState.DATA_ACTIVITY_IN: "IN",
            CdmaDataConnectionState.DATA_ACTIVITY_OUT: "OUT",
            CdmaDataConnectionState.DATA_ACTIVITY_INOUT: "INOUT",
            CdmaDataConnectionState.DATA_ACTIVITY_DORMANT: "DORMANT",
        }
        return names.get(activity, f"UNKNOWN({activity})")


# ═══════════════════════════════════════════════════════════════
# CDMA 网络注册
# ═══════════════════════════════════════════════════════════════

class CdmaRegistrationState(Stub):
    """CdmaRegistrationState — CDMA 注册状态"""

    REG_STATE_NOT_REGISTERED = 0
    REG_STATE_REGISTERED = 1
    REG_STATE_REGISTERING = 2
    REG_STATE_DENIED = 3
    REG_STATE_UNKNOWN = 4
    REG_STATE_ROAMING = 5
    REG_STATE_HOME = 6

    def __init__(self, state: int = REG_STATE_UNKNOWN):
        super().__init__()
        self._state = state
        self._system_id: int = -1
        self._network_id: int = -1
        self._base_id: int = -1
        self._zone_id: int = -1

    def getState(self) -> int:
        return self._state

    def setState(self, state: int):
        self._state = state

    def getSystemId(self) -> int:
        return self._system_id

    def setSystemId(self, sid: int):
        self._system_id = sid

    def getNetworkId(self) -> int:
        return self._network_id

    def setNetworkId(self, nid: int):
        self._network_id = nid

    def getBaseId(self) -> int:
        return self._base_id

    def setBaseId(self, base_id: int):
        self._base_id = base_id

    def isRegistered(self) -> bool:
        return self._state in (CdmaRegistrationState.REG_STATE_REGISTERED,
                                CdmaRegistrationState.REG_STATE_HOME,
                                CdmaRegistrationState.REG_STATE_ROAMING)

    def isRoaming(self) -> bool:
        return self._state == CdmaRegistrationState.REG_STATE_ROAMING

    def toString(self) -> str:
        return f"CdmaRegistrationState(state={self._state})"