"""ALPR movement intelligence. Pure functions over read dicts so they are unit-testable

without a database. A 'read' is a dict with at least:

    {plate_norm, read_ts (datetime, tz-aware), camera_id, lat, lon, confidence}

"""

from __future__ import annotations

import math

from collections import Counter, defaultdict

from dataclasses import dataclass, field

from datetime import datetime

def haversine_km(lat1, lon1, lat2, lon2) -> float | None:

    if None in (lat1, lon1, lat2, lon2):

        return None

    r = 6371.0

    p1, p2 = math.radians(lat1), math.radians(lat2)

    dphi = math.radians(lat2 - lat1)

    dlam = math.radians(lon2 - lon1)

    a = math.sin(dphi / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dlam / 2) ** 2

    return 2 * r * math.asin(math.sqrt(a))

def first_last_seen(reads: list[dict]) -> dict:

    if not reads:

        return {"first_seen": None, "last_seen": None, "count": 0}

    ts = sorted(r["read_ts"] for r in reads)

    return {"first_seen": ts[0], "last_seen": ts[-1], "count": len(reads)}

def sightings_by_camera(reads: list[dict]) -> list[dict]:

    c = Counter(r.get("camera_id") for r in reads)

    return [{"camera_id": k, "count": v} for k, v in c.most_common()]

def frequency_by_hour(reads: list[dict]) -> dict[int, int]:

    """Time-of-day histogram - surfaces home/work anchor patterns."""

    hist: dict[int, int] = defaultdict(int)

    for r in reads:

        hist[r["read_ts"].hour] += 1

    return dict(sorted(hist.items()))

@dataclass

class RouteLeg:

    from_camera: str | None

    to_camera: str | None

    depart_ts: datetime

    arrive_ts: datetime

    elapsed_s: float

    distance_km: float | None

    speed_kmh: float | None

    implausible: bool

def reconstruct_route(reads: list[dict], cameras: dict[str, dict] | None = None,

                      impossible_speed_kmh: float = 250.0) -> list[RouteLeg]:

    """Order reads by time and emit camera->camera legs with elapsed time, distance, speed.

    `cameras` maps camera_id -> {lat, lon} for distance when reads lack coordinates."""

    cameras = cameras or {}

    ordered = sorted(reads, key=lambda r: r["read_ts"])

    legs: list[RouteLeg] = []

    for a, b in zip(ordered, ordered[1:]):

        elapsed = (b["read_ts"] - a["read_ts"]).total_seconds()

        la, lo = _coord(a, cameras)

        lb, lob = _coord(b, cameras)

        dist = haversine_km(la, lo, lb, lob)

        speed = (dist / (elapsed / 3600.0)) if (dist is not None and elapsed > 0) else None

        legs.append(RouteLeg(

            from_camera=a.get("camera_id"), to_camera=b.get("camera_id"),

            depart_ts=a["read_ts"], arrive_ts=b["read_ts"], elapsed_s=elapsed,

            distance_km=dist, speed_kmh=speed,

            implausible=bool(speed is not None and speed > impossible_speed_kmh),

        ))

    return legs

def _coord(read: dict, cameras: dict[str, dict]):

    if read.get("lat") is not None and read.get("lon") is not None:

        return read["lat"], read["lon"]

    cam = cameras.get(read.get("camera_id"))

    if cam:

        return cam.get("lat"), cam.get("lon")

    return None, None

@dataclass

class DwellEpisode:

    camera_id: str | None

    start_ts: datetime

    end_ts: datetime

    duration_s: float

    reads: int

def detect_dwell(reads: list[dict], gap_seconds: int = 1800) -> list[DwellEpisode]:

    """Consecutive reads at the same camera within `gap_seconds` form a dwell episode."""

    ordered = sorted(reads, key=lambda r: r["read_ts"])

    episodes: list[DwellEpisode] = []

    cur: list[dict] = []

    for r in ordered:

        if not cur:

            cur = [r]

            continue

        same_cam = r.get("camera_id") == cur[-1].get("camera_id")

        within = (r["read_ts"] - cur[-1]["read_ts"]).total_seconds() <= gap_seconds

        if same_cam and within:

            cur.append(r)

        else:

            episodes.append(_episode(cur))

            cur = [r]

    if cur:

        episodes.append(_episode(cur))

    return [e for e in episodes if e.reads > 1 or e.duration_s > 0]

