"""
GPS support for INTERCEPT via gpsd daemon.

Provides GPS location data by connecting to the gpsd daemon.
"""

from __future__ import annotations

import contextlib
import logging
import socket as _socket_mod
import threading
from dataclasses import dataclass, field
from datetime import datetime
from typing import Callable

logger = logging.getLogger("intercept.gps")


@dataclass
class GPSSatellite:
    """Individual satellite data from gpsd SKY message."""

    prn: int
    elevation: float | None = None  # degrees
    azimuth: float | None = None  # degrees
    snr: float | None = None  # dB-Hz
    used: bool = False
    constellation: str = "GPS"  # GPS, GLONASS, Galileo, BeiDou, SBAS, QZSS

    def to_dict(self) -> dict:
        return {
            "prn": self.prn,
            "elevation": self.elevation,
            "azimuth": self.azimuth,
            "snr": self.snr,
            "used": self.used,
            "constellation": self.constellation,
        }


@dataclass
class GPSSkyData:
    """Sky view data from gpsd SKY message."""

    satellites: list[GPSSatellite] = field(default_factory=list)
    hdop: float | None = None
    vdop: float | None = None
    pdop: float | None = None
    tdop: float | None = None
    gdop: float | None = None
    xdop: float | None = None
    ydop: float | None = None
    nsat: int = 0  # total visible
    usat: int = 0  # total used

    def to_dict(self) -> dict:
        return {
            "satellites": [s.to_dict() for s in self.satellites],
            "hdop": self.hdop,
            "vdop": self.vdop,
            "pdop": self.pdop,
            "tdop": self.tdop,
            "gdop": self.gdop,
            "xdop": self.xdop,
            "ydop": self.ydop,
            "nsat": self.nsat,
            "usat": self.usat,
        }


@dataclass
class GPSPosition:
    """GPS position data."""

    latitude: float
    longitude: float
    altitude: float | None = None
    speed: float | None = None  # m/s
    heading: float | None = None  # degrees
    climb: float | None = None  # m/s vertical speed
    satellites: int | None = None
    fix_quality: int = 0  # 0=unknown, 1=no fix, 2=2D fix, 3=3D fix
    timestamp: datetime | None = None
    device: str | None = None
    # Error estimates
    epx: float | None = None  # lon error (m)
    epy: float | None = None  # lat error (m)
    epv: float | None = None  # vertical error (m)
    eps: float | None = None  # speed error (m/s)
    ept: float | None = None  # time error (s)

    def to_dict(self) -> dict:
        """Convert to dictionary for JSON serialization."""
        return {
            "latitude": self.latitude,
            "longitude": self.longitude,
            "altitude": self.altitude,
            "speed": self.speed,
            "heading": self.heading,
            "climb": self.climb,
            "satellites": self.satellites,
            "fix_quality": self.fix_quality,
            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
            "device": self.device,
            "epx": self.epx,
            "epy": self.epy,
            "epv": self.epv,
            "eps": self.eps,
            "ept": self.ept,
        }


def _classify_constellation(prn: int, gnssid: int | None = None) -> str:
    """Classify satellite constellation from PRN or gnssid."""
    if gnssid is not None:
        mapping = {
            0: "GPS",
            1: "SBAS",
            2: "Galileo",
            3: "BeiDou",
            4: "IMES",
            5: "QZSS",
            6: "GLONASS",
            7: "NavIC",
        }
        return mapping.get(gnssid, "GPS")
    # Fall back to PRN range heuristic
    if 1 <= prn <= 32:
        return "GPS"
    elif 33 <= prn <= 64:
        return "SBAS"
    elif 65 <= prn <= 96:
        return "GLONASS"
    elif 120 <= prn <= 158:
        return "SBAS"
    elif 201 <= prn <= 264:
        return "BeiDou"
    elif 301 <= prn <= 336:
        return "Galileo"
    elif 193 <= prn <= 200:
        return "QZSS"
    return "GPS"


