#!/usr/bin/env python3
"""
sensor_dashboard.py — Termux phone sensor publisher for SaltyBot (Issue #574)

Reads phone IMU, GPS, and battery via termux-api and publishes JSON payloads
to the SaltyBot MQTT broker.  Designed to run on Android/Termux as a
persistent background service.

Topics
──────
  saltybot/phone/imu      — accelerometer + gyroscope  @ 5 Hz
  saltybot/phone/gps      — lat/lon/alt/accuracy        @ 1 Hz
  saltybot/phone/battery  — percentage/charging/temp    @ 1 Hz

JSON payloads
─────────────
  IMU:
    {"ts": 1710000000.000,
     "accel": {"x": 0.12, "y": -0.05, "z": 9.81},
     "gyro":  {"x": 0.01, "y": -0.00, "z": 0.00}}

  GPS:
    {"ts": 1710000000.000,
     "lat": 45.123, "lon": -73.456, "alt_m": 12.3,
     "accuracy_m": 3.5, "speed_ms": 0.0, "bearing_deg": 0.0,
     "provider": "gps"}

  Battery:
    {"ts": 1710000000.000,
     "pct": 87, "charging": true, "temp_c": 28.5,
     "health": "GOOD", "plugged": "AC"}

Usage
─────
  python3 phone/sensor_dashboard.py [OPTIONS]

  --broker HOST     MQTT broker IP/hostname  (default: 192.168.1.100)
  --port PORT       MQTT broker port         (default: 1883)
  --imu-hz FLOAT    IMU publish rate Hz      (default: 5.0)
  --gps-hz FLOAT    GPS publish rate Hz      (default: 1.0)
  --bat-hz FLOAT    Battery publish rate Hz  (default: 1.0)
  --qos INT         MQTT QoS level 0/1/2     (default: 0)
  --no-imu          Disable IMU publishing
  --no-gps          Disable GPS publishing
  --no-battery      Disable battery publishing
  --debug           Verbose logging

Dependencies (install in Termux)
─────────────────────────────────
  pkg install termux-api python
  pip install paho-mqtt
"""

import argparse
import json
import logging
import subprocess
import sys
import threading
import time
from typing import Optional

try:
    import paho.mqtt.client as mqtt
    MQTT_AVAILABLE = True
except ImportError:
    MQTT_AVAILABLE = False

# ── MQTT topic roots ──────────────────────────────────────────────────────────

TOPIC_IMU     = "saltybot/phone/imu"
TOPIC_GPS     = "saltybot/phone/gps"
TOPIC_BATTERY = "saltybot/phone/battery"

# ── termux-api wrappers ───────────────────────────────────────────────────────

def _run_termux(cmd: list[str], timeout: float = 5.0) -> Optional[dict]:
    """Run a termux-api command and parse its JSON output. Returns None on error."""
    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            timeout=timeout,
        )
        if result.returncode != 0 or not result.stdout.strip():
            logging.debug("termux cmd %s returned %d: %s",
                          cmd[0], result.returncode, result.stderr.strip())
            return None
        return json.loads(result.stdout)
    except (subprocess.TimeoutExpired, json.JSONDecodeError, FileNotFoundError) as e:
        logging.debug("termux cmd %s error: %s", cmd[0], e)
        return None


def read_sensor_once(sensor_name: str) -> Optional[dict]:
    """
    Call termux-sensor for a single reading of @sensor_name.

    termux-sensor -s <name> -n 1 returns one sample then exits.
    """
    raw = _run_termux(["termux-sensor", "-s", sensor_name, "-n", "1"], timeout=4.0)
    if raw is None:
        return None
    # Response shape: {"<sensor_name>": {"values": [x, y, z], ...}}
    # Key may be the full sensor description string; iterate to find it.
    for key, val in raw.items():
        if isinstance(val, dict) and "values" in val:
            return val
    return None


def read_imu() -> Optional[dict]:
    """
    Read accelerometer and gyroscope in a single call each.
    Returns dict with 'accel' and 'gyro' sub-dicts, or None if both fail.
    """
    accel_data = read_sensor_once("accelerometer")
    gyro_data  = read_sensor_once("gyroscope")

    accel = None
    if accel_data and isinstance(accel_data.get("values"), list):
        v = accel_data["values"]
        if len(v) >= 3:
            accel = {"x": float(v[0]), "y": float(v[1]), "z": float(v[2])}

    gyro = None
    if gyro_data and isinstance(gyro_data.get("values"), list):
        v = gyro_data["values"]
        if len(v) >= 3:
            gyro = {"x": float(v[0]), "y": float(v[1]), "z": float(v[2])}

    if accel is None and gyro is None:
        return None

    return {
        "ts":    time.time(),
        "accel": accel or {"x": 0.0, "y": 0.0, "z": 0.0},
        "gyro":  gyro  or {"x": 0.0, "y": 0.0, "z": 0.0},
    }


