"""Connector for a USER-OWNED Flock Safety ALPR camera (a consented device the user

physically owns). Flock units expose no public API, so this supports the realistic local

surfaces of an owned unit: an RTSP stream, a snapshot image (URL/upload), and Flock-style

CSV/JSON export files. Every path funnels into the same normalize/dedup/watchlist pipeline

(ingest_live_reads) as file imports and other live sources.

"""

from __future__ import annotations

from datetime import datetime, timezone

from sqlalchemy import select

from sqlalchemy.orm import Session

from app.models import Camera, Location, Source

from app.services.alpr import recognize_bytes

from app.services.ingest import ingest_live_reads

from app.services.normalize import build_alias_map, normalize_read

from app.services.parsers import get_parser

from app.services.video_alpr import process_stream

SOURCE_NAME = "Flock (Owned Device)"

SYSTEM_TYPE = "flock_owned"

LIVE_SOURCE = "flock_owned"

def _slug(name: str) -> str:

    s = "".join(ch if ch.isalnum() else "-" for ch in (name or "").lower())

    while "--" in s:

        s = s.replace("--", "-")

    return s.strip("-") or "device"

def _get_or_create_source(db: Session) -> Source:

    src = db.scalar(select(Source).where(Source.system_type == SYSTEM_TYPE))

    if src:

        return src

    src = Source(name=SOURCE_NAME, system_type=SYSTEM_TYPE, organization="default",

                 trust_level=1.0)

    db.add(src)

    db.flush()

    return src

def register_flock_device(db: Session, name: str, lat: float, lon: float,

                          snapshot_url: str | None = None) -> Camera:

    """Create (or fetch) the owned-Flock Source and a Camera for this physical unit.

    Idempotent on (source, external_camera_id) derived from the device name."""

    src = _get_or_create_source(db)

    ext_id = f"flock-owned-{_slug(name)}"

    cam = db.scalar(select(Camera).where(

        Camera.source_id == src.id, Camera.external_camera_id == ext_id))

    if cam:

        if snapshot_url:

            cam.image_url, cam.has_live_feed = snapshot_url, True

        db.flush()

        return cam

    loc = Location(label=name, lat=lat, lon=lon)

    db.add(loc)

    db.flush()

    cam = Camera(source_id=src.id, external_camera_id=ext_id, name=name,

                 operator="Flock Safety", live_source=LIVE_SOURCE,

                 has_live_feed=bool(snapshot_url), image_url=snapshot_url,

                 location_id=loc.id,

                 meta={"ownership": "user_owned", "consented": True})

    db.add(cam)

    db.flush()

    return cam

def _camera_loc(db: Session, camera: Camera) -> Location | None:

    return db.get(Location, camera.location_id) if camera.location_id else None

def _track_reads(db: Session, camera: Camera, plates: list[dict]) -> list[dict]:

    """Build ingest_live_reads dicts from aggregated plate tracks / detections, pinned to

    this device's identity and coordinates (reads happen where the owned unit is mounted)."""

    loc = _camera_loc(db, camera)

    now = datetime.now(timezone.utc).isoformat()

    return [{"plate": p["plate_norm"], "state": camera.state, "timestamp": now,

             "camera": camera.external_camera_id,

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

             "confidence": p["ocr_confidence"]} for p in plates]

def ingest_flock_image(db: Session, camera: Camera, image_bytes: bytes,

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

    """Snapshot path: recognize plates in one frame from the owned unit and create real reads."""

    dets = recognize_bytes(image_bytes, min_conf=min_conf)

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

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

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

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

    if not plates:

        return {"recognized": 0, "inserted": 0, "plates": []}

    reads = _track_reads(db, camera, plates)

    summary = ingest_live_reads(db, camera.source_id, reads, label="flock-owned-image",

                                created_by=created_by)

    return {"recognized": len(plates), **summary, "plates": plates}

def ingest_flock_rtsp(db: Session, camera: Camera, rtsp_url: str, seconds: float = 15.0,

                      created_by: str | None = None, sample_fps: float = 2.0,

                      min_conf: float = 0.4) -> dict:

    """RTSP path: sample the owned unit's stream for a bounded window, aggregate per-plate

    tracks, and ingest each distinct plate as one read."""

    result = process_stream(rtsp_url, seconds=seconds, sample_fps=sample_fps, min_conf=min_conf)

    if result["plates"]:

        reads = _track_reads(db, camera, result["plates"])

        result["ingest"] = ingest_live_reads(db, camera.source_id, reads,

                                             label="flock-owned-rtsp", created_by=created_by)

    return result

def ingest_flock_export(db: Session, camera: Camera, file_bytes: bytes, filename: str,

                        created_by: str | None = None,

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

    """Export path: parse a Flock-style CSV/JSON export, normalize rows, attribute them to

    this device, and ingest. Rows keep their own timestamps; coordinates fall back to the

    device location when the export omits them."""

    parsed = get_parser(filename, content_type).parse(file_bytes)

    alias = build_alias_map(parsed.headers)

    loc = _camera_loc(db, camera)

    reads: list[dict] = []

    skipped = 0

    for raw in parsed.rows:

        try:

            n = normalize_read(raw, alias, source_tz=timezone.utc)

        except Exception:

            n = None

        if n is None:

            skipped += 1

            continue

        reads.append({"plate": n.plate_norm, "state": n.state or camera.state,

                      "timestamp": n.read_ts.isoformat(),

                      "camera": camera.external_camera_id,

                      "latitude": n.lat if n.lat is not None else (loc.lat if loc else None),

                      "longitude": n.lon if n.lon is not None else (loc.lon if loc else None),

                      "confidence": n.confidence})

    if not reads:

        return {"parsed_rows": len(parsed.rows), "skipped": skipped, "inserted": 0,

                "errors": parsed.errors[:50]}

    summary = ingest_live_reads(db, camera.source_id, reads,

                                label=f"flock-owned-export-{_slug(filename)}",

                                created_by=created_by)

    return {"parsed_rows": len(parsed.rows), "skipped": skipped, **summary}