#!/usr/bin/env python3
"""padsleep_adb 守护程序

基于树莓派，通过 ADB 控制安卓平板自动亮屏和息屏。

阶段一功能：
- 根据配置的亮屏时间段自动亮屏/息屏
- 屏幕亮起超过设定时长且不在亮屏时间段内 → 自动息屏
- 通过 Unix Socket 提供 IPC 接口，供 TUI 工具管理
"""

import json
import logging
import os
import signal
import socket
import threading
import time
from datetime import datetime
from pathlib import Path
from socketserver import ThreadingUnixStreamServer, StreamRequestHandler

from adbutils import AdbClient, AdbDevice

# ── 常量 ────────────────────────────────────────────────────────

SCRIPT_DIR = Path(__file__).parent.resolve()
CONFIG_PATH = SCRIPT_DIR / "config.json"
SOCKET_PATH = "/tmp/padsleep.sock"

DEFAULT_CONFIG = {
    "screen_on_periods": [
        {"start": "08:00", "end": "22:00"}
    ],
    "check_interval_seconds": 30,
    "auto_sleep_delay_minutes": 5,
    "adb_device_serial": "",
    "adb_wireless_host": "",
    "adb_wireless_port": 5555,
    "adb_wireless_auto_connect": False,
}

# ── 日志 ────────────────────────────────────────────────────────

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger("padsleep")


# ═══════════════════════════════════════════════════════════════════
#  ConfigManager — 配置加载/保存/监控
# ═══════════════════════════════════════════════════════════════════

class ConfigManager:
    """管理 JSON 配置文件的加载、保存和变更检测。"""

    def __init__(self, path: Path = CONFIG_PATH):
        self.path = path
        self.config = dict(DEFAULT_CONFIG)
        self._mtime: float = 0
        self._lock = threading.Lock()

    def load(self) -> bool:
        """从 JSON 文件加载配置，失败时使用默认值并不中断运行。"""
        try:
            with open(self.path, "r") as f:
                data = json.load(f)
            if "screen_on_periods" not in data:
                raise ValueError("缺少 screen_on_periods")
            for p in data["screen_on_periods"]:
                if "start" not in p or "end" not in p:
                    raise ValueError("时间段缺少 start 或 end")
            with self._lock:
                self.config.update(data)
                self._mtime = os.path.getmtime(self.path)
            log.info("配置已加载: %s", self.path)
            return True
        except FileNotFoundError:
            log.warning("配置文件不存在，写入默认配置: %s", self.path)
            self.save()
            return True
        except (json.JSONDecodeError, ValueError, OSError) as e:
            log.error("配置加载失败: %s，使用默认配置", e)
            return True  # 不崩溃，用默认配置继续运行

    def save(self) -> bool:
        """将当前配置写入 JSON 文件。"""
        with self._lock:
            data = dict(self.config)
        try:
            with open(self.path, "w") as f:
                json.dump(data, f, indent=2, ensure_ascii=False)
            self._mtime = os.path.getmtime(self.path)
            log.info("配置已保存")
            return True
        except OSError as e:
            log.error("配置保存失败: %s", e)
            return False

    def get(self) -> dict:
        """线程安全地获取当前配置副本。"""
        with self._lock:
            return dict(self.config)

    def update(self, new_config: dict) -> bool:
        """合并新配置并写入文件。"""
        with self._lock:
            self.config.update(new_config)
        self.save()
        return True

    def has_changed(self) -> bool:
        """检查配置文件是否被外部修改。"""
        try:
            return os.path.getmtime(self.path) != self._mtime
        except OSError:
            return False

    def reload_if_changed(self):
        """检测到外部修改则自动重载。"""
        if self.has_changed():
            log.info("配置文件已变更，重新加载")
            self.load()


# ═══════════════════════════════════════════════════════════════════
#  TimeChecker — 时间判断工具
# ═══════════════════════════════════════════════════════════════════