def read_gps() -> Optional[dict]:
    """Read GPS fix via termux-location."""
    raw = _run_termux(["termux-location", "-p", "gps", "-r", "once"], timeout=10.0)
    if raw is None:
        # Fallback: try network provider if GPS cold
        raw = _run_termux(
            ["termux-location", "-p", "network", "-r", "once"], timeout=6.0
        )
    if raw is None:
        return None

    return {
        "ts":          time.time(),
        "lat":         float(raw.get("latitude",  0.0)),
        "lon":         float(raw.get("longitude", 0.0)),
        "alt_m":       float(raw.get("altitude",  0.0)),
        "accuracy_m":  float(raw.get("accuracy",  -1.0)),
        "speed_ms":    float(raw.get("speed",     0.0)),
        "bearing_deg": float(raw.get("bearing",   0.0)),
        "provider":    str(raw.get("provider", "unknown")),
    }


def read_battery() -> Optional[dict]:
    """Read battery status via termux-battery-status."""
    raw = _run_termux(["termux-battery-status"], timeout=4.0)
    if raw is None:
        return None

    return {
        "ts":      time.time(),
        "pct":     int(raw.get("percentage", -1)),
        "charging": raw.get("status", "DISCHARGING") not in ("DISCHARGING", "UNKNOWN"),
        "temp_c":  float(raw.get("temperature", 0.0)),
        "health":  str(raw.get("health", "UNKNOWN")),
        "plugged": str(raw.get("plugged", "UNPLUGGED")),
    }


# ── MQTT client with auto-reconnect ───────────────────────────────────────────

class MQTTPublisher:
    """
    Thin paho-mqtt wrapper with:
    - Automatic reconnect on disconnect (exponential back-off, max 60 s)
    - Thread-safe publish() — queues messages if offline
    - Connection status accessible via .connected property
    """

    _RECONNECT_BASE  = 2.0   # seconds
    _RECONNECT_MAX   = 60.0

    def __init__(self, broker: str, port: int, qos: int = 0):
        self._broker  = broker
        self._port    = port
        self._qos     = qos
        self._lock    = threading.Lock()
        self._connected = False
        self._reconnect_delay = self._RECONNECT_BASE

        self._client = mqtt.Client(client_id="saltybot-phone-sensor", clean_session=True)
        self._client.on_connect    = self._on_connect
        self._client.on_disconnect = self._on_disconnect
        self._client.reconnect_delay_set(
            min_delay=int(self._RECONNECT_BASE),
            max_delay=int(self._RECONNECT_MAX),
        )

        self._connect()

    def _connect(self) -> None:
        try:
            self._client.connect_async(self._broker, self._port, keepalive=60)
            self._client.loop_start()
            logging.info("MQTT connecting to %s:%d ...", self._broker, self._port)
        except Exception as e:
            logging.warning("MQTT initial connect error: %s", e)

    def _on_connect(self, client, userdata, flags, rc) -> None:
        if rc == 0:
            with self._lock:
                self._connected = True
                self._reconnect_delay = self._RECONNECT_BASE
            logging.info("MQTT connected to %s:%d", self._broker, self._port)
        else:
            logging.warning("MQTT connect failed rc=%d", rc)

    def _on_disconnect(self, client, userdata, rc) -> None:
        with self._lock:
            self._connected = False
        if rc != 0:
            logging.warning("MQTT unexpected disconnect (rc=%d) — paho will retry", rc)

    @property
    def connected(self) -> bool:
        with self._lock:
            return self._connected

    def publish(self, topic: str, payload: dict) -> bool:
        """Serialize @payload to JSON and publish to @topic. Returns True on success."""
        if not self.connected:
            logging.debug("MQTT offline — dropping %s", topic)
            return False
        try:
            msg = json.dumps(payload, separators=(",", ":"))
            info = self._client.publish(topic, msg, qos=self._qos, retain=False)
            return info.rc == mqtt.MQTT_ERR_SUCCESS
        except Exception as e:
            logging.warning("MQTT publish error on %s: %s", topic, e)
            return False

    def shutdown(self) -> None:
        self._client.loop_stop()
        self._client.disconnect()
        logging.info("MQTT disconnected.")


# ── Sensor polling threads ────────────────────────────────────────────────────

