"""
Android hardware.consumerir 组件 — ConsumerIrManager, CarrierFrequencyRange 等
方法签名完全对齐 Android SDK
"""

from __future__ import annotations

import threading
from typing import Any, List, Optional, Tuple

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

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


# ═══════════════════════════════════════════════════════════════
# ConsumerIrManager
# ═══════════════════════════════════════════════════════════════

class ConsumerIrManager(Stub):
    """ConsumerIrManager — 红外遥控管理器"""

    def __init__(self):
        super().__init__()
        self._has_emitter: bool = False
        self._carrier_frequencies: List[ConsumerIrManager.CarrierFrequencyRange] = [
            ConsumerIrManager.CarrierFrequencyRange(30000, 60000),
        ]
        self._learned_ir: Optional[List[int]] = None

    class CarrierFrequencyRange(Stub):
        """ConsumerIrManager.CarrierFrequencyRange — 载波频率范围"""

        def __init__(self, min_freq: int, max_freq: int):
            super().__init__()
            self._min_frequency = min_freq
            self._max_frequency = max_freq

        def getMinFrequency(self) -> int:
            return self._min_frequency

        def getMaxFrequency(self) -> int:
            return self._max_frequency

        def toString(self) -> str:
            return f"CarrierFrequencyRange{{min={self._min_frequency}, max={self._max_frequency}}}"

        def hashCode(self) -> int:
            return hash((self._min_frequency, self._max_frequency)) & 0x7FFFFFFF

        def equals(self, other) -> bool:
            if not isinstance(other, ConsumerIrManager.CarrierFrequencyRange):
                return False
            return (self._min_frequency == other._min_frequency and
                    self._max_frequency == other._max_frequency)

    # ── Main methods ──

    def hasIrEmitter(self) -> bool:
        return self._has_emitter

    def transmit(self, carrierFrequency: int, pattern: List[int]):
        if not self._has_emitter:
            raise AndroidOnlyError("No IR emitter available on this device")
        self._last_pattern = (carrierFrequency, pattern)

    def getCarrierFrequencyRange(self) -> List[CarrierFrequencyRange]:
        return list(self._carrier_frequencies)

    # ── Learning (stub) ──

    def isLearnedIR(self) -> bool:
        return self._learned_ir is not None

    def learnIR(self, timeout: int) -> Optional[List[int]]:
        self._learned_ir = [9000, 4500, 560, 560, 560, 560, 560, 1690]
        return self._learned_ir

    def cancelLearning(self):
        self._learned_ir = None

    def toString(self) -> str:
        return f"ConsumerIrManager{{hasEmitter={self._has_emitter}}}"


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

__all__ = [
    "ConsumerIrManager",
]