from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException

from sqlalchemy import select

from sqlalchemy.orm import Session

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

from app.models import (

    Alert, AuditLog, PlateRead, Sighting, User, Watchlist, WatchlistEntry, WatchlistHit,

)

from app.schemas import WatchlistCreate, WatchlistEntryCreate

from app.services.watchlist import WatchEntry, match_all

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

@router.get("/watchlists")

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

    return db.scalars(select(Watchlist).order_by(Watchlist.created_at.desc())).all()

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

def create_watchlist(payload: WatchlistCreate, db: Session = Depends(get_db),

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

    wl = Watchlist(name=payload.name, kind=payload.kind, organization=payload.organization,

                   created_by=user.id)

    db.add(wl)

    db.flush()

    db.add(AuditLog(actor_user_id=user.id, action="watchlist.create",

                    entity_type="watchlist", entity_id=wl.id))

    db.commit()

    db.refresh(wl)

    return wl

@router.post("/watchlists/{wl_id}/entries", status_code=201)

def add_entry(wl_id: str, payload: WatchlistEntryCreate, backfill: bool = True,

              db: Session = Depends(get_db), user: User = Depends(require(Perm.MANAGE_WATCHLIST))):

    if not db.get(Watchlist, wl_id):

        raise HTTPException(404, "watchlist not found")

    norm = payload.plate_norm

    if norm:

        norm = "".join(c for c in norm.upper() if c.isalnum())

    entry = WatchlistEntry(watchlist_id=wl_id, plate_norm=norm,

                           partial_plate=payload.partial_plate, vehicle_desc=payload.vehicle_desc,

                           reason=payload.reason, expires_at=payload.expires_at)

    db.add(entry)

    db.flush()

    created_hits = 0

    if backfill:

        we = WatchEntry(id=entry.id, plate_norm=entry.plate_norm,

                        partial_plate=entry.partial_plate, vehicle_desc=entry.vehicle_desc)

        reads = db.scalars(select(PlateRead)).all()

        for r in reads:

            if match_all([we], r.plate_norm, None):

                s = db.scalar(select(Sighting).where(Sighting.plate_read_id == r.id))

                db.add(WatchlistHit(watchlist_entry_id=entry.id, plate_read_id=r.id,

                                    sighting_id=s.id if s else None, matched_on="backfill"))

                created_hits += 1

    db.add(AuditLog(actor_user_id=user.id, action="watchlist.add_entry",

                    entity_type="watchlist_entry", entity_id=entry.id,

                    meta={"backfill_hits": created_hits}))

    db.commit()

    return {"id": entry.id, "backfill_hits": created_hits}

@router.get("/watchlists/{wl_id}/entries")

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

    if not db.get(Watchlist, wl_id):

        raise HTTPException(404, "watchlist not found")

    rows = db.scalars(select(WatchlistEntry).where(WatchlistEntry.watchlist_id == wl_id)

                      .order_by(WatchlistEntry.created_at.desc())).all()

    return [{"id": e.id, "plate_norm": e.plate_norm, "partial_plate": e.partial_plate,

             "vehicle_desc": e.vehicle_desc, "reason": e.reason,

             "expires_at": e.expires_at, "created_at": e.created_at} for e in rows]

@router.get("/watchlist-hits")

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

    rows = db.execute(

        select(WatchlistHit.id, WatchlistHit.matched_on, WatchlistHit.created_at,

               PlateRead.plate_norm, PlateRead.camera_id)

        .join(PlateRead, PlateRead.id == WatchlistHit.plate_read_id)

        .order_by(WatchlistHit.created_at.desc()).limit(200)

    ).all()

    return [{"id": r[0], "matched_on": r[1], "at": r[2], "plate_norm": r[3], "camera_id": r[4]}

            for r in rows]

@router.get("/alerts")

def list_alerts(status: str | None = None, db: Session = Depends(get_db), _: User = Depends(require(Perm.READ))):

    q = select(Alert).order_by(Alert.created_at.desc()).limit(200)

    if status:

        q = q.where(Alert.status == status)

    return db.scalars(q).all()

@router.patch("/alerts/{alert_id}")

def update_alert(alert_id: int, status: str, db: Session = Depends(get_db),

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

    alert = db.get(Alert, alert_id)

    if not alert:

        raise HTTPException(404, "alert not found")

    if status not in {"new", "ack", "resolved"}:

        raise HTTPException(400, "invalid status")

    alert.status = status

    db.add(AuditLog(actor_user_id=user.id, action="alert.update",

                    entity_type="alert", entity_id=str(alert_id), meta={"status": status}))

    db.commit()

    return {"id": alert_id, "status": status}