class SensorPoller(threading.Thread):
    """
    Polls a sensor function at a fixed rate and publishes to MQTT.
    Runs as a daemon thread so it exits cleanly when the main thread stops.
    """

    def __init__(self, name: str, read_fn, topic: str,
                 hz: float, publisher: MQTTPublisher):
        super().__init__(name=name, daemon=True)
        self._read_fn  = read_fn
        self._topic    = topic
        self._interval = 1.0 / hz
        self._pub      = publisher
        self._running  = False

        # Stats
        self.published  = 0
        self.errors     = 0

    def run(self) -> None:
        self._running = True
        logging.info("Poller '%s' started at %.1f Hz → %s",
                     self.name, 1.0 / self._interval, self._topic)
        while self._running:
            t0 = time.monotonic()
            try:
                data = self._read_fn()
                if data is not None:
                    if self._pub.publish(self._topic, data):
                        self.published += 1
                        logging.debug("%s: published %s", self.name,
                                      list(data.keys()))
                    else:
                        self.errors += 1
                else:
                    self.errors += 1
                    logging.debug("%s: read returned None", self.name)
            except Exception as e:
                self.errors += 1
                logging.warning("%s: read error: %s", self.name, e)

            elapsed = time.monotonic() - t0
            sleep_s = max(0.0, self._interval - elapsed)
            time.sleep(sleep_s)

    def stop(self) -> None:
        self._running = False


# ── Status logger ─────────────────────────────────────────────────────────────

def _status_logger(pollers: list[SensorPoller], publisher: MQTTPublisher,
                   stop_event: threading.Event) -> None:
    """Log per-poller stats every 30 s."""
    while not stop_event.wait(30.0):
        parts = [f"MQTT={'OK' if publisher.connected else 'DOWN'}"]
        for p in pollers:
            parts.append(f"{p.name}={p.published}ok/{p.errors}err")
        logging.info("Status — %s", "  ".join(parts))


# ── Entry point ───────────────────────────────────────────────────────────────

def main() -> None:
    parser = argparse.ArgumentParser(
        description="SaltyBot Termux sensor dashboard (Issue #574)"
    )
    parser.add_argument("--broker",     default="192.168.1.100",
                        help="MQTT broker IP/hostname (default: 192.168.1.100)")
    parser.add_argument("--port",       type=int, default=1883,
                        help="MQTT broker port (default: 1883)")
    parser.add_argument("--imu-hz",     type=float, default=5.0,
                        help="IMU publish rate Hz (default: 5.0)")
    parser.add_argument("--gps-hz",     type=float, default=1.0,
                        help="GPS publish rate Hz (default: 1.0)")
    parser.add_argument("--bat-hz",     type=float, default=1.0,
                        help="Battery publish rate Hz (default: 1.0)")
    parser.add_argument("--qos",        type=int, default=0, choices=[0, 1, 2],
                        help="MQTT QoS level (default: 0)")
    parser.add_argument("--no-imu",     action="store_true", help="Disable IMU")
    parser.add_argument("--no-gps",     action="store_true", help="Disable GPS")
    parser.add_argument("--no-battery", action="store_true", help="Disable battery")
    parser.add_argument("--debug",      action="store_true", help="Verbose logging")
    args = parser.parse_args()

    logging.basicConfig(
        level=logging.DEBUG if args.debug else logging.INFO,
        format="%(asctime)s [%(levelname)s] %(message)s",
    )

    if not MQTT_AVAILABLE:
        logging.error("paho-mqtt not installed.  Run: pip install paho-mqtt")
        sys.exit(1)

    if args.no_imu and args.no_gps and args.no_battery:
        logging.error("All sensors disabled — nothing to do.")
        sys.exit(1)

    # Connect MQTT
    publisher = MQTTPublisher(args.broker, args.port, qos=args.qos)

    # Wait briefly for initial connection before starting pollers
    deadline = time.monotonic() + 10.0
    while not publisher.connected and time.monotonic() < deadline:
        time.sleep(0.2)
    if not publisher.connected:
        logging.warning("MQTT not yet connected — pollers will start anyway and retry.")

    # Build pollers for enabled sensors
    pollers: list[SensorPoller] = []
    if not args.no_imu:
        pollers.append(SensorPoller("imu",     read_imu,     TOPIC_IMU,     args.imu_hz, publisher))
    if not args.no_gps:
        pollers.append(SensorPoller("gps",     read_gps,     TOPIC_GPS,     args.gps_hz, publisher))
    if not args.no_battery:
        pollers.append(SensorPoller("battery", read_battery, TOPIC_BATTERY, args.bat_hz, publisher))

    for p in pollers:
        p.start()

    # Status log thread
    stop_evt = threading.Event()
    status_thread = threading.Thread(
        target=_status_logger, args=(pollers, publisher, stop_evt), daemon=True
    )
    status_thread.start()

    logging.info("Sensor dashboard running — Ctrl-C to stop.")
    try:
        while True:
            time.sleep(1.0)
    except KeyboardInterrupt:
        logging.info("Shutting down...")
    finally:
        stop_evt.set()
        for p in pollers:
            p.stop()
        publisher.shutdown()
        logging.info("Done.")


if __name__ == "__main__":
    main()