class TimeChecker:
    """亮屏时间段判断，支持跨天（如 22:00 ~ 08:00）。"""

    @staticmethod
    def _to_minutes(tstr: str) -> int:
        h, m = tstr.strip().split(":")
        return int(h) * 60 + int(m)

    @staticmethod
    def now_minutes() -> int:
        now = datetime.now()
        return now.hour * 60 + now.minute

    @staticmethod
    def is_within_period(period: dict, now_m: int | None = None) -> bool:
        """判断 now_m 是否在单个时间段内（支持跨天）。"""
        if now_m is None:
            now_m = TimeChecker.now_minutes()
        start = TimeChecker._to_minutes(period["start"])
        end = TimeChecker._to_minutes(period["end"])

        if end > start:
            return start <= now_m < end
        elif end == start:
            return True          # 全天
        else:
            return now_m >= start or now_m < end  # 跨天

    @staticmethod
    def is_within_any_period(periods: list, now_m: int | None = None) -> bool:
        """判断当前时间是否在任意一个亮屏时间段内。"""
        if not periods:
            return False
        if now_m is None:
            now_m = TimeChecker.now_minutes()
        return any(TimeChecker.is_within_period(p, now_m) for p in periods)


# ═══════════════════════════════════════════════════════════════════
#  AdbManager — ADB 操作封装（使用 adbutils 库）
# ═══════════════════════════════════════════════════════════════════