class GPSDClient:
    """
    Connects to gpsd daemon for GPS data.

    gpsd provides a unified interface for GPS devices and handles
    device management, making it ideal when gpsd is already running.
    """

    DEFAULT_HOST = "localhost"
    DEFAULT_PORT = 2947

    def __init__(self, host: str = DEFAULT_HOST, port: int = DEFAULT_PORT):
        self.host = host
        self.port = port
        self._position: GPSPosition | None = None
        self._sky: GPSSkyData | None = None
        self._lock = threading.Lock()
        self._running = False
        self._thread: threading.Thread | None = None
        self._socket: _socket_mod.socket | None = None
        self._last_update: datetime | None = None
        self._error: str | None = None
        self._callbacks: list[Callable[[GPSPosition], None]] = []
        self._sky_callbacks: list[Callable[[GPSSkyData], None]] = []
        self._device: str | None = None

    @property
    def position(self) -> GPSPosition | None:
        """Get the current GPS position."""
        with self._lock:
            return self._position

    @property
    def sky(self) -> GPSSkyData | None:
        """Get the current sky view data."""
        with self._lock:
            return self._sky

    @property
    def is_running(self) -> bool:
        """Check if the client is running."""
        return self._running

    @property
    def last_update(self) -> datetime | None:
        """Get the time of the last position update."""
        with self._lock:
            return self._last_update

    @property
    def error(self) -> str | None:
        """Get any error message."""
        with self._lock:
            return self._error

    @property
    def device_path(self) -> str:
        """Return gpsd connection info."""
        return f"gpsd://{self.host}:{self.port}"

    def add_callback(self, callback: Callable[[GPSPosition], None]) -> None:
        """Add a callback to be called on position updates."""
        if callback not in self._callbacks:
            self._callbacks.append(callback)

    def remove_callback(self, callback: Callable[[GPSPosition], None]) -> None:
        """Remove a position update callback."""
        if callback in self._callbacks:
            self._callbacks.remove(callback)

    def add_sky_callback(self, callback: Callable[[GPSSkyData], None]) -> None:
        """Add a callback to be called on sky data updates."""
        if callback not in self._sky_callbacks:
            self._sky_callbacks.append(callback)

    def remove_sky_callback(self, callback: Callable[[GPSSkyData], None]) -> None:
        """Remove a sky data update callback."""
        if callback in self._sky_callbacks:
            self._sky_callbacks.remove(callback)

    def start(self) -> bool:
        """Start receiving GPS data from gpsd."""
        import socket

        if self._running:
            return True

        try:
            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self._socket.settimeout(5.0)
            self._socket.connect((self.host, self.port))

            # Enable JSON watch mode
            watch_cmd = '?WATCH={"enable":true,"json":true}\n'
            self._socket.send(watch_cmd.encode("ascii"))

            self._running = True
            self._error = None

            self._thread = threading.Thread(target=self._read_loop, daemon=True)
            self._thread.start()

            logger.info(f"Connected to gpsd at {self.host}:{self.port}")
            print(f"[GPS] Connected to gpsd at {self.host}:{self.port}", flush=True)
            return True

        except Exception as e:
            self._error = str(e)
            logger.error(f"Failed to connect to gpsd at {self.host}:{self.port}: {e}")
            if self._socket:
                with contextlib.suppress(Exception):
                    self._socket.close()
                self._socket = None
            return False

    def stop(self) -> None:
        """Stop receiving GPS data."""
        self._running = False

        if self._socket:
            try:
                # Disable watch mode
                self._socket.send(b'?WATCH={"enable":false}\n')
                self._socket.close()
            except Exception:
                pass
            self._socket = None

        if self._thread:
            self._thread.join(timeout=2.0)
            self._thread = None

        logger.info(f"Disconnected from gpsd at {self.host}:{self.port}")

    def _read_loop(self) -> None:
        """Background thread loop for reading gpsd data."""
        import json
        import socket

        buffer = ""
        message_count = 0

        print("[GPS] gpsd read loop started", flush=True)

        while self._running and self._socket:
            try:
                self._socket.settimeout(1.0)
                data = self._socket.recv(4096)

                if not data:
                    logger.warning("gpsd connection closed")
                    with self._lock:
                        self._error = "Connection closed by gpsd"
                    break

                buffer += data.decode("ascii", errors="ignore")

                # Process complete JSON lines
                while "\n" in buffer:
                    line, buffer = buffer.split("\n", 1)
                    line = line.strip()

                    if not line:
                        continue

                    try:
                        msg = json.loads(line)
                        msg_class = msg.get("class", "")

                        message_count += 1
                        if message_count <= 5 or message_count % 20 == 0:
                            print(f"[GPS] gpsd msg [{message_count}]: {msg_class}", flush=True)

                        if msg_class == "TPV":
                            self._handle_tpv(msg)
                        elif msg_class == "SKY":
                            self._handle_sky(msg)
                        elif msg_class == "DEVICES":
                            # Track connected device
                            devices = msg.get("devices", [])
                            if devices:
                                self._device = devices[0].get("path", "unknown")
                                print(f"[GPS] gpsd device: {self._device}", flush=True)

                    except json.JSONDecodeError:
                        logger.debug(f"Invalid JSON from gpsd: {line[:50]}")
                    except Exception as parse_err:
                        logger.error(f"Error handling gpsd {msg_class} message: {parse_err}")

            except socket.timeout:
                continue
            except Exception as e:
                logger.error(f"gpsd read error: {e}")
                with self._lock:
                    self._error = str(e)
                break

    def _handle_tpv(self, msg: dict) -> None:
        """Handle TPV (Time-Position-Velocity) message from gpsd."""
        # mode: 0=unknown, 1=no fix, 2=2D fix, 3=3D fix
        mode = msg.get("mode", 0)

        if mode < 2:
            # No fix yet
            return

        lat = msg.get("lat")
        lon = msg.get("lon")

        if lat is None or lon is None:
            return

        # Parse timestamp
        timestamp = None
        time_str = msg.get("time")
        if time_str:
            with contextlib.suppress(ValueError, AttributeError):
                # gpsd uses ISO format: 2024-01-01T12:00:00.000Z
                timestamp = datetime.fromisoformat(time_str.replace("Z", "+00:00"))

        position = GPSPosition(
            latitude=lat,
            longitude=lon,
            altitude=msg.get("alt"),
            speed=msg.get("speed"),  # m/s in gpsd
            heading=msg.get("track"),
            climb=msg.get("climb"),
            fix_quality=mode,
            timestamp=timestamp,
            device=self._device or f"gpsd://{self.host}:{self.port}",
            epx=msg.get("epx"),
            epy=msg.get("epy"),
            epv=msg.get("epv"),
            eps=msg.get("eps"),
            ept=msg.get("ept"),
        )

        print(f"[GPS] gpsd FIX: {lat:.6f}, {lon:.6f} (mode: {mode})", flush=True)
        self._update_position(position)

    def _handle_sky(self, msg: dict) -> None:
        """Handle SKY (satellite sky view) message from gpsd.

        gpsd sends multiple SKY messages per cycle: some contain only DOP
        values while others include the full satellites array.  When a
        DOP-only SKY arrives, preserve the most recent satellite list
        instead of overwriting it with an empty one.
        """
        raw_sats = msg.get("satellites", [])
        has_satellites = len(raw_sats) > 0

        if has_satellites:
            sats = []
            for sat in raw_sats:
                prn = sat.get("PRN", 0)
                gnssid = sat.get("gnssid")
                sats.append(
                    GPSSatellite(
                        prn=prn,
                        elevation=sat.get("el"),
                        azimuth=sat.get("az"),
                        snr=sat.get("ss"),
                        used=sat.get("used", False),
                        constellation=_classify_constellation(prn, gnssid),
                    )
                )
        else:
            # DOP-only SKY message — keep existing satellites
            with self._lock:
                sats = list(self._sky.satellites) if self._sky else []

        sky_data = GPSSkyData(
            satellites=sats,
            hdop=msg.get("hdop"),
            vdop=msg.get("vdop"),
            pdop=msg.get("pdop"),
            tdop=msg.get("tdop"),
            gdop=msg.get("gdop"),
            xdop=msg.get("xdop"),
            ydop=msg.get("ydop"),
            nsat=len(sats),
            usat=sum(1 for s in sats if s.used),
        )

        with self._lock:
            self._sky = sky_data

        # Notify sky callbacks
        for callback in self._sky_callbacks:
            try:
                callback(sky_data)
            except Exception as e:
                logger.error(f"GPS sky callback error: {e}")

    def _update_position(self, position: GPSPosition) -> None:
        """Update the current position and notify callbacks."""
        with self._lock:
            self._position = position
            self._last_update = datetime.utcnow()
            self._error = None

        # Notify callbacks
        for callback in self._callbacks:
            try:
                callback(position)
            except Exception as e:
                logger.error(f"GPS callback error: {e}")