def _episode(group: list[dict]) -> DwellEpisode:

    start, end = group[0]["read_ts"], group[-1]["read_ts"]

    return DwellEpisode(camera_id=group[0].get("camera_id"), start_ts=start, end_ts=end,

                        duration_s=(end - start).total_seconds(), reads=len(group))

def camera_transitions(reads_by_vehicle: dict[str, list[dict]]) -> list[dict]:

    """Directed camera->camera transition graph aggregated across vehicles."""

    edges: Counter = Counter()

    for reads in reads_by_vehicle.values():

        ordered = sorted(reads, key=lambda r: r["read_ts"])

        for a, b in zip(ordered, ordered[1:]):

            if a.get("camera_id") and b.get("camera_id") and a["camera_id"] != b["camera_id"]:

                edges[(a["camera_id"], b["camera_id"])] += 1

    return [{"from": f, "to": t, "weight": w} for (f, t), w in edges.most_common()]

def find_cotravel(reads_by_vehicle: dict[str, list[dict]], target_plate: str,

                  window_seconds: int = 120, min_shared: int = 2) -> list[dict]:

    """Vehicles repeatedly seen at the same camera within `window_seconds` of the target."""

    target = reads_by_vehicle.get(target_plate, [])

    results: list[dict] = []

    for plate, reads in reads_by_vehicle.items():

        if plate == target_plate:

            continue

        shared = 0

        for tr in target:

            for r in reads:

                if r.get("camera_id") == tr.get("camera_id") and \

                   abs((r["read_ts"] - tr["read_ts"]).total_seconds()) <= window_seconds:

                    shared += 1

                    break

        if shared >= min_shared:

            results.append({"plate_norm": plate, "shared_sightings": shared})

    return sorted(results, key=lambda x: x["shared_sightings"], reverse=True)

def possible_duplicate_plates(reads: list[dict], impossible_speed_kmh: float = 250.0,

                              cameras: dict[str, dict] | None = None) -> list[dict]:

    """Impossible-travel detector: legs faster than physically plausible suggest a misread

    or a cloned/duplicated plate."""

    flags = []

    for leg in reconstruct_route(reads, cameras, impossible_speed_kmh):

        if leg.implausible:

            flags.append({

                "from_camera": leg.from_camera, "to_camera": leg.to_camera,

                "depart_ts": leg.depart_ts, "arrive_ts": leg.arrive_ts,

                "speed_kmh": round(leg.speed_kmh, 1) if leg.speed_kmh else None,

                "reason": "impossible_travel_speed",

            })

    return flags

@dataclass

class MovementSummary:

    plate_norm: str

    first_seen: datetime | None

    last_seen: datetime | None

    total_reads: int

    distinct_cameras: int

    by_camera: list[dict] = field(default_factory=list)

    by_hour: dict[int, int] = field(default_factory=dict)

    route: list[RouteLeg] = field(default_factory=list)

    dwell: list[DwellEpisode] = field(default_factory=list)

    anomalies: list[dict] = field(default_factory=list)

def movement_summary(plate_norm: str, reads: list[dict], cameras: dict[str, dict] | None = None,

                     impossible_speed_kmh: float = 250.0, dwell_gap_seconds: int = 1800) -> MovementSummary:

    fl = first_last_seen(reads)

    return MovementSummary(

        plate_norm=plate_norm,

        first_seen=fl["first_seen"], last_seen=fl["last_seen"], total_reads=fl["count"],

        distinct_cameras=len({r.get("camera_id") for r in reads if r.get("camera_id")}),

        by_camera=sightings_by_camera(reads),

        by_hour=frequency_by_hour(reads),

        route=reconstruct_route(reads, cameras, impossible_speed_kmh),

        dwell=detect_dwell(reads, dwell_gap_seconds),

        anomalies=possible_duplicate_plates(reads, impossible_speed_kmh, cameras),

    )