class AdbManager:
    """封装所有 ADB 操作，使用 adbutils 库实现持久连接。"""

    def __init__(self, config_getter):
        self._config_getter = config_getter
        self._client: AdbClient | None = None
        self._device: AdbDevice | None = None
        self._ready = False
        self._last_error = ""
        self._screen_on_since: float | None = None
        self._last_known_screen_on = False
        self._last_adb_check = 0
        self._wireless_addr: str = ""  # 当前无线连接地址 (IP:PORT)
        self._wireless_retries: int = 0  # 无线重连尝试次数

    # ── 连接管理 ──

    def _ensure_client(self) -> AdbClient:
        """懒初始化 ADB 客户端连接。"""
        if self._client is None:
            self._client = AdbClient(host="127.0.0.1", port=5037)
        return self._client

    def _ensure_device(self) -> AdbDevice | None:
        """获取目标设备，支持串号过滤。"""
        config = self._config_getter()
        target_serial = config.get("adb_device_serial", "")

        try:
            client = self._ensure_client()
            if target_serial:
                self._device = client.device(target_serial)
            else:
                devices = client.device_list()
                self._device = devices[0] if devices else None
            return self._device
        except Exception as e:
            self._device = None
            self._last_error = str(e)
            return None

    # ── 无线连接管理 ──

    @staticmethod
    def is_wireless_serial(serial: str) -> bool:
        """判断 serial 是否为无线格式（IP:PORT）。"""
        parts = serial.split(":")
        if len(parts) != 2:
            return False
        try:
            port = int(parts[1])
            ip_parts = parts[0].split(".")
            if len(ip_parts) == 4 and all(0 <= int(p) <= 255 for p in ip_parts):
                return True
        except (ValueError, IndexError):
            pass
        return False

    def connect_wireless(self, host: str, port: int = 5555, timeout: float = 5.0) -> tuple[bool, str]:
        """连接无线 ADB 设备。返回 (success, message)。"""
        addr = f"{host}:{port}"
        try:
            client = self._ensure_client()
            result = client.connect(addr, timeout=timeout)
            if "connected" in result.lower():
                self._wireless_addr = addr
                self._wireless_retries = 0
                log.info("无线 ADB 已连接: %s", addr)
                return True, result
            return False, result
        except Exception as e:
            self._last_error = str(e)
            log.error("无线连接失败: %s", e)
            return False, str(e)

    def disconnect_wireless(self, addr: str = "") -> bool:
        """断开无线 ADB 连接。"""
        target = addr or self._wireless_addr
        if not target:
            return False
        try:
            client = self._ensure_client()
            client.disconnect(target)
            log.info("无线 ADB 已断开: %s", target)
            if target == self._wireless_addr:
                self._wireless_addr = ""
            return True
        except Exception as e:
            self._last_error = str(e)
            log.error("断开无线连接失败: %s", e)
            return False

    def get_connection_type(self) -> str:
        """返回当前连接类型：'usb' / 'wireless' / 'none'。"""
        if self._device is None:
            return "none"
        if self.is_wireless_serial(self._device.serial):
            return "wireless"
        return "usb"

    def ensure_wireless_connection(self) -> bool:
        """确保无线连接存活，失败时尝试重连。返回是否成功。"""
        config = self._config_getter()
        wireless_host = config.get("adb_wireless_host", "")
        wireless_port = config.get("adb_wireless_port", 5555)

        if not wireless_host:
            return False

        addr = f"{wireless_host}:{wireless_port}"

        # 检查是否已有连接
        if self._device and self._device.serial == addr:
            try:
                self._device.getprop("ro.build.version.sdk")
                return True
            except Exception:
                # 连接已断开，尝试重连
                pass

        # 尝试重连（最多 3 次）
        max_retries = 3
        for i in range(max_retries):
            self._wireless_retries += 1
            log.info("尝试重连无线设备 (%d/%d): %s", i + 1, max_retries, addr)
            success, msg = self.connect_wireless(wireless_host, wireless_port, timeout=3.0)
            if success:
                # 重新获取设备
                try:
                    client = self._ensure_client()
                    self._device = client.device(addr)
                    self._device.getprop("ro.build.version.sdk")
                    self._ready = True
                    self._last_error = ""
                    return True
                except Exception:
                    pass
            time.sleep(2)

        self._last_error = f"无线重连失败: {addr}"
        return False

    # ── 设备管理 ──

    def check_available(self) -> bool:
        """检查 ADB Server 是否可连接。"""
        try:
            client = self._ensure_client()
            client.device_list()
            return True
        except Exception as e:
            self._last_error = f"ADB Server 不可用: {e}"
            return False

    def list_devices(self) -> list[dict]:
        """返回 [{"serial": "...", "status": "device", "connection_type": "usb"/"wireless"}]。"""
        try:
            client = self._ensure_client()
            devices = client.device_list()
            result = []
            for d in devices:
                conn_type = "wireless" if self.is_wireless_serial(d.serial) else "usb"
                result.append({
                    "serial": d.serial,
                    "status": "device",
                    "connection_type": conn_type,
                })
            return result
        except Exception as e:
            self._last_error = str(e)
            return []

    def get_ready_device(self) -> str | None:
        """返回当前已连接设备的串号，无则返回 None。"""
        if self._device is not None:
            return self._device.serial
        return None

    def is_ready(self) -> bool:
        """检查是否有已授权的 ADB 设备可用。"""
        now = time.time()
        if now - self._last_adb_check < 1 and self._ready:
            return True
        self._last_adb_check = now

        config = self._config_getter()
        target_serial = config.get("adb_device_serial", "")
        wireless_host = config.get("adb_wireless_host", "")

        try:
            client = self._ensure_client()
            devices = client.device_list()

            # USB 连接优先
            for d in devices:
                if not self.is_wireless_serial(d.serial):
                    if not target_serial or d.serial == target_serial:
                        d.getprop("ro.build.version.sdk")
                        self._device = d
                        self._ready = True
                        self._last_error = ""
                        return True

            # 尝试无线连接
            if wireless_host:
                wireless_port = config.get("adb_wireless_port", 5555)
                wireless_addr = f"{wireless_host}:{wireless_port}"

                # 检查是否已在设备列表中
                for d in devices:
                    if d.serial == wireless_addr:
                        d.getprop("ro.build.version.sdk")
                        self._device = d
                        self._ready = True
                        self._last_error = ""
                        self._wireless_addr = wireless_addr
                        return True

                # 不在列表中，尝试连接
                if self.ensure_wireless_connection():
                    return True

            if not devices and not wireless_host:
                self._last_error = "未检测到 ADB 设备，请连接平板"
            elif not devices:
                self._last_error = f"无线设备未连接: {wireless_host}:{config.get('adb_wireless_port', 5555)}"
            else:
                self._last_error = f"未找到指定设备: {target_serial}"
        except Exception as e:
            self._last_error = str(e)

        self._ready = False
        self._device = None
        return False

    # ── 屏幕控制 ──

    def get_screen_state(self) -> tuple[bool, str]:
        """返回 (is_on, wakefulness)，失败时返回上次已知状态。"""
        try:
            device = self._ensure_device()
            if device is None:
                return self._last_known_screen_on, "unknown"

            output = device.shell("dumpsys power")
            for line in output.split("\n"):
                line = line.strip()
                if "mWakefulness" in line:
                    state = line.split("=")[-1].strip()
                    is_on = state == "Awake"
                    self._last_known_screen_on = is_on
                    if is_on and self._screen_on_since is None:
                        self._screen_on_since = time.time()
                    elif not is_on:
                        self._screen_on_since = None
                    return is_on, state

            # fallback
            for line in output.split("\n"):
                if "Display Power" in line or "mScreenOn" in line:
                    is_on = "ON" in line.upper() or "=true" in line.lower()
                    return is_on, "unknown"
        except Exception as e:
            self._last_error = str(e)

        return self._last_known_screen_on, "unknown"

    def get_screen_on_duration(self) -> float:
        """返回屏幕已持续亮起的秒数，灭屏时返回 0。"""
        if self._screen_on_since is not None:
            return time.time() - self._screen_on_since
        return 0.0

    def screen_off(self) -> bool:
        """发送息屏命令。"""
        log.info("执行息屏操作")
        try:
            device = self._ensure_device()
            if device is None:
                log.error("息屏失败: 无可用设备")
                return False
            device.shell("input keyevent 26")
            self._screen_on_since = None
            return True
        except Exception as e:
            self._last_error = str(e)
            log.error("息屏失败: %s", e)
            return False

    def screen_on(self) -> bool:
        """发送亮屏并解锁命令。"""
        log.info("执行亮屏操作")
        try:
            device = self._ensure_device()
            if device is None:
                log.error("亮屏失败: 无可用设备")
                return False
            device.shell("input keyevent 26")
            self._screen_on_since = time.time()
            device.shell("input keyevent 82")  # 解锁（MENU）
            return True
        except Exception as e:
            self._last_error = str(e)
            log.error("亮屏失败: %s", e)
            return False