# Global GPS client instance
_gps_client: GPSDClient | None = None
_gps_lock = threading.Lock()


def get_gps_reader() -> GPSDClient | None:
    """Get the global GPS client instance."""
    with _gps_lock:
        return _gps_client


def start_gpsd(
    host: str = "localhost",
    port: int = 2947,
    callback: Callable[[GPSPosition], None] | None = None,
    sky_callback: Callable[[GPSSkyData], None] | None = None,
) -> bool:
    """
    Start the global GPS client connected to gpsd.

    Args:
        host: gpsd host (default localhost)
        port: gpsd port (default 2947)
        callback: Optional callback for position updates
        sky_callback: Optional callback for sky data updates

    Returns:
        True if started successfully
    """
    global _gps_client

    with _gps_lock:
        # Stop existing client if any
        if _gps_client:
            _gps_client.stop()

        _gps_client = GPSDClient(host, port)

        # Register callbacks BEFORE starting to avoid race condition
        if callback:
            _gps_client.add_callback(callback)
        if sky_callback:
            _gps_client.add_sky_callback(sky_callback)

        return _gps_client.start()


def stop_gps() -> None:
    """Stop the global GPS client."""
    global _gps_client

    with _gps_lock:
        if _gps_client:
            _gps_client.stop()
            _gps_client = None


