"""Video / RTSP frame path for ALPR. Samples frames from a video file or an RTSP/HTTP stream

(both via OpenCV's VideoCapture), runs the plate recognizer on each sampled frame, and aggregates

detections so each distinct plate becomes ONE read (best OCR across the frames it appeared in) -

not one read per frame. This is the temporal layer on top of the single-image engine.

"""

from __future__ import annotations

import os

import tempfile

import time

from dataclasses import dataclass, field

from app.services.alpr import recognize_array

@dataclass

class PlateTrack:

    plate_norm: str

    plate: str

    best_ocr: float

    best_det: float

    frames_seen: int

    first_ts: float

    last_ts: float

    bbox: list[int] = field(default_factory=list)

def _aggregate(per_frame: list[tuple[float, list]]) -> list[PlateTrack]:

    """per_frame: list of (timestamp_seconds, [PlateDetection,...]). Collapse by plate_norm."""

    tracks: dict[str, PlateTrack] = {}

    for ts, dets in per_frame:

        for d in dets:

            t = tracks.get(d.plate_norm)

            if t is None:

                tracks[d.plate_norm] = PlateTrack(

                    plate_norm=d.plate_norm, plate=d.plate, best_ocr=d.ocr_confidence,

                    best_det=d.detection_confidence, frames_seen=1, first_ts=ts, last_ts=ts,

                    bbox=d.bbox)

            else:

                t.frames_seen += 1

                t.last_ts = ts

                if d.ocr_confidence > t.best_ocr:

                    t.best_ocr, t.plate, t.bbox = d.ocr_confidence, d.plate, d.bbox

                t.best_det = max(t.best_det, d.detection_confidence)

    return sorted(tracks.values(), key=lambda t: (t.frames_seen, t.best_ocr), reverse=True)

def process_capture(cap, sample_fps: float = 2.0, max_frames: int = 240,

                    max_seconds: float | None = None, min_conf: float = 0.4) -> dict:

    """Drive an opened cv2.VideoCapture: sample ~sample_fps frames/sec, recognize, aggregate.

    Works identically for files and live streams."""

    import cv2

    src_fps = cap.get(cv2.CAP_PROP_FPS) or 0

    stride = max(1, int(round(src_fps / sample_fps))) if src_fps and src_fps > 0 else 0

    per_frame: list[tuple[float, list]] = []

    processed = sampled = 0

    start = time.monotonic()

    last_sample = 0.0

    idx = 0

    while True:

        ok, frame = cap.read()

        if not ok:

            break

        idx += 1

        now = time.monotonic() - start

        if max_seconds and now > max_seconds:

            break

        take = False

        if stride:

            take = (idx % stride == 0)

            ts = idx / src_fps

        else:

            if now - last_sample >= 1.0 / sample_fps:

                take, last_sample, ts = True, now, now

            else:

                ts = now

        if not take:

            continue

        sampled += 1

        try:

            dets = recognize_array(frame, min_conf=min_conf)

        except Exception:

            dets = []

        per_frame.append((round(ts, 2), dets))

        processed += 1

        if processed >= max_frames:

            break

    tracks = _aggregate(per_frame)

    return {"frames_sampled": sampled, "frames_with_detections": sum(1 for _, d in per_frame if d),

            "plates": [{"plate_norm": t.plate_norm, "plate": t.plate,

                        "ocr_confidence": round(t.best_ocr, 3), "detection_confidence": round(t.best_det, 3),

                        "frames_seen": t.frames_seen, "first_ts": t.first_ts, "last_ts": t.last_ts,

                        "bbox": t.bbox} for t in tracks]}

def process_video_bytes(data: bytes, sample_fps: float = 2.0, max_frames: int = 240,

                        min_conf: float = 0.4) -> dict:

    import cv2

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tf:

        tf.write(data)

        path = tf.name

    try:

        cap = cv2.VideoCapture(path)

        if not cap.isOpened():

            raise ValueError("could not open video (unsupported codec?)")

        try:

            return process_capture(cap, sample_fps=sample_fps, max_frames=max_frames, min_conf=min_conf)

        finally:

            cap.release()

    finally:

        try:

            os.remove(path)

        except OSError:

            pass

def open_stream(url: str):

    """Open an RTSP/HTTP(S)/file stream. Returns an opened VideoCapture or raises."""

    import cv2

    if url.lower().startswith("rtsp"):

        os.environ["OPENCV_FFMPEG_CAPTURE_OPTIONS"] = "rtsp_transport;tcp"

    else:

        os.environ.pop("OPENCV_FFMPEG_CAPTURE_OPTIONS", None)

    cap = cv2.VideoCapture(url, cv2.CAP_FFMPEG)

    if not cap.isOpened():

        cap.release()

        raise ValueError("could not open stream (check URL / reachability / codec)")

    return cap

def probe_stream(url: str) -> dict:

    """Connect and grab a single frame to verify a stream is reachable and decodable."""

    cap = open_stream(url)

    try:

        ok, frame = cap.read()

        if not ok or frame is None:

            return {"reachable": True, "decoded": False}

        h, w = frame.shape[:2]

        return {"reachable": True, "decoded": True, "width": int(w), "height": int(h)}

    finally:

        cap.release()

def process_stream(url: str, seconds: float = 15.0, sample_fps: float = 2.0,

                   max_frames: int = 120, min_conf: float = 0.4) -> dict:

    cap = open_stream(url)

    try:

        return process_capture(cap, sample_fps=sample_fps, max_frames=max_frames,

                               max_seconds=seconds, min_conf=min_conf)

    finally:

        cap.release()