"""通过 ADB 查询当前电脑已经识别的 Android 设备。"""

from dataclasses import dataclass
import ipaddress
import subprocess
import time
from pathlib import Path
from typing import Callable, List, Optional, Sequence

from .adb_runtime import (
    BundledAdbError,
    bundled_adb_path,
    validate_bundled_adb,
)


DEFAULT_ADB_TIMEOUT_SECONDS = 5.0
DEFAULT_DEVICE_READY_CHECKS = 8
DEFAULT_DEVICE_READY_INTERVAL_SECONDS = 0.25
PDD_PACKAGE_NAME = "com.xunmeng.pinduoduo"


class AndroidDeviceSearchError(RuntimeError):
    """ADB 无法完成设备搜索时抛出的可读错误。"""


class AndroidDeviceConversionCancelled(RuntimeError):
    """页面关闭后停止 USB 转 Wi-Fi 的后续步骤。"""


@dataclass(frozen=True)
class AndroidDevice:
    """一台由 ``adb devices -l`` 返回的设备。"""

    serial: str
    connection_type: str
    model: str = "—"
    android_version: str = "—"
    status: str = "device"


@dataclass(frozen=True)
class AndroidWifiConversionResult:
    """USB 转 Wi-Fi 成功后的目标设备号和最新设备列表。"""

    wifi_serial: str
    devices: List[AndroidDevice]


@dataclass(frozen=True)
class AndroidDeviceSearchResult:
    """一次设备搜索的结果，可同时携带已保存设备恢复警告。"""

    devices: List[AndroidDevice]
    restore_warning: str = ""


CommandRunner = Callable[[Sequence[str], float], subprocess.CompletedProcess]
ProgressCallback = Callable[[str], None]
Sleeper = Callable[[float], None]


def run_adb_command(
    command: Sequence[str], timeout_seconds: float
) -> subprocess.CompletedProcess:
    """执行一条隐藏窗口的 ADB 命令，返回标准输出和错误输出。"""

    return subprocess.run(
        list(command),
        capture_output=True,
        text=True,
        encoding="utf-8",
        errors="replace",
        timeout=timeout_seconds,
        check=False,
        creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
    )


