#!/usr/bin/env python3
"""
ble_alerter.py — BLE presence alerter daemon.
Passively scans for BLE devices by name, sends arrival/departure alerts to Matrix.
Replaces net_alerter's physical presence detection via passive BLE instead of ARP.

Zero active scanning. No SCAN_REQ packets transmitted. No DNS lookups.
"""

import asyncio
import json
import logging
import os
import re
import signal
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path
from bleak import BleakScanner


# --- Global config (loaded from .env) ---
MODE = "open"  # open | known
KNOWN_DEVICES = []  # Only used if MODE=="known"
DEPARTURE_TIMEOUT = 60
RSSI_MIN = -100
MATRIX_HOMESERVER = ""
MATRIX_ACCESS_TOKEN = ""
MATRIX_ROOM_ID = ""
LOG_FILE = "/opt/ble_alerter/ble_alerter.log"
LOG_LEVEL = "INFO"

# --- State ---
tracked = {}  # {device_key: {name, mac, first_seen, last_seen, rssi}}
tracked_lock = asyncio.Lock()
shutdown_event = asyncio.Event()


def setup_logging():
    """Configure logging to file and stderr."""
    log_format = "%(asctime)s [%(levelname)s] %(message)s"
    log_level = getattr(logging, LOG_LEVEL.upper(), logging.INFO)
    
    handlers = [logging.StreamHandler(sys.stderr)]
    try:
        handlers.append(logging.FileHandler(LOG_FILE, mode='a'))
    except Exception as e:
        logging.warning(f"Could not open {LOG_FILE}: {e}")
    
    logging.basicConfig(
        level=log_level,
        format=log_format,
        handlers=handlers
    )


def load_env():
    """Parse .env file manually (key=value), no dependency required."""
    global MODE, KNOWN_DEVICES, DEPARTURE_TIMEOUT, RSSI_MIN
    global MATRIX_HOMESERVER, MATRIX_ACCESS_TOKEN, MATRIX_ROOM_ID, LOG_LEVEL
    
    env_path = Path(os.getenv("BLE_ALERTER_ENV", "/opt/ble_alerter/.env"))
    
    if not env_path.exists():
        logging.warning(f".env not found at {env_path}, using env vars only")
        MODE = os.getenv("MODE", "open")
        KNOWN_DEVICES = [d.strip() for d in os.getenv("KNOWN_DEVICES", "").split(",") if d.strip()]
        DEPARTURE_TIMEOUT = int(os.getenv("DEPARTURE_TIMEOUT", "60"))
        RSSI_MIN = int(os.getenv("RSSI_MIN", "-100"))
        MATRIX_HOMESERVER = os.getenv("MATRIX_HOMESERVER", "https://m.example.org")
        MATRIX_ACCESS_TOKEN = os.getenv("MATRIX_ACCESS_TOKEN", "")
        MATRIX_ROOM_ID = os.getenv("MATRIX_ROOM_ID", "")
        LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
        return
    
    try:
        for line in env_path.read_text().splitlines():
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            if "=" not in line:
                continue
            key, val = line.split("=", 1)
            val = val.strip()
            
            if key == "MODE":
                MODE = val
            elif key == "KNOWN_DEVICES":
                KNOWN_DEVICES = [d.strip() for d in val.split(",") if d.strip()]
            elif key == "DEPARTURE_TIMEOUT":
                try:
                    DEPARTURE_TIMEOUT = int(val)
                except ValueError:
                    logging.warning(f"Invalid DEPARTURE_TIMEOUT: {val}, using default 60")
                    DEPARTURE_TIMEOUT = 60
            elif key == "RSSI_MIN":
                try:
                    RSSI_MIN = int(val)
                except ValueError:
                    logging.warning(f"Invalid RSSI_MIN: {val}, using default -100")
                    RSSI_MIN = -100
            elif key == "MATRIX_HOMESERVER":
                MATRIX_HOMESERVER = val
            elif key == "MATRIX_ACCESS_TOKEN":
                MATRIX_ACCESS_TOKEN = val
            elif key == "MATRIX_ROOM_ID":
                MATRIX_ROOM_ID = val
            elif key == "LOG_LEVEL":
                LOG_LEVEL = val
        
        logging.info(f"Loaded config from {env_path}")
    except Exception as e:
        logging.error(f"Failed to load .env: {e}")