# ═══════════════════════════════════════════════════════════════════
#  IPC 服务端 — Unix Socket JSON 行协议
# ═══════════════════════════════════════════════════════════════════

class IpcHandler(StreamRequestHandler):
    """每个客户端连接由独立线程处理。"""

    def handle(self):
        try:
            raw = self.rfile.readline()
            if not raw:
                return
            req = json.loads(raw.decode("utf-8").strip())
            resp = self.server.app.handle_ipc(req)
            self.wfile.write((json.dumps(resp) + "\n").encode("utf-8"))
        except json.JSONDecodeError:
            self.wfile.write('{"ok":false,"error":"JSON 解析失败"}\n'.encode("utf-8"))
        except Exception as e:
            self.wfile.write(json.dumps({"ok": False, "error": str(e)}).encode() + b"\n")


class IpcServer:
    """管理 Unix Socket 生命周期。"""

    def __init__(self, app):
        self.app = app
        self.server: ThreadingUnixStreamServer | None = None
        self._thread: threading.Thread | None = None

    def start(self):
        try:
            os.unlink(SOCKET_PATH)
        except OSError:
            pass

        self.server = ThreadingUnixStreamServer(SOCKET_PATH, IpcHandler)
        self.server.app = self.app
        self.server.socket.settimeout(1.0)
        self._thread = threading.Thread(target=self._serve, daemon=True)
        self._thread.start()
        log.info("IPC 服务已启动: %s", SOCKET_PATH)

    def _serve(self):
        while self.app.running:
            try:
                self.server.handle_request()
            except socket.timeout:
                continue
            except OSError:
                break

    def cleanup(self):
        try:
            os.unlink(SOCKET_PATH)
        except OSError:
            pass

    def stop(self):
        if self.server:
            self.server.shutdown()
        self.cleanup()