def get_current_position() -> GPSPosition | None:
    """Get the current GPS position from the global client."""
    client = get_gps_reader()
    if client:
        return client.position
    return None


# ============================================
# GPS device detection and gpsd auto-start
# ============================================

_gpsd_process: subprocess.Popen | None = None
_gpsd_process_lock = threading.RLock()


def detect_gps_devices() -> list[dict]:
    """
    Detect connected GPS serial devices.

    Returns list of dicts with 'path' and 'description' keys.
    """
    import glob
    import os
    import platform

    devices: list[dict] = []
    system = platform.system()

    if system == "Linux":
        # Common USB GPS device paths
        patterns = ["/dev/ttyUSB*", "/dev/ttyACM*"]
        for pattern in patterns:
            for path in sorted(glob.glob(pattern)):
                desc = _describe_device_linux(path)
                devices.append({"path": path, "description": desc})

        # Also check /dev/serial/by-id for descriptive names
        serial_dir = "/dev/serial/by-id"
        if os.path.isdir(serial_dir):
            for name in sorted(os.listdir(serial_dir)):
                full = os.path.join(serial_dir, name)
                real = os.path.realpath(full)
                # Skip if we already found this device
                if any(d["path"] == real for d in devices):
                    # Update description with the more descriptive name
                    for d in devices:
                        if d["path"] == real:
                            d["description"] = name
                    continue
                devices.append({"path": real, "description": name})

    elif system == "Darwin":
        # macOS: USB serial devices (prefer cu. over tty. for outgoing)
        patterns = ["/dev/cu.usbmodem*", "/dev/cu.usbserial*"]
        for pattern in patterns:
            for path in sorted(glob.glob(pattern)):
                desc = _describe_device_macos(path)
                devices.append({"path": path, "description": desc})

    # Sort: devices with GPS-related descriptions first
    gps_keywords = ("gps", "gnss", "u-blox", "ublox", "nmea", "sirf", "navigation")
    devices.sort(key=lambda d: (0 if any(k in d["description"].lower() for k in gps_keywords) else 1))

    return devices


