from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException, Query

from sqlalchemy import func, select

from sqlalchemy.orm import Session

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

from app.core.config import settings

from app.models import Camera, LicensePlate, PlateRead, Sighting, User, Vehicle

from app.schemas import SearchQuery

from app.services.analytics import camera_transitions, find_cotravel, movement_summary

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

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

def plate_search(q: str = Query(..., min_length=1), partial: bool = False,

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

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

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

    query = select(LicensePlate)

    if partial:

        query = query.where(LicensePlate.plate_norm.like(f"%{norm}%"))

    else:

        query = query.where(LicensePlate.plate_norm == norm)

    if state:

        query = query.where(LicensePlate.state == state.upper())

    plates = db.scalars(query.limit(100)).all()

    return [{"plate_norm": p.plate_norm, "state": p.state, "plate_raw": p.plate_raw} for p in plates]

@router.get("/states")

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

    """Per-state coverage: read count + distinct plates, joined from the plate's registration

    state. Powers the nationwide states view and lets an analyst drill into any state."""

    rows = db.execute(

        select(LicensePlate.state, func.count(PlateRead.id), func.count(func.distinct(PlateRead.plate_id)))

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

        .group_by(LicensePlate.state)

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

    ).all()

    return [{"state": r[0] or "UNK", "reads": r[1], "vehicles": r[2]} for r in rows]

@router.get("/states/{state}/plates")

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

    rows = db.execute(

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

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

        .where(LicensePlate.state == state.upper())

        .group_by(LicensePlate.plate_norm)

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

        .limit(200)

    ).all()

    return {"state": state.upper(), "plates": [{"plate_norm": r[0], "reads": r[1]} for r in rows]}

@router.get("/plates/{plate_norm}")

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

    reads = db.scalars(select(PlateRead).where(PlateRead.plate_norm == plate_norm.upper())

                       .order_by(PlateRead.read_ts)).all()

    if not reads:

        raise HTTPException(404, "no reads for plate")

    read_dicts = _read_dicts(db, reads)

    m = movement_summary(plate_norm.upper(), read_dicts)

    return {

        "plate_norm": plate_norm.upper(),

        "total_reads": m.total_reads,

        "first_seen": m.first_seen, "last_seen": m.last_seen,

        "distinct_cameras": m.distinct_cameras,

        "by_camera": m.by_camera, "by_hour": m.by_hour,

        "reads": [{"read_ts": r["read_ts"], "camera_id": r["camera_id"],

                   "confidence": r["confidence"]} for r in read_dicts],

    }

@router.post("/search")

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

    q = select(PlateRead)

    if qry.plate:

        q = q.where(PlateRead.plate_norm == "".join(c for c in qry.plate.upper() if c.isalnum()))

    if qry.partial_plate:

        p = "".join(c for c in qry.partial_plate.upper() if c.isalnum())

        q = q.where(PlateRead.plate_norm.like(f"%{p}%"))

    if qry.camera_id:

        q = q.where(PlateRead.camera_id == qry.camera_id)

    if qry.from_ts:

        q = q.where(PlateRead.read_ts >= qry.from_ts)

    if qry.to_ts:

        q = q.where(PlateRead.read_ts <= qry.to_ts)

    if qry.incident_ref:

        q = q.where(PlateRead.incident_ref == qry.incident_ref)

    reads = db.scalars(q.order_by(PlateRead.read_ts.desc()).limit(qry.limit)).all()

    if any([qry.make, qry.color, qry.body_type]):

        reads = _filter_by_vehicle(db, reads, qry)

    return {"count": len(reads),

            "results": [{"plate_norm": r.plate_norm, "read_ts": r.read_ts,

                         "camera_id": r.camera_id, "direction": r.direction,

                         "confidence": float(r.confidence) if r.confidence is not None else None,

                         "hotlist_hit": r.hotlist_hit} for r in reads]}

@router.get("/vehicles/{plate_norm}/movement")

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

    reads = db.scalars(select(PlateRead).where(PlateRead.plate_norm == plate_norm.upper())).all()

    if not reads:

        raise HTTPException(404, "no reads for plate")

    rd = _read_dicts(db, reads)

    cams = _camera_coords(db)

    m = movement_summary(plate_norm.upper(), rd, cameras=cams)

    return {

        "plate_norm": m.plate_norm, "total_reads": m.total_reads,

        "distinct_cameras": m.distinct_cameras,

        "first_seen": m.first_seen, "last_seen": m.last_seen,

        "route": [{"from": l.from_camera, "to": l.to_camera, "elapsed_s": l.elapsed_s,

                   "distance_km": l.distance_km, "speed_kmh": l.speed_kmh,

                   "implausible": l.implausible} for l in m.route],

        "dwell": [{"camera_id": d.camera_id, "start": d.start_ts, "end": d.end_ts,

                   "duration_s": d.duration_s, "reads": d.reads} for d in m.dwell],

        "anomalies": m.anomalies,

        "by_hour": m.by_hour,

    }

@router.get("/vehicles/{plate_norm}/cotravel")

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

    """Vehicles repeatedly co-located with this plate within the co-travel window -

    candidate associates. Guarded against false positives by requiring shared sightings."""

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

    by_vehicle: dict[str, list[dict]] = {}

    for r in reads:

        by_vehicle.setdefault(r.plate_norm, []).append({"camera_id": r.camera_id, "read_ts": r.read_ts})

    if plate_norm.upper() not in by_vehicle:

        raise HTTPException(404, "no reads for plate")

    candidates = find_cotravel(by_vehicle, plate_norm.upper(),

                               window_seconds=settings.cotravel_window_seconds, min_shared=2)

    return {"plate_norm": plate_norm.upper(), "window_seconds": settings.cotravel_window_seconds,

            "candidates": candidates}

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

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

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

    by_vehicle: dict[str, list[dict]] = {}

    for r in reads:

        by_vehicle.setdefault(r.plate_norm, []).append(

            {"camera_id": r.camera_id, "read_ts": r.read_ts})

    edges = [e for e in camera_transitions(by_vehicle)

             if e["from"] == camera_id or e["to"] == camera_id]

    return {"camera_id": camera_id, "transitions": edges}

def _read_dicts(db: Session, reads) -> list[dict]:

    cams = _camera_coords(db)

    out = []

    for r in reads:

        c = cams.get(r.camera_id, {})

        out.append({"plate_norm": r.plate_norm, "read_ts": r.read_ts, "camera_id": r.camera_id,

                    "confidence": float(r.confidence) if r.confidence is not None else None,

                    "lat": r.lat if r.lat is not None else c.get("lat"),

                    "lon": r.lon if r.lon is not None else c.get("lon")})

    return out

def _camera_coords(db: Session) -> dict[str, dict]:

    rows = db.execute(select(Camera.id, Camera.location_id)).all()

    coords: dict[str, dict] = {}

    from app.models import Location

    locs = {l.id: l for l in db.scalars(select(Location)).all()}

    for cam_id, loc_id in rows:

        loc = locs.get(loc_id)

        coords[cam_id] = {"lat": loc.lat if loc else None, "lon": loc.lon if loc else None}

    return coords

def _filter_by_vehicle(db: Session, reads, qry: SearchQuery):

    keep = []

    for r in reads:

        veh = db.scalar(select(Vehicle).join(LicensePlate, Vehicle.primary_plate_id == LicensePlate.id)

                        .where(LicensePlate.plate_norm == r.plate_norm))

        if not veh:

            continue

        if qry.make and (veh.make or "").lower() != qry.make.lower():

            continue

        if qry.color and (veh.color or "").lower() != qry.color.lower():

            continue

        if qry.body_type and (veh.body_type or "").lower() != qry.body_type.lower():

            continue

        keep.append(r)

    return keep