#!/usr/bin/env python3
"""
ButtonTask BLE Collector — GATT peripheral + advertiser on BlueZ 5.55.

Accepts connections from sensors, receives 4-byte reports, keeps addr→slot
registry, mirrors latest values in advertising. Pool size N=4. No scanning.

ANTI-SCOPE (do not implement / do not "improve"):
  - encryption / pairing / bonding
  - provisioning of collector address
  - RPA resolving
  - web/CLI UI inside this process
  - multiple collectors
  - BLE scanning
"""
from __future__ import annotations

import asyncio
import logging
import signal
import sys
import threading
import time
from logging.handlers import RotatingFileHandler
from pathlib import Path
from typing import Any, Dict, List, Optional

# Allow `python3 main.py` from collector/ directory.
_HERE = Path(__file__).resolve().parent
if str(_HERE) not in sys.path:
    sys.path.insert(0, str(_HERE))

from adv import BlessAdvertiser, build_manufacturer_data  # noqa: E402
from bluez_adv import (  # noqa: E402
    disconnect_device,
    find_device_path,
    list_connected_addresses,
    read_device_rssi,
    system_bus,
)
from config import (  # noqa: E402
    LOCAL_NAME,
    N,
    TICK_INTERVAL_S,
    collector_log_path,
    registry_path,
    run_dir,
)
from gatt import CollectorGatt, build_bless_server  # noqa: E402
from protocol import (  # noqa: E402
    CFG_JOIN_OPEN,
    CFG_POOL_FULL,
    pack_interval_min,
    pack_slot_config,
    unpack_report,
)
from registry import Registry  # noqa: E402
from settings import (  # noqa: E402
    load_names,
    load_report_interval_min,
    save_report_interval_min,
)
from ui_io import append_ui_log, read_cmd, write_status  # noqa: E402

log = logging.getLogger("collector")


def setup_logging() -> None:
    run_dir()
    root = logging.getLogger("collector")
    root.setLevel(logging.INFO)
    fmt = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
    sh = logging.StreamHandler(sys.stderr)
    sh.setFormatter(fmt)
    root.addHandler(sh)
    try:
        fh = RotatingFileHandler(
            collector_log_path(), maxBytes=512_000, backupCount=2, encoding="utf-8"
        )
        fh.setFormatter(fmt)
        root.addHandler(fh)
    except OSError as e:
        root.warning("file log unavailable: %s", e)


def preflight() -> None:
    try:
        import bless  # noqa: F401
    except Exception as e:
        log.error("bless import failed: %s", e)
        raise SystemExit(2) from e
    try:
        bus = system_bus()
        bus.get_object("org.bluez", "/")
    except Exception as e:
        log.error("D-Bus / bluetoothd unavailable: %s", e)
        raise SystemExit(2) from e
    log.info("preflight ok (bless + SystemBus + bluez)")


