"""Geofence zones with haversine distance, enter/exit detection, and SQLite persistence."""

from __future__ import annotations

import math
from typing import Any

from utils.database import get_db


def haversine_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    """Return distance in meters between two lat/lon points."""
    R = 6_371_000  # Earth radius in meters
    phi1 = math.radians(lat1)
    phi2 = math.radians(lat2)
    dphi = math.radians(lat2 - lat1)
    dlam = math.radians(lon2 - lon1)

    a = math.sin(dphi / 2) ** 2 + math.cos(phi1) * math.cos(phi2) * math.sin(dlam / 2) ** 2
    return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))


def _ensure_table() -> None:
    """Create geofence_zones table if it doesn't exist."""
    with get_db() as conn:
        conn.execute('''
            CREATE TABLE IF NOT EXISTS geofence_zones (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                lat REAL NOT NULL,
                lon REAL NOT NULL,
                radius_m REAL NOT NULL,
                alert_on TEXT DEFAULT 'enter_exit',
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        ''')


class GeofenceManager:
    """Manages geofence zones with enter/exit detection."""

    def __init__(self):
        self._inside: dict[str, set[int]] = {}  # entity_id -> set of zone_ids inside
        _ensure_table()

    def list_zones(self) -> list[dict]:
        with get_db() as conn:
            cursor = conn.execute(
                'SELECT id, name, lat, lon, radius_m, alert_on, created_at FROM geofence_zones ORDER BY id'
            )
            return [dict(row) for row in cursor]

    def add_zone(self, name: str, lat: float, lon: float, radius_m: float,
                 alert_on: str = 'enter_exit') -> int:
        with get_db() as conn:
            cursor = conn.execute(
                'INSERT INTO geofence_zones (name, lat, lon, radius_m, alert_on) VALUES (?, ?, ?, ?, ?)',
                (name, lat, lon, radius_m, alert_on),
            )
            return cursor.lastrowid

    def delete_zone(self, zone_id: int) -> bool:
        with get_db() as conn:
            cursor = conn.execute('DELETE FROM geofence_zones WHERE id = ?', (zone_id,))
            # Clean up inside tracking
            for entity_zones in self._inside.values():
                entity_zones.discard(zone_id)
            return cursor.rowcount > 0

    def check_position(self, entity_id: str, entity_type: str,
                       lat: float, lon: float,
                       metadata: dict[str, Any] | None = None) -> list[dict]:
        """Check entity position against all zones. Returns list of events."""
        zones = self.list_zones()
        if not zones:
            return []

        events: list[dict] = []
        prev_inside = self._inside.get(entity_id, set())
        curr_inside: set[int] = set()

        for zone in zones:
            dist = haversine_distance(lat, lon, zone['lat'], zone['lon'])
            zid = zone['id']
            if dist <= zone['radius_m']:
                curr_inside.add(zid)

                if zid not in prev_inside and zone['alert_on'] in ('enter', 'enter_exit'):
                    events.append({
                        'type': 'geofence_enter',
                        'zone_id': zid,
                        'zone_name': zone['name'],
                        'entity_id': entity_id,
                        'entity_type': entity_type,
                        'distance_m': round(dist, 1),
                        'lat': lat,
                        'lon': lon,
                        **(metadata or {}),
                    })
            else:
                if zid in prev_inside and zone['alert_on'] in ('exit', 'enter_exit'):
                    events.append({
                        'type': 'geofence_exit',
                        'zone_id': zid,
                        'zone_name': zone['name'],
                        'entity_id': entity_id,
                        'entity_type': entity_type,
                        'distance_m': round(dist, 1),
                        'lat': lat,
                        'lon': lon,
                        **(metadata or {}),
                    })

        self._inside[entity_id] = curr_inside
        return events


# Singleton
_manager: GeofenceManager | None = None


def get_geofence_manager() -> GeofenceManager:
    global _manager
    if _manager is None:
        _manager = GeofenceManager()
    return _manager