_MAC_RE = re.compile(r'^[0-9A-Fa-f]{2}[:\-][0-9A-Fa-f]{2}[:\-][0-9A-Fa-f]{2}[:\-][0-9A-Fa-f]{2}[:\-][0-9A-Fa-f]{2}[:\-][0-9A-Fa-f]{2}$')


def is_generic_name(name):
    """
    Filter out unhelpful device names (generic manufacturer defaults, hex-only, too short).
    Return True if name should be ignored.
    """
    if not name or not isinstance(name, str):
        return True

    name = name.strip()

    # Too short
    if len(name) < 3:
        return True

    # All hex characters (looks like MAC address fragment)
    if all(c in "0123456789ABCDEFabcdef" for c in name):
        return True

    # MAC address format with colons or dashes (e.g. 45-48-39-7F-73-C7 or 45:48:39:7F:73:C7)
    if _MAC_RE.match(name):
        return True

    # Common generic patterns
    generic_patterns = [
        "LE-", "BLE-", "BT-", "BT ", "Bluetooth", "Unknown",
        "Device", "Object", "Beacon", "Sensor", "Module"
    ]
    for pattern in generic_patterns:
        if pattern.lower() in name.lower():
            return True

    return False


def fmt_duration(secs):
    """Format duration in seconds to human-readable format."""
    if secs < 60:
        return f"{int(secs)}s"
    elif secs < 3600:
        m = int(secs // 60)
        s = int(secs % 60)
        return f"{m}m {s}s" if s else f"{m}m"
    else:
        h = int(secs // 3600)
        m = int((secs % 3600) // 60)
        return f"{h}h {m}m" if m else f"{h}h"


def send_alert(msg):
    """Send alert to Matrix room. Retries up to 3 times with exponential backoff on 429/5xx."""
    if not MATRIX_ACCESS_TOKEN:
        logging.warning("No MATRIX_ACCESS_TOKEN set, skipping alert")
        return

    url = (
        f"{MATRIX_HOMESERVER}/_matrix/client/v3/rooms/"
        f"{urllib.parse.quote(MATRIX_ROOM_ID, safe='')}/send/m.room.message"
    )
    payload = json.dumps({"msgtype": "m.text", "body": msg}).encode()

    for attempt in range(3):
        req = urllib.request.Request(
            url,
            data=payload,
            headers={
                "Authorization": f"Bearer {MATRIX_ACCESS_TOKEN}",
                "Content-Type": "application/json",
                "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
            },
            method="POST",
        )
        try:
            with urllib.request.urlopen(req, timeout=10) as r:
                pass
            logging.debug("Alert sent to Matrix")
            return
        except urllib.error.HTTPError as e:
            if e.code in (429, 500, 502, 503, 504) and attempt < 2:
                wait = 2 ** attempt  # 1s, 2s
                logging.warning(f"Matrix HTTP {e.code}, retrying in {wait}s")
                time.sleep(wait)
            else:
                logging.error(f"Matrix send failed with HTTP {e.code}")
                return
        except Exception as e:
            logging.error(f"Matrix send exception: {e}")
            return


async def on_arrival(name, mac, rssi):
    """Handle BLE device arrival."""
    async with tracked_lock:
        now = time.time()
        key = name if name else mac
        
        if key not in tracked:
            # New device
            tracked[key] = {
                "name": name,
                "mac": mac,
                "first_seen": now,
                "last_seen": now,
                "rssi": rssi,
            }
            msg = f"[BLE] ARRIVED: {name} (RSSI: {rssi})" if name else f"[BLE] ARRIVED: {mac} (RSSI: {rssi})"
            logging.info(msg)
            send_alert(msg)
        else:
            # Update existing device
            tracked[key]["last_seen"] = now
            tracked[key]["rssi"] = rssi


async def on_departure(device_key):
    """Handle BLE device departure."""
    async with tracked_lock:
        if device_key in tracked:
            device = tracked[device_key]
            duration = time.time() - device["first_seen"]
            duration_str = fmt_duration(duration)
            name = device.get("name") or device.get("mac")
            msg = f"[BLE] DEPARTED: {name} — present {duration_str}"
            logging.info(msg)
            send_alert(msg)
            del tracked[device_key]


async def scan_loop():
    """Passive BLE scanner. Continuously monitors for new advertisements."""
    logging.info(f"Starting BLE scan loop (mode={MODE}, timeout={DEPARTURE_TIMEOUT}s)")
    
    async def detection_callback(device, advertisement_data):
        """Called on each BLE advertisement."""
        # Get device name (from device or advertisement)
        name = device.name or advertisement_data.local_name
        mac = device.address
        rssi = device.rssi
        
        # Apply detection filters
        if MODE == "known":
            # Only track devices in KNOWN_DEVICES list
            if not name or name not in KNOWN_DEVICES:
                return
        else:  # open mode
            # Filter generic names
            if is_generic_name(name):
                return
        
        # Apply RSSI filter (if specified)
        if rssi < RSSI_MIN:
            logging.debug(f"RSSI too weak: {name or mac} ({rssi})")
            return
        
        await on_arrival(name, mac, rssi)
    
    # Passive scanner — required to avoid corrupting BLE 0x004C manufacturer_data (bleak #1440)
    async with BleakScanner(detection_callback=detection_callback, scanning_mode="passive") as scanner:
        try:
            while not shutdown_event.is_set():
                await asyncio.sleep(1)
        except asyncio.CancelledError:
            logging.info("BLE scanner cancelled")
        except Exception as e:
            logging.error(f"BLE scanner exception: {e}")


async def timeout_checker():
    """Check for departed devices (no advertisements for DEPARTURE_TIMEOUT seconds)."""
    logging.info(f"Starting timeout checker (interval={DEPARTURE_TIMEOUT}s)")
    
    check_interval = max(10, DEPARTURE_TIMEOUT // 6)  # Check 6x per timeout
    
    while not shutdown_event.is_set():
        try:
            await asyncio.sleep(check_interval)
            
            async with tracked_lock:
                now = time.time()
                departed = []
                
                for device_key, device in list(tracked.items()):
                    time_since_last_seen = now - device["last_seen"]
                    if time_since_last_seen > DEPARTURE_TIMEOUT:
                        departed.append(device_key)
                
                # Send departure alerts (outside lock to avoid contention)
                for device_key in departed:
                    await on_departure(device_key)
        
        except asyncio.CancelledError:
            logging.info("Timeout checker cancelled")
        except Exception as e:
            logging.error(f"Timeout checker exception: {e}")


async def main():
    """Main entry point. Run scanner and timeout checker concurrently."""
    setup_logging()
    load_env()
    
    logging.info(f"BLE Alerter starting (mode={MODE}, departure_timeout={DEPARTURE_TIMEOUT}s)")
    
    # Set up signal handlers for graceful shutdown
    def signal_handler(signum, frame):
        logging.info(f"Received signal {signum}, shutting down")
        shutdown_event.set()
    
    signal.signal(signal.SIGTERM, signal_handler)
    signal.signal(signal.SIGINT, signal_handler)
    
    # Run scanner and timeout checker together
    try:
        scan_task = asyncio.create_task(scan_loop())
        timeout_task = asyncio.create_task(timeout_checker())
        
        await shutdown_event.wait()
        
        # Cancel tasks and wait for cleanup
        scan_task.cancel()
        timeout_task.cancel()
        
        try:
            await asyncio.gather(scan_task, timeout_task)
        except asyncio.CancelledError:
            pass
        
        logging.info("BLE Alerter shutdown complete")
    except Exception as e:
        logging.error(f"Fatal error: {e}", exc_info=True)
        sys.exit(1)


if __name__ == "__main__":
    asyncio.run(main())