"""Live-camera ALPR sweep: run the recognition engine over live DOT snapshot feeds.

Selects cameras with has_live_feed=True (optionally filtered by id/state), fetches each

camera's current snapshot, runs recognize_bytes, and pushes every recognized plate through

ingest_live_reads as a real read tied to that camera.

HONEST LIMITATION: public wide-area traffic cams (NYC DOT, Caltrans) are low-resolution

overview shots - plates are rarely legible, so most scans find 0 plates. That is expected;

this job exists for the cameras/angles where it *does* work and as the mechanism for any

future higher-resolution feed."""

from __future__ import annotations

from datetime import datetime, timezone

from urllib.parse import urlparse

import httpx

from sqlalchemy import select

from sqlalchemy.orm import Session

from app.models import Camera, Location

FETCH_TIMEOUT = 10.0

USER_AGENT = "Mozilla/5.0 Sightline/1.0"

def _fetch_snapshot(client: httpx.Client, image_url: str) -> bytes:

    """Fetch a camera snapshot the same way the snapshot proxy does (Referer = feed origin)."""

    p = urlparse(image_url)

    referer = f"{p.scheme}://{p.netloc}/"

    r = client.get(image_url, timeout=FETCH_TIMEOUT, follow_redirects=True,

                   headers={"User-Agent": USER_AGENT, "Referer": referer})

    r.raise_for_status()

    return r.content

def scan_live_cameras(db: Session, camera_ids: list[str] | None = None, state: str | None = None,

                      limit: int = 20, min_conf: float = 0.5,

                      created_by: str | None = None) -> dict:

    """Scan a batch of live cameras for plates and ingest anything recognized.

    Resilient per camera: fetch errors, undecodable images, and zero-plate frames are all

    skipped, never fatal. Returns a summary; reads (if any) go through the normal

    normalize/dedup/watchlist pipeline via a single ingest_live_reads call."""

    from app.services.alpr import recognize_bytes

    from app.services.ingest import ingest_live_reads

    q = select(Camera).where(Camera.has_live_feed.is_(True), Camera.image_url.isnot(None))

    if camera_ids:

        q = q.where(Camera.id.in_(camera_ids))

    if state:

        q = q.where(Camera.state == state.upper())

    cams = db.scalars(q.order_by(Camera.name).limit(limit)).all()

    scanned = 0

    reads: list[dict] = []

    results: list[dict] = []

    source_id: str | None = None

    now = datetime.now(timezone.utc)

    with httpx.Client() as client:

        for cam in cams:

            try:

                data = _fetch_snapshot(client, cam.image_url)

                dets = recognize_bytes(data, min_conf=min_conf)

            except Exception:

                continue

            scanned += 1

            if not dets:

                continue

            loc = db.get(Location, cam.location_id) if cam.location_id else None

            for d in dets:

                reads.append({"plate": d.plate_norm, "state": cam.state,

                              "timestamp": now.isoformat(),

                              "camera": cam.external_camera_id,

                              "latitude": loc.lat if loc else None,

                              "longitude": loc.lon if loc else None,

                              "confidence": d.ocr_confidence})

            if source_id is None:

                source_id = cam.source_id

            results.append({"camera": cam.external_camera_id,

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

                                        "ocr_confidence": round(d.ocr_confidence, 3),

                                        "detection_confidence": round(d.detection_confidence, 3),

                                        "bbox": d.bbox} for d in dets]})

    summary = {"cameras_scanned": scanned, "cameras_with_plates": len(results),

               "plates_found": len(reads), "results": results}

    if reads:

        summary["ingest"] = ingest_live_reads(db, source_id, reads, label="live-alpr-scan",

                                              created_by=created_by)

    return summary