# ═══════════════════════════════════════════════════════════════════
#  PadSleepApp — 主应用
# ═══════════════════════════════════════════════════════════════════

class PadSleepApp:
    """守护程序核心：加载配置 → 主循环检查屏幕状态 → IPC 通信。"""

    def __init__(self):
        self.running = True
        self.config_mgr = ConfigManager()
        self.adb = AdbManager(self._get_config)
        self.ipc = IpcServer(self)
        self._lock = threading.Lock()
        self._start_time = time.time()
        self._status = {
            "screen_on": False,
            "wakefulness": "unknown",
            "within_period": False,
            "adb_ready": False,
            "device": None,
            "uptime": 0,
            "start_time": self._start_time,
        }

    # ── 辅助 ──

    def _get_config(self) -> dict:
        return self.config_mgr.get()

    def _update_status(self, **kwargs):
        with self._lock:
            self._status.update(kwargs)

    def get_status(self) -> dict:
        with self._lock:
            s = dict(self._status)
            s["uptime"] = int(time.time() - self._start_time)
            return s

    # ── IPC 命令处理 ──

    def handle_ipc(self, request: dict) -> dict:
        cmd = request.get("cmd", "")
        log.debug("IPC 请求: %s", cmd)

        if cmd == "status":
            status = self.get_status()
            cfg = self.config_mgr.get()
            status["periods_count"] = len(cfg.get("screen_on_periods", []))
            status["check_interval"] = cfg.get("check_interval_seconds", 30)
            status["connection_type"] = self.adb.get_connection_type()
            status["wireless_host"] = cfg.get("adb_wireless_host", "")
            status["wireless_port"] = cfg.get("adb_wireless_port", 5555)
            return {"ok": True, "data": status}

        if cmd == "get_config":
            return {"ok": True, "data": self.config_mgr.get()}

        if cmd == "update_config":
            new = request.get("config", {})
            if "screen_on_periods" in new:
                for p in new["screen_on_periods"]:
                    if "start" not in p or "end" not in p:
                        return {"ok": False, "error": "时间段格式错误"}
            self.config_mgr.update(new)
            cfg = self.config_mgr.get()
            # 重设串号以使 is_ready 立即用新串号检查
            self.config_mgr.config["adb_device_serial"] = cfg.get("adb_device_serial", "")
            return {"ok": True, "data": {"reloaded": True}}

        if cmd == "reload":
            self.config_mgr.load()
            return {"ok": True, "data": {"reloaded": True}}

        if cmd == "list_devices":
            return {"ok": True, "data": {"devices": self.adb.list_devices()}}

        if cmd == "select_device":
            serial = request.get("serial", "")
            self.config_mgr.update({"adb_device_serial": serial})
            return {"ok": True, "data": {"selected": serial}}

        if cmd == "shutdown":
            log.info("收到 IPC 关闭命令")
            self.running = False
            return {"ok": True}

        if cmd == "screen_off":
            ok = self.adb.screen_off()
            return {"ok": ok}

        if cmd == "screen_on":
            ok = self.adb.screen_on()
            return {"ok": ok}

        if cmd == "connect_wireless":
            host = request.get("host", "")
            port = request.get("port", 5555)
            if not host:
                return {"ok": False, "error": "请提供 IP 地址"}
            success, msg = self.adb.connect_wireless(host, int(port))
            if success:
                # 更新配置
                self.config_mgr.update({
                    "adb_wireless_host": host,
                    "adb_wireless_port": int(port),
                })
            return {"ok": success, "data": {"message": msg}}

        if cmd == "disconnect_wireless":
            addr = request.get("addr", "")
            ok = self.adb.disconnect_wireless(addr)
            return {"ok": ok}

        return {"ok": False, "error": f"未知命令: {cmd}"}

    # ── 主循环 ──

    def run(self):
        log.info("=" * 50)
        log.info("padsleep_adb 守护程序启动")
        log.info("=" * 50)

        # 加载配置
        self.config_mgr.load()

        # 检测 ADB
        if not self.adb.check_available():
            log.warning("ADB 未就绪，请安装: sudo apt install adb")
            log.warning("安装后将自动检测到 ADB，无需重启本程序")
        else:
            log.info("ADB 可执行文件已就绪")

        # 自动连接无线设备
        config = self.config_mgr.get()
        if config.get("adb_wireless_auto_connect") and config.get("adb_wireless_host"):
            host = config["adb_wireless_host"]
            port = config.get("adb_wireless_port", 5555)
            log.info("尝试自动连接无线设备: %s:%d", host, port)
            success, msg = self.adb.connect_wireless(host, port, timeout=5.0)
            if success:
                log.info("无线设备已连接: %s", msg)
            else:
                log.warning("无线设备连接失败: %s", msg)

        # 启动 IPC
        self.ipc.start()

        # 注册信号
        def sighandler(sig, _frame):
            log.info("收到信号 %s，正在退出...", sig)
            self.running = False

        signal.signal(signal.SIGTERM, sighandler)
        signal.signal(signal.SIGINT, sighandler)

        # 主循环
        while self.running:
            try:
                self._tick()
            except Exception as e:
                log.error("主循环异常: %s", e, exc_info=True)

            # 检测配置文件外部变更
            self.config_mgr.reload_if_changed()

            # 分段睡眠以快速响应退出信号
            interval = self.config_mgr.get().get("check_interval_seconds", 30)
            for _ in range(max(1, interval)):
                if not self.running:
                    break
                time.sleep(1)

        # 清理
        self.ipc.cleanup()
        log.info("padsleep_adb 守护程序已退出")

    def _tick(self):
        """单次检查逻辑。"""
        config = self.config_mgr.get()

        # ── 检查 ADB 就绪 ──
        if not self.adb.is_ready():
            self._update_status(adb_ready=False, device=None)
            now = time.time()
            if not hasattr(self, "_last_adb_warn") or now - self._last_adb_warn > 60:
                log.warning("ADB 未就绪: %s", self.adb._last_error)
                self._last_adb_warn = now
            return

        # ── 获取屏幕状态 ──
        screen_on, wakefulness = self.adb.get_screen_state()
        periods = config.get("screen_on_periods", [])
        within_period = TimeChecker.is_within_any_period(periods)

        device = self.adb.get_ready_device()
        self._update_status(
            adb_ready=True,
            device=device,
            screen_on=screen_on,
            wakefulness=wakefulness,
            within_period=within_period,
        )

        # ── 决策逻辑 ──
        delay_sec = config.get("auto_sleep_delay_minutes", 5) * 60

        if not within_period and screen_on:
            # 非亮屏时段但屏幕亮着 → 超时后息屏
            on_duration = self.adb.get_screen_on_duration()
            if on_duration >= delay_sec:
                log.info("不在亮屏时段（已亮 %.0fs）→ 自动息屏", on_duration)
                self.adb.screen_off()
            else:
                remaining = delay_sec - on_duration
                if remaining <= 10:
                    log.info("不在亮屏时段，%.0f 秒后将息屏", remaining)

        elif within_period and not screen_on:
            # 在亮屏时段但屏幕灭着 → 亮屏
            log.info("在亮屏时段内 → 自动亮屏")
            self.adb.screen_on()


# ═══════════════════════════════════════════════════════════════════
#  入口
# ═══════════════════════════════════════════════════════════════════

def main():
    app = PadSleepApp()
    try:
        app.run()
    except KeyboardInterrupt:
        log.info("用户中断")
    finally:
        app.ipc.cleanup()


if __name__ == "__main__":
    main()