"""Omni-search and person/detection intelligence. One query box that searches across plates,

persons (by name/alias), vehicles (make/model/color/body), detections (clothing/articles), and

cameras (operator/name) - plus type-specific faceted endpoints and a paginated camera grid."""

from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException, Query

from sqlalchemy import String, cast, func, or_, select

from sqlalchemy.orm import Session

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

from app.models import (

    Camera, Detection, LicensePlate, Location, Person, PlateRead, Sighting, User, Vehicle,

)

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

def _norm_plate(q: str) -> str:

    return "".join(ch for ch in q.upper() if ch.isalnum())

@router.get("/search/omni")

def omni_search(q: str = Query(..., min_length=1), limit: int = 8,

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

    """Search anything: a plate, a person's name, a vehicle make/model/color, an article of

    clothing, or a camera. Returns grouped, ranked results."""

    like = f"%{q}%"

    np = _norm_plate(q)

    plates = db.execute(

        select(LicensePlate.plate_norm, LicensePlate.state, func.count(PlateRead.id))

        .join(PlateRead, PlateRead.plate_id == LicensePlate.id, isouter=True)

        .where(LicensePlate.plate_norm.like(f"%{np}%") if np else False)

        .group_by(LicensePlate.plate_norm, LicensePlate.state)

        .order_by(func.count(PlateRead.id).desc()).limit(limit)

    ).all() if np else []

    persons = db.scalars(

        select(Person).where(or_(Person.full_name.ilike(like),

                                 cast(Person.aliases, String).ilike(like)))

        .limit(limit)

    ).all()

    vehicles = db.execute(

        select(Vehicle, LicensePlate.plate_norm)

        .join(LicensePlate, Vehicle.primary_plate_id == LicensePlate.id, isouter=True)

        .where(or_(Vehicle.make.ilike(like), Vehicle.model.ilike(like),

                   Vehicle.color.ilike(like), Vehicle.body_type.ilike(like)))

        .limit(limit)

    ).all()

    detections = db.scalars(

        select(Detection).where(or_(

            Detection.clothing_top.ilike(like), Detection.clothing_bottom.ilike(like),

            Detection.description.ilike(like),

            cast(Detection.articles, String).ilike(like)))

        .order_by(Detection.read_ts.desc()).limit(limit)

    ).all()

    cameras = db.scalars(

        select(Camera).where(or_(Camera.operator.ilike(like), Camera.name.ilike(like),

                                 Camera.state.ilike(q)))

        .limit(limit)

    ).all()

    return {

        "query": q,

        "plates": [{"plate_norm": p[0], "state": p[1], "reads": p[2]} for p in plates],

        "persons": [{"id": p.id, "full_name": p.full_name, "aliases": p.aliases,

                     "threat_level": p.threat_level, "wanted": p.wanted,

                     "associated_plate": p.associated_plate} for p in persons],

        "vehicles": [{"plate_norm": v[1], "make": v[0].make, "model": v[0].model,

                      "color": v[0].color, "body_type": v[0].body_type} for v in vehicles],

        "detections": [{"id": d.id, "clothing_top": d.clothing_top, "clothing_bottom": d.clothing_bottom,

                        "articles": d.articles, "description": d.description,

                        "plate_norm": d.plate_norm, "read_ts": d.read_ts} for d in detections],

        "cameras": [{"id": c.id, "name": c.name, "operator": c.operator, "state": c.state} for c in cameras],

    }

@router.get("/persons/search")

def persons_search(q: str = Query(..., min_length=1), db: Session = Depends(get_db),

                   _: User = Depends(require(Perm.READ))):

    like = f"%{q}%"

    rows = db.scalars(select(Person).where(Person.full_name.ilike(like)).limit(50)).all()

    return [{"id": p.id, "full_name": p.full_name, "aliases": p.aliases,

             "threat_level": p.threat_level, "wanted": p.wanted,

             "associated_plate": p.associated_plate} for p in rows]

@router.get("/persons/{person_id}")

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

    p = db.get(Person, person_id)

    if not p:

        raise HTTPException(404, "person not found")

    dets = db.scalars(select(Detection).where(Detection.person_id == person_id)

                      .order_by(Detection.read_ts.desc()).limit(100)).all()

    return {

        "id": p.id, "full_name": p.full_name, "aliases": p.aliases, "dob": p.dob, "sex": p.sex,

        "height_cm": p.height_cm, "build": p.build, "hair": p.hair, "eyes": p.eyes,

        "distinguishing_marks": p.distinguishing_marks, "associated_plate": p.associated_plate,

        "threat_level": p.threat_level, "wanted": p.wanted, "notes": p.notes,

        "detections": [{"id": d.id, "read_ts": d.read_ts, "camera_id": d.camera_id,

                        "clothing_top": d.clothing_top, "clothing_bottom": d.clothing_bottom,

                        "articles": d.articles, "occupant_role": d.occupant_role,

                        "description": d.description, "plate_norm": d.plate_norm} for d in dets],

    }

@router.get("/detections/search")

def detections_search(clothing: str | None = None, article: str | None = None,

                      q: str | None = None, db: Session = Depends(get_db),

                      _: User = Depends(require(Perm.READ))):

    """Search detections by clothing color, article of clothing, or free text."""

    query = select(Detection)

    if clothing:

        query = query.where(or_(Detection.clothing_top.ilike(f"%{clothing}%"),

                                Detection.clothing_bottom.ilike(f"%{clothing}%")))

    if article:

        query = query.where(cast(Detection.articles, String).ilike(f"%{article}%"))

    if q:

        query = query.where(Detection.description.ilike(f"%{q}%"))

    rows = db.scalars(query.order_by(Detection.read_ts.desc()).limit(100)).all()

    return [{"id": d.id, "person_id": d.person_id, "read_ts": d.read_ts, "camera_id": d.camera_id,

             "clothing_top": d.clothing_top, "clothing_bottom": d.clothing_bottom,

             "articles": d.articles, "occupant_role": d.occupant_role,

             "description": d.description, "plate_norm": d.plate_norm} for d in rows]

@router.get("/vehicles/search")

def vehicles_search(make: str | None = None, model: str | None = None, color: str | None = None,

                    body_type: str | None = None, db: Session = Depends(get_db),

                    _: User = Depends(require(Perm.READ))):

    query = select(Vehicle, LicensePlate.plate_norm, LicensePlate.state).join(

        LicensePlate, Vehicle.primary_plate_id == LicensePlate.id, isouter=True)

    if make:

        query = query.where(Vehicle.make.ilike(f"%{make}%"))

    if model:

        query = query.where(Vehicle.model.ilike(f"%{model}%"))

    if color:

        query = query.where(Vehicle.color.ilike(f"%{color}%"))

    if body_type:

        query = query.where(Vehicle.body_type.ilike(f"%{body_type}%"))

    rows = db.execute(query.limit(200)).all()

    return [{"plate_norm": r[1], "state": r[2], "make": r[0].make, "model": r[0].model,

             "color": r[0].color, "body_type": r[0].body_type, "year": r[0].year} for r in rows]

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

def cameras_grid(state: str | None = None, operator: str | None = None, q: str | None = None,

                 limit: int = 60, offset: int = 0, db: Session = Depends(get_db),

                 _: User = Depends(require(Perm.READ))):

    """Paginated, filterable camera grid."""

    base = select(Camera)

    if state:

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

    if operator:

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

    if q:

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

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

    cams = db.scalars(base.order_by(Camera.state, Camera.name).limit(min(limit, 200)).offset(offset)).all()

    out = []

    for c in cams:

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

        reads = db.scalar(select(func.count()).select_from(PlateRead).where(PlateRead.camera_id == c.id)) or 0

        out.append({"id": c.id, "name": c.name, "operator": c.operator, "state": c.state,

                    "zone": c.zone, "direction_facing": c.direction_facing,

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

                    "reads": reads, "has_live_feed": bool(c.has_live_feed),

                    "snapshot_url": f"/api/v1/cameras/{c.id}/snapshot" if c.has_live_feed else None})

    return {"total": total, "limit": limit, "offset": offset, "cameras": out}

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

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

    rows = db.execute(select(Camera.operator, func.count()).group_by(Camera.operator)

                      .order_by(func.count().desc())).all()

    return [{"operator": r[0] or "Unknown", "count": r[1]} for r in rows]