"""Owned Flock ALPR device API: register a user-owned Flock Safety unit and ingest from the

surfaces such a device actually exposes (no public API): snapshot images, an RTSP stream,

and Flock-style CSV/JSON export files.

  POST /flock/devices                  register the owned device (Source + Camera + Location)

  GET  /flock/devices                  list registered owned devices

  POST /flock/devices/{id}/image       multipart snapshot -> recognize + ingest reads

  POST /flock/devices/{id}/rtsp        {rtsp_url, seconds} -> sample stream + ingest reads

  POST /flock/devices/{id}/import      multipart CSV/JSON export -> parse + ingest reads

"""

from __future__ import annotations

from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile

from pydantic import BaseModel

from sqlalchemy import select

from sqlalchemy.orm import Session

from app.api.deps import Perm, get_db, require

from app.models import AuditLog, Camera, Location, User

from app.services.flock_connector import (

    LIVE_SOURCE, ingest_flock_export, ingest_flock_image, ingest_flock_rtsp,

    register_flock_device,

)

router = APIRouter(prefix="/flock", tags=["flock"])

def _device_dict(db: Session, cam: Camera) -> dict:

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

    return {"id": cam.id, "external_camera_id": cam.external_camera_id, "name": cam.name,

            "operator": cam.operator, "state": cam.state, "has_live_feed": cam.has_live_feed,

            "image_url": cam.image_url, "live_source": cam.live_source,

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

            "created_at": cam.created_at}

def _get_device(db: Session, device_id: str) -> Camera:

    cam = db.get(Camera, device_id)

    if cam is None or cam.live_source != LIVE_SOURCE:

        raise HTTPException(404, "owned flock device not found")

    return cam

class DeviceReq(BaseModel):

    name: str

    lat: float

    lon: float

    snapshot_url: str | None = None

@router.post("/devices", status_code=201)

def register_device(req: DeviceReq, db: Session = Depends(get_db),

                    user: User = Depends(require(Perm.WRITE))):

    """Register a consented, user-owned Flock unit as a Source + Camera."""

    cam = register_flock_device(db, req.name, req.lat, req.lon, snapshot_url=req.snapshot_url)

    db.add(AuditLog(actor_user_id=user.id, action="flock.register_device",

                    entity_type="camera", entity_id=cam.id,

                    meta={"name": req.name, "snapshot_url": req.snapshot_url}))

    db.commit()

    db.refresh(cam)

    return _device_dict(db, cam)

@router.get("/devices")

def list_devices(db: Session = Depends(get_db), _: User = Depends(require(Perm.READ))):

    rows = db.scalars(select(Camera).where(Camera.live_source == LIVE_SOURCE)

                      .order_by(Camera.created_at.desc())).all()

    return [_device_dict(db, c) for c in rows]

@router.post("/devices/{device_id}/image")

async def ingest_image(

    device_id: str,

    file: UploadFile = File(...),

    min_conf: float = Form(default=0.4),

    db: Session = Depends(get_db),

    user: User = Depends(require(Perm.INGEST)),

):

    """Recognize plates in a snapshot from the owned unit and create real reads."""

    cam = _get_device(db, device_id)

    data = await file.read()

    if not data:

        raise HTTPException(400, "empty image")

    try:

        result = ingest_flock_image(db, cam, data, created_by=user.id, min_conf=min_conf)

    except Exception as e:

        raise HTTPException(422, f"recognition failed: {e}")

    db.add(AuditLog(actor_user_id=user.id, action="flock.image_ingest",

                    entity_type="camera", entity_id=cam.id,

                    meta={"recognized": result.get("recognized", 0),

                          "import_id": result.get("import_id")}))

    db.commit()

    return result

class RtspReq(BaseModel):

    rtsp_url: str

    seconds: float = 15.0

    sample_fps: float = 2.0

    min_conf: float = 0.4

@router.post("/devices/{device_id}/rtsp")

def ingest_rtsp(device_id: str, req: RtspReq, db: Session = Depends(get_db),

                user: User = Depends(require(Perm.INGEST))):

    """Sample the owned unit's RTSP stream for a bounded window and ingest plate tracks."""

    cam = _get_device(db, device_id)

    if req.seconds > 120:

        raise HTTPException(400, "capture window capped at 120s")

    try:

        result = ingest_flock_rtsp(db, cam, req.rtsp_url, seconds=req.seconds,

                                   created_by=user.id, sample_fps=req.sample_fps,

                                   min_conf=req.min_conf)

    except Exception as e:

        raise HTTPException(502, f"stream capture failed: {e}")

    db.add(AuditLog(actor_user_id=user.id, action="flock.rtsp_ingest",

                    entity_type="camera", entity_id=cam.id,

                    meta={"plates": len(result.get("plates", [])), "seconds": req.seconds}))

    db.commit()

    return result

@router.post("/devices/{device_id}/import")

async def ingest_export(

    device_id: str,

    file: UploadFile = File(...),

    db: Session = Depends(get_db),

    user: User = Depends(require(Perm.INGEST)),

):

    """Ingest a Flock-style CSV/JSON export file from the owned unit."""

    cam = _get_device(db, device_id)

    data = await file.read()

    if not data:

        raise HTTPException(400, "empty file")

    try:

        result = ingest_flock_export(db, cam, data, file.filename or "export.csv",

                                     created_by=user.id, content_type=file.content_type)

    except Exception as e:

        raise HTTPException(422, f"export ingest failed: {e}")

    db.add(AuditLog(actor_user_id=user.id, action="flock.export_ingest",

                    entity_type="camera", entity_id=cam.id,

                    meta={"filename": file.filename, "inserted": result.get("inserted", 0),

                          "import_id": result.get("import_id")}))

    db.commit()

    return result