class AndroidDeviceService:
    """查询 ADB 设备列表；本类不依赖 Qt，也不创建 uiautomator2 设备。"""

    def __init__(
        self,
        command_runner: CommandRunner = run_adb_command,
        timeout_seconds: float = DEFAULT_ADB_TIMEOUT_SECONDS,
        sleeper: Sleeper = time.sleep,
        adb_executable: Optional[Path] = None,
    ):
        if timeout_seconds <= 0:
            raise ValueError("ADB 超时时间必须大于 0")
        self._run_command = command_runner
        self._timeout_seconds = timeout_seconds
        self._sleep = sleeper
        self._uses_bundled_adb = adb_executable is None
        self._adb_executable = str(adb_executable or bundled_adb_path())

    def search(
        self, is_cancelled: Optional[Callable[[], bool]] = None
    ) -> List[AndroidDevice]:
        """返回当前 ADB 设备；取消后停止补充设备属性。"""

        result = self._run(
            [self._adb_executable, "devices", "-l"], "搜索设备"
        )
        devices = self.parse_devices(result.stdout or "")

        enriched = []
        for device in devices:
            if is_cancelled is not None and is_cancelled():
                break
            if device.status != "device":
                enriched.append(device)
                continue

            model = device.model
            if model == "—":
                model = self._read_property(device.serial, "ro.product.model")
            if is_cancelled is not None and is_cancelled():
                break
            android_version = self._read_property(
                device.serial, "ro.build.version.release"
            )
            enriched.append(
                AndroidDevice(
                    serial=device.serial,
                    connection_type=device.connection_type,
                    model=model,
                    android_version=android_version,
                    status=device.status,
                )
            )
        return enriched

    def require_connected(self, serial: str) -> AndroidDevice:
        """确认已保存设备仍由 ADB 识别且状态可用。"""

        self._validate_saved_serial(serial)
        device = next(
            (item for item in self._list_devices() if item.serial == serial),
            None,
        )
        if device is None:
            connection = "Wi-Fi" if ":" in serial else "USB"
            raise AndroidDeviceSearchError(
                f"{connection} Android 设备 {serial} 未连接，"
                "请连接设备后重试"
            )
        if device.status == "unauthorized":
            raise AndroidDeviceSearchError(
                f"Android 设备 {serial} 未授权，"
                "请在手机上允许 USB 调试后重试"
            )
        if device.status != "device":
            raise AndroidDeviceSearchError(
                f"Android 设备 {serial} 当前为 {device.status} 状态，"
                "请重新连接后重试"
            )
        return device

    def is_package_installed(
        self,
        serial: str,
        package_name: str = PDD_PACKAGE_NAME,
    ) -> bool:
        """查询指定设备是否安装目标包；ADB 失败时抛出可读异常。"""

        self._validate_saved_serial(serial)
        if not package_name or any(character.isspace() for character in package_name):
            raise AndroidDeviceSearchError("应用包名格式不正确")

        result = self._run(
            [
                self._adb_executable,
                "-s",
                serial,
                "shell",
                "pm",
                "path",
                package_name,
            ],
            "检测 PDD 应用",
        )
        return any(
            line.strip().startswith("package:")
            for line in (result.stdout or "").splitlines()
        )

    def restore_saved_device(
        self,
        serial: str,
        is_cancelled: Optional[Callable[[], bool]] = None,
    ) -> List[AndroidDevice]:
        """恢复已保存设备；Wi-Fi 先重连，USB 只刷新设备列表。"""

        self._validate_saved_serial(serial)
        self._check_cancelled(is_cancelled)
        if ":" in serial:
            self._connect_wifi(serial)
            self._wait_until_device_ready(serial, is_cancelled)
        self._check_cancelled(is_cancelled)
        return self.search(is_cancelled)

    def convert_usb_to_wifi(
        self,
        usb_serial: str,
        is_cancelled: Optional[Callable[[], bool]] = None,
        on_progress: Optional[ProgressCallback] = None,
    ) -> AndroidWifiConversionResult:
        """插着数据线开启 5555，连接 Wi-Fi 后返回最新设备列表。"""

        self._validate_usb_serial(usb_serial)
        self._check_cancelled(is_cancelled)
        self._report(on_progress, "正在读取勾选设备的 Wi-Fi 地址…")
        route = self._run(
            [self._adb_executable, "-s", usb_serial, "shell", "ip", "route"],
            "读取 Wi-Fi 地址",
        )
        ip_address = self.parse_wifi_ipv4(route.stdout or "")
        wifi_serial = f"{ip_address}:5555"

        self._check_cancelled(is_cancelled)
        self._report(on_progress, "正在开启 ADB 5555 端口…")
        self._run(
            [self._adb_executable, "-s", usb_serial, "tcpip", "5555"],
            "开启 Wi-Fi 调试",
        )

        self._check_cancelled(is_cancelled)
        self._report(on_progress, f"正在连接 Wi-Fi 设备 {wifi_serial}…")
        self._connect_wifi(wifi_serial)
        self._wait_until_device_ready(wifi_serial, is_cancelled)
        self._wait_until_device_ready(usb_serial, is_cancelled)

        self._check_cancelled(is_cancelled)
        devices = self.search(is_cancelled)
        wifi_device = next(
            (device for device in devices if device.serial == wifi_serial),
            None,
        )
        if wifi_device is None or wifi_device.status != "device":
            status = wifi_device.status if wifi_device is not None else "未发现"
            raise AndroidDeviceSearchError(
                f"Wi-Fi 连接验证失败：{wifi_serial} 状态为 {status}；"
                "请确认手机和电脑在同一网络后重试"
            )

        self._report(on_progress, "Wi-Fi ADB 已连接，可以保存后拔掉 USB")
        return AndroidWifiConversionResult(wifi_serial, devices)

    @staticmethod
    def parse_wifi_ipv4(route_output: str) -> str:
        """从 Android ``ip route`` 输出的 ``src`` 字段读取有效 IPv4。"""

        route_tokens = [line.split() for line in route_output.splitlines()]
        default_interfaces = []
        for tokens in route_tokens:
            if not tokens or tokens[0] != "default" or "dev" not in tokens:
                continue
            device_index = tokens.index("dev")
            if device_index + 1 < len(tokens):
                default_interfaces.append(tokens[device_index + 1])

        preferred_routes = []
        for interface in default_interfaces:
            preferred_routes.extend(
                tokens
                for tokens in route_tokens
                if "dev" in tokens
                and tokens.index("dev") + 1 < len(tokens)
                and tokens[tokens.index("dev") + 1] == interface
            )
        preferred_routes.extend(
            tokens for tokens in route_tokens if tokens not in preferred_routes
        )

        for tokens in preferred_routes:
            for index, token in enumerate(tokens[:-1]):
                if token != "src":
                    continue
                candidate = tokens[index + 1]
                try:
                    address = ipaddress.ip_address(candidate)
                except ValueError:
                    continue
                if (
                    address.version == 4
                    and not address.is_loopback
                    and not address.is_unspecified
                    and not address.is_multicast
                ):
                    return str(address)
        raise AndroidDeviceSearchError(
            "无法读取手机 Wi-Fi IPv4；请先让手机连接与电脑相同的 Wi-Fi"
        )

    @staticmethod
    def parse_devices(output: str) -> List[AndroidDevice]:
        """解析 ``adb devices -l`` 输出，不依赖操作系统换行格式。"""

        devices = []
        for raw_line in output.splitlines():
            line = raw_line.strip()
            if not line or line.startswith("List of devices") or line.startswith("*"):
                continue

            parts = line.split()
            if len(parts) < 2:
                continue

            serial, status = parts[0], parts[1]
            fields = {}
            for token in parts[2:]:
                if ":" not in token:
                    continue
                key, value = token.split(":", 1)
                fields[key] = value

            model = fields.get("model", "—").replace("_", " ") or "—"
            devices.append(
                AndroidDevice(
                    serial=serial,
                    connection_type="Wi-Fi" if ":" in serial else "USB",
                    model=model,
                    status=status,
                )
            )
        return devices

    def _read_property(self, serial: str, property_name: str) -> str:
        """读取单个属性；失败只返回占位符，不丢掉已经发现的设备。"""

        try:
            result = self._run(
                [
                    self._adb_executable,
                    "-s",
                    serial,
                    "shell",
                    "getprop",
                    property_name,
                ],
                "读取设备信息",
            )
        except AndroidDeviceSearchError:
            return "—"
        value = (result.stdout or "").strip()
        return value or "—"

    def _wait_until_device_ready(
        self,
        serial: str,
        is_cancelled: Optional[Callable[[], bool]],
    ) -> None:
        """短暂等待 ADB transport 完成重启或授权握手。"""

        for attempt in range(DEFAULT_DEVICE_READY_CHECKS):
            self._check_cancelled(is_cancelled)
            device = next(
                (
                    item
                    for item in self._list_devices()
                    if item.serial == serial
                ),
                None,
            )
            if device is not None and device.status == "device":
                return
            if attempt < DEFAULT_DEVICE_READY_CHECKS - 1:
                self._sleep(DEFAULT_DEVICE_READY_INTERVAL_SECONDS)

    def _list_devices(self) -> List[AndroidDevice]:
        result = self._run(
            [self._adb_executable, "devices", "-l"], "读取设备列表"
        )
        return self.parse_devices(result.stdout or "")

    def _connect_wifi(self, wifi_serial: str) -> None:
        result = self._run(
            [self._adb_executable, "connect", wifi_serial],
            "连接 Wi-Fi 设备",
        )
        detail = " ".join(
            part.strip() for part in (result.stdout, result.stderr) if part
        )
        normalized_detail = detail.lower()
        if (
            "connected to" not in normalized_detail
            and "already connected to" not in normalized_detail
        ):
            raise AndroidDeviceSearchError(
                f"ADB 连接 {wifi_serial} 失败："
                f"{detail or '没有返回成功信息'}"
            )

    @staticmethod
    def _validate_usb_serial(serial: str) -> None:
        if not isinstance(serial, str) or not serial.strip():
            raise AndroidDeviceSearchError("请先勾选一台已连接的 USB 设备")
        contains_whitespace = any(
            character.isspace() for character in serial
        )
        if serial != serial.strip() or contains_whitespace:
            raise AndroidDeviceSearchError("USB 设备号格式不正确")
        if ":" in serial:
            raise AndroidDeviceSearchError("当前设备已经是 Wi-Fi 连接")

    @staticmethod
    def _validate_saved_serial(serial: str) -> None:
        if not isinstance(serial, str) or not serial.strip():
            raise AndroidDeviceSearchError("已保存 Android 设备号为空")
        contains_whitespace = any(
            character.isspace() for character in serial
        )
        if serial != serial.strip() or contains_whitespace:
            raise AndroidDeviceSearchError("已保存 Android 设备号格式不正确")

    @staticmethod
    def _check_cancelled(
        is_cancelled: Optional[Callable[[], bool]],
    ) -> None:
        if is_cancelled is not None and is_cancelled():
            raise AndroidDeviceConversionCancelled()

    @staticmethod
    def _report(
        callback: Optional[ProgressCallback], message: str
    ) -> None:
        if callback is not None:
            callback(message)

    def _run(self, command: Sequence[str], action: str):
        if self._uses_bundled_adb:
            try:
                validate_bundled_adb()
            except BundledAdbError as exc:
                raise AndroidDeviceSearchError(str(exc)) from exc
        try:
            result = self._run_command(command, self._timeout_seconds)
        except FileNotFoundError as exc:
            raise AndroidDeviceSearchError(
                "内置 adb.exe 无法启动，请重新安装完整的软件包"
            ) from exc
        except subprocess.TimeoutExpired as exc:
            raise AndroidDeviceSearchError(
                f"ADB {action}超时，请检查设备连接或重启 ADB 后重试"
            ) from exc
        except OSError as exc:
            raise AndroidDeviceSearchError(
                f"无法启动内置 adb：{str(exc) or '系统拒绝执行'}"
            ) from exc

        if result.returncode != 0:
            detail = (result.stderr or result.stdout or "未知错误").strip()
            raise AndroidDeviceSearchError(f"ADB {action}失败：{detail}")
        return result