class CollectorApp:
    def __init__(self):
        self.registry = Registry(n=N, path=registry_path())
        self.gatt = CollectorGatt(self.registry)
        self.bus = None
        self.advertiser: BlessAdvertiser | None = None
        self.server = None
        self._known_connected: set[str] = set()
        self._stop = threading.Event()
        self._names: Dict[str, str] = {}
        self._dirty_registry = False
        self._dirty_status = False
        self._dirty_adv = False
        self._pending_logs: List[Dict[str, Any]] = []
        self._lock = threading.Lock()

        self.gatt.on_write = self._on_write
        self.gatt.on_read_slot = self._on_read_slot
        self.gatt.on_read_interval = self._on_read_interval
        self.gatt.on_connect = self._on_connect
        self.gatt.on_disconnect = self._on_disconnect

    def _reload_settings(self, *, force_log: bool = False) -> None:
        interval = load_report_interval_min()
        names = load_names()
        changed = (
            interval != self.gatt.report_interval_min or names != self._names
        )
        self.gatt.report_interval_min = interval
        self._names = names
        if force_log or changed:
            log.info(
                "settings: report_interval_min=%s names=%d",
                self.gatt.report_interval_min,
                len(self._names),
            )

    def _queue_log(self, level: str, message: str, **extra: Any) -> None:
        with self._lock:
            self._pending_logs.append({"level": level, "msg": message, **extra})

    def _mark_dirty(self, registry: bool = False, status: bool = True, adv: bool = False) -> None:
        with self._lock:
            if registry:
                self._dirty_registry = True
            if status:
                self._dirty_status = True
            if adv:
                self._dirty_adv = True

    def _connected(self) -> bool:
        return bool(self._known_connected)

    def _sync_status(self) -> None:
        write_status(
            self.registry.status_dict(
                names=self._names,
                report_interval_min=self.gatt.report_interval_min,
            )
        )

    def _mirror_bytes(self) -> bytes:
        bitmap, reports = self.registry.mirror_payload_parts()
        return build_manufacturer_data(bitmap, reports)

    def _refresh_mirror(self, force: bool = False) -> None:
        if self.advertiser is None:
            return
        if not force and self._connected():
            # Do not tear down advertising while a central is connected.
            return
        self.advertiser.set_mirror(self._mirror_bytes(), force=force)

    def _on_connect(self, addr: str) -> bool:
        addr = self.registry.normalize_addr(addr)
        sensor = self.registry.get(addr)
        if sensor is None:
            sensor = self.registry.assign(addr)
            if sensor is None:
                log.warning("pool-full, rejecting %s", addr)
                self._queue_log("warn", "pool-full", addr=addr)
                self._mark_dirty(registry=True, status=True)
                return False
            self._queue_log("info", "assigned", addr=addr, slot=sensor.slot)
            log.info("assigned slot=%s addr=%s", sensor.slot, addr)
        else:
            self.registry.touch(addr)
        rssi = None
        if self.bus is not None:
            path = find_device_path(self.bus, addr)
            if path:
                rssi = read_device_rssi(self.bus, path)
                if rssi is not None:
                    sensor.rssi = rssi
        self.gatt.set_current_addr(addr)
        self._mark_dirty(registry=True, status=True)
        return True

    def _on_disconnect(self, addr: str) -> None:
        addr = self.registry.normalize_addr(addr)
        sensor = self.registry.get(addr)
        if sensor is not None:
            # Keep last_seen from last report; only bump state.
            if sensor.state != "stale":
                sensor.state = "live"
        if self.gatt.current_addr() == addr:
            self.gatt.set_current_addr(None)
        self._queue_log("info", "disconnect", addr=addr)
        self._mark_dirty(registry=True, status=True, adv=True)
        log.info("disconnect %s", addr)

    def _on_write(self, addr: str, data: bytes) -> None:
        """GATT hot-path: RAM only — no disk / D-Bus / adv / UI I/O."""
        addr = self.registry.normalize_addr(addr) or (self.gatt.current_addr() or "")
        if not addr:
            if len(self._known_connected) == 1:
                addr = next(iter(self._known_connected))
            else:
                log.warning("write without address — discarded")
                return
        report = unpack_report(data)
        if report is None:
            log.warning("bad report from %s — discarded", addr)
            return
        sensor = self.registry.get(addr)
        if sensor is None:
            sensor = self.registry.assign(addr)
            if sensor is None:
                log.warning("pool-full on write from %s", addr)
                self._queue_log("warn", "pool-full", addr=addr)
                self._mark_dirty(registry=True, status=True)
                return
            self.gatt.set_current_addr(addr)
            self._queue_log("info", "assigned", addr=addr, slot=sensor.slot)
        self.registry.update_report(
            addr, report.battery, report.flags, report.dist, rssi=None
        )
        self._queue_log(
            "info",
            "report",
            addr=addr,
            battery=report.battery,
            flags=report.flags,
            dist=report.dist,
        )
        self._mark_dirty(registry=True, status=True, adv=True)
        log.debug(
            "report slot=%s addr=%s batt=%s dist=%s",
            sensor.slot if sensor else "?",
            addr,
            report.battery,
            report.dist,
        )

    def _on_read_slot(self, addr: str) -> bytes:
        addr = self.registry.normalize_addr(addr) or (self.gatt.current_addr() or "")
        sensor = self.registry.get(addr) if addr else None
        slot = sensor.slot if sensor else 0xFF
        flags = CFG_JOIN_OPEN if not self.registry.pool_full() else CFG_POOL_FULL
        return pack_slot_config(slot, flags, self.gatt.period_s())

    def _on_read_interval(self) -> bytes:
        return pack_interval_min(self.gatt.report_interval_min)

    def _poll_connections(self) -> None:
        if self.bus is None:
            return
        try:
            connected = set(list_connected_addresses(self.bus))
        except Exception as e:
            log.debug("conn poll: %s", e)
            return
        for addr in connected - self._known_connected:
            ok = self._on_connect(addr)
            if not ok:
                disconnect_device(self.bus, addr)
        for addr in self._known_connected - connected:
            self._on_disconnect(addr)
        self._known_connected = connected
        if connected and self.gatt.current_addr() is None:
            # Prefer the sole connected peer as current writer context.
            if len(connected) == 1:
                self.gatt.set_current_addr(next(iter(connected)))

    def _handle_cmd(self) -> None:
        cmd = read_cmd()
        if not cmd:
            return
        op = str(cmd.get("op", "")).lower()
        if op == "advertise":
            self._queue_log("info", "manual-advertise")
            log.info("manual advertise requested")
            self._refresh_mirror(force=True)
        elif op == "reload_settings":
            self._reload_settings()
            self._mark_dirty(status=True)
            if "report_interval_min" in cmd:
                try:
                    self.gatt.report_interval_min = save_report_interval_min(
                        int(cmd["report_interval_min"])
                    )
                except (TypeError, ValueError):
                    pass
            log.info("reload_settings done interval=%s", self.gatt.report_interval_min)
        elif op == "set_interval":
            try:
                minutes = int(cmd.get("report_interval_min", self.gatt.report_interval_min))
            except (TypeError, ValueError):
                return
            self.gatt.report_interval_min = save_report_interval_min(minutes)
            self._mark_dirty(status=True)
            self._queue_log("info", "set-interval", minutes=self.gatt.report_interval_min)
            log.info("set_interval %s min", self.gatt.report_interval_min)

    def _flush_dirty(self) -> None:
        with self._lock:
            do_reg = self._dirty_registry
            do_st = self._dirty_status
            do_adv = self._dirty_adv
            logs = list(self._pending_logs)
            self._dirty_registry = False
            self._dirty_status = False
            self._dirty_adv = False
            self._pending_logs.clear()
        for entry in logs:
            level = entry.pop("level", "info")
            msg = entry.pop("msg", "")
            append_ui_log(level, msg, **entry)
        if do_reg:
            self.registry.save()
        if do_st:
            self._sync_status()
        if do_adv:
            # Only when idle (no connected centrals), unless already forced earlier.
            self._refresh_mirror(force=False)

    async def run(self) -> None:
        self._reload_settings(force_log=True)
        self.registry.load()
        self._sync_status()
        append_ui_log("info", "startup", sensors=len(self.registry.by_addr))

        self.bus = system_bus()
        loop = asyncio.get_running_loop()
        self.server = await build_bless_server(self.gatt, loop, LOCAL_NAME)

        await self.server.start()
        log.info("GATT server started (%s)", LOCAL_NAME)

        self.advertiser = BlessAdvertiser(self.server)
        self._refresh_mirror(force=True)
        await self.advertiser.tick()

        while not self._stop.is_set():
            try:
                # Pick up web/Qt edits to names & interval without a separate watcher.
                self._reload_settings()
                self._poll_connections()
                if self.registry.reevaluate(period_s=self.gatt.period_s()):
                    self._mark_dirty(registry=True, status=True, adv=True)
                self._handle_cmd()
                self._flush_dirty()
                if self.advertiser and not self._connected():
                    await self.advertiser.tick()
                # Refresh age_s even when nothing else changed.
                self._sync_status()
            except Exception as e:
                log.error("tick error: %s", e)
            try:
                await asyncio.sleep(TICK_INTERVAL_S)
            except asyncio.CancelledError:
                break

        await self._shutdown()

    async def _shutdown(self) -> None:
        log.info("shutdown")
        append_ui_log("info", "shutdown")
        try:
            if self.server is not None:
                await self.server.stop()
        except Exception as e:
            log.warning("server stop: %s", e)
        self._flush_dirty()
        self.registry.save()
        self._sync_status()

    def request_stop(self) -> None:
        self._stop.set()


def main() -> None:
    setup_logging()
    preflight()

    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    app = CollectorApp()

    def _sig(*_a):
        log.info("signal → stop")
        app.request_stop()
        for task in asyncio.all_tasks(loop):
            task.cancel()

    for sig in (signal.SIGINT, signal.SIGTERM):
        try:
            loop.add_signal_handler(sig, _sig)
        except NotImplementedError:
            signal.signal(sig, lambda *_: _sig())

    try:
        loop.run_until_complete(app.run())
    except asyncio.CancelledError:
        pass
    finally:
        loop.close()


if __name__ == "__main__":
    main()