def _describe_device_linux(path: str) -> str:
    """Get a human-readable description of a Linux serial device."""
    import os

    basename = os.path.basename(path)
    # Try to read from sysfs
    try:
        # /sys/class/tty/ttyUSB0/device/../product
        sysfs = f"/sys/class/tty/{basename}/device/../product"
        if os.path.exists(sysfs):
            with open(sysfs) as f:
                return f.read().strip()
    except Exception:
        pass
    return basename


def _describe_device_macos(path: str) -> str:
    """Get a description of a macOS serial device."""
    import os

    return os.path.basename(path)


def is_gpsd_running(host: str = "localhost", port: int = 2947) -> bool:
    """Check if gpsd is reachable."""
    import socket

    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(1.0)
        sock.connect((host, port))
        sock.close()
        return True
    except Exception:
        return False


def start_gpsd_daemon(device_path: str, host: str = "localhost", port: int = 2947) -> tuple[bool, str]:
    """
    Start gpsd daemon pointing at the given device.

    Returns (success, message) tuple.
    """
    import shutil
    import subprocess

    global _gpsd_process

    with _gpsd_process_lock:
        # Already running?
        if is_gpsd_running(host, port):
            return True, "gpsd already running"

        gpsd_bin = shutil.which("gpsd")
        if not gpsd_bin:
            return False, "gpsd not installed"

        # Stop any existing managed process
        stop_gpsd_daemon()

        try:
            import os

            if not os.path.exists(device_path):
                return False, f"Device {device_path} not found"

            cmd = [gpsd_bin, "-N", "-n", "-S", str(port), device_path]
            logger.info(f"Starting gpsd: {' '.join(cmd)}")
            print(f"[GPS] Starting gpsd: {' '.join(cmd)}", flush=True)

            _gpsd_process = subprocess.Popen(
                cmd,
                stdout=subprocess.DEVNULL,
                stderr=subprocess.PIPE,
            )

            # Give gpsd a moment to start
            import time

            time.sleep(1.5)

            if _gpsd_process.poll() is not None:
                stderr = ""
                if _gpsd_process.stderr:
                    stderr = _gpsd_process.stderr.read().decode("utf-8", errors="ignore").strip()
                msg = f"gpsd exited with code {_gpsd_process.returncode}"
                if stderr:
                    msg += f": {stderr}"
                return False, msg

            # Verify it's listening
            if is_gpsd_running(host, port):
                return True, f"gpsd started on {device_path}"
            else:
                return False, "gpsd started but not accepting connections"

        except Exception as e:
            logger.error(f"Failed to start gpsd: {e}")
            return False, str(e)


def stop_gpsd_daemon() -> None:
    """Stop the managed gpsd daemon process."""
    global _gpsd_process

    with _gpsd_process_lock:
        if _gpsd_process and _gpsd_process.poll() is None:
            try:
                _gpsd_process.terminate()
                _gpsd_process.wait(timeout=3.0)
            except Exception:
                with contextlib.suppress(Exception):
                    _gpsd_process.kill()
            logger.info("Stopped gpsd daemon")
            print("[GPS] Stopped gpsd daemon", flush=True)
        _gpsd_process = None