from __future__ import annotations

import httpx

from fastapi import APIRouter, Depends, HTTPException, Query, Response

from sqlalchemy import func, select

from sqlalchemy.orm import Session

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

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

router = APIRouter(tags=["cameras"])

@router.get("/cameras/live")

def live_cameras(state: str | None = None, q: str | None = None, limit: int = 120, offset: int = 0,

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

    """Cameras that expose a real live snapshot feed (e.g. NYC DOT). Each returns a same-origin

    snapshot_url (proxied) the UI can render and refresh."""

    base = select(Camera, Location).join(Location, Camera.location_id == Location.id, isouter=True)\

        .where(Camera.has_live_feed.is_(True))

    if state:

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

    if q:

        base = base.where(Camera.name.ilike(f"%{q}%"))

    total = db.scalar(select(func.count()).select_from(

        select(Camera).where(Camera.has_live_feed.is_(True)).subquery()))

    rows = db.execute(base.order_by(Camera.name).limit(min(limit, 300)).offset(offset)).all()

    return {"total": total, "limit": limit, "offset": offset,

            "cameras": [{"id": c.id, "name": c.name, "operator": c.operator, "area": c.area,

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

                         "online": (c.meta or {}).get("online", True),

                         "snapshot_url": f"/api/v1/cameras/{c.id}/snapshot",

                         "live_source": c.live_source} for c, loc in rows]}

_SNAP_CACHE: dict[str, tuple] = {}

_SNAP_TTL = 18.0

@router.get("/cameras/{camera_id}/snapshot")

def camera_snapshot(camera_id: str, db: Session = Depends(get_db)):

    """Proxy + cache the camera's live snapshot (public DOT imagery). Public + cacheable so the UI

    can refresh it in an <img> without auth headers. Upstream is hit at most once per TTL."""

    import time

    now = time.time()

    hit = _SNAP_CACHE.get(camera_id)

    if hit and now - hit[0] < _SNAP_TTL:

        return Response(content=hit[1], media_type=hit[2],

                        headers={"Cache-Control": f"public, max-age={int(_SNAP_TTL)}"})

    cam = db.get(Camera, camera_id)

    if not cam or not cam.has_live_feed or not cam.image_url:

        raise HTTPException(404, "no live feed for this camera")

    from urllib.parse import urlparse

    p = urlparse(cam.image_url)

    try:

        r = httpx.get(cam.image_url, timeout=12, follow_redirects=True,

                      headers={"User-Agent": "Mozilla/5.0 Sightline/1.0",

                               "Referer": f"{p.scheme}://{p.netloc}/"})

        r.raise_for_status()

        ctype = r.headers.get("content-type", "image/jpeg")

        if not ctype.startswith("image"):

            raise ValueError("not an image")

    except Exception:

        if hit:

            return Response(content=hit[1], media_type=hit[2],

                            headers={"Cache-Control": "public, max-age=10"})

        raise HTTPException(502, "snapshot unavailable")

    _SNAP_CACHE[camera_id] = (now, r.content, ctype)

    if len(_SNAP_CACHE) > 4000:

        for k in list(_SNAP_CACHE)[:1000]:

            _SNAP_CACHE.pop(k, None)

    return Response(content=r.content, media_type=ctype,

                    headers={"Cache-Control": f"public, max-age={int(_SNAP_TTL)}"})

@router.get("/cameras")

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

    rows = db.scalars(select(Camera).limit(1000)).all()

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

@router.get("/cameras/map")

def camera_map(bbox: str | None = Query(default=None, description="min_lon,min_lat,max_lon,max_lat"),

               state: str | None = None, operator: str | None = None, limit: int = 20000,

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

    """All camera points for the map. Efficient single join (no per-camera counts) so it scales

    to the full ~9.5k real-camera network; the frontend clusters them."""

    q = (select(Camera.id, Camera.name, Camera.operator, Camera.state, Camera.zone,

                Camera.direction_facing, Location.lat, Location.lon)

         .join(Location, Camera.location_id == Location.id)

         .where(Location.lat.isnot(None)))

    if state:

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

    if operator:

        q = q.where(Camera.operator.ilike(f"%{operator}%"))

    if bbox:

        b = [float(x) for x in bbox.split(",")]

        q = q.where(Location.lon >= b[0], Location.lat >= b[1], Location.lon <= b[2], Location.lat <= b[3])

    rows = db.execute(q.limit(limit)).all()

    return {"type": "camera_map", "count": len(rows),

            "cameras": [{"camera_id": r[0], "name": r[1], "operator": r[2], "state": r[3],

                         "zone": r[4], "direction_facing": r[5], "lat": r[6], "lon": r[7]} for r in rows]}

@router.get("/cameras/{camera_id}")

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

    cam = db.get(Camera, camera_id)

    if not cam:

        raise HTTPException(404, "camera not found")

    count = db.scalar(select(func.count()).where(PlateRead.camera_id == cam.id)) or 0

    return {**_camera_dict(db, cam), "read_count": count}

def _camera_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,

            "direction_facing": cam.direction_facing,

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

            "address": loc.address if loc else None}