"""Profile / entity-resolution engine. Builds a unified dossier for a SUBJECT from data already

in the system (their plates -> reads -> sightings across cameras -> movement timeline + map +

detections).

Consent guardrail: a runtime scope switch. In 'consented' mode (default) the engine only resolves

and builds profiles for whitelisted, consented subjects - it cannot touch anyone else's data.

Flip to 'all' to operate over all ingested subjects.

"""

from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException

from pydantic import BaseModel

from sqlalchemy import func, or_, select

from sqlalchemy.orm import Session

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

from app.models import (

    AppSetting, AuditLog, Camera, Detection, LicensePlate, Location, Person, PlateRead, User,

)

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

SCOPE_KEY = "profile_scope"

def _norm(p: str) -> str:

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

def get_scope(db: Session) -> str:

    s = db.get(AppSetting, SCOPE_KEY)

    return (s.value or {}).get("mode", "consented") if s else "consented"

def set_scope(db: Session, mode: str) -> None:

    s = db.get(AppSetting, SCOPE_KEY) or AppSetting(key=SCOPE_KEY, value={})

    s.value = {"mode": mode}

    db.add(s)

    db.commit()

@router.get("/scope")

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

    mode = get_scope(db)

    consented = db.scalar(select(func.count()).select_from(Person).where(Person.consented.is_(True))) or 0

    return {"mode": mode, "consented_subjects": consented,

            "modes": ["consented", "all"],

            "description": ("Restricted to consented subjects only - cannot touch anyone else's data."

                            if mode == "consented" else "Operating over ALL ingested subjects.")}

class ScopeReq(BaseModel):

    mode: str

@router.put("/scope")

def update_scope(req: ScopeReq, db: Session = Depends(get_db), user: User = Depends(require(Perm.ADMIN))):

    if req.mode not in ("consented", "all"):

        raise HTTPException(400, "mode must be 'consented' or 'all'")

    set_scope(db, req.mode)

    db.add(AuditLog(actor_user_id=user.id, action="profile.scope_change",

                    entity_type="settings", entity_id=None, meta={"mode": req.mode}))

    db.commit()

    return {"mode": req.mode}

class SubjectReq(BaseModel):

    full_name: str

    plates: list[str] = []

    consented: bool = True

    notes: str | None = None

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

def create_subject(req: SubjectReq, db: Session = Depends(get_db), user: User = Depends(require(Perm.WRITE))):

    """Register a consented subject (e.g. yourself, your brother) with their plate(s)."""

    plates = [_norm(p) for p in req.plates if _norm(p)]

    p = Person(full_name=req.full_name, consented=req.consented,

               associated_plate=plates[0] if plates else None, associated_plates=plates,

               notes=req.notes, threat_level="none")

    db.add(p)

    db.flush()

    db.add(AuditLog(actor_user_id=user.id, action="profile.subject_create",

                    entity_type="person", entity_id=p.id, meta={"name": req.full_name, "consented": req.consented}))

    db.commit()

    return {"id": p.id, "full_name": p.full_name, "plates": plates, "consented": p.consented}

@router.get("/search")

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

    scope = get_scope(db)

    query = select(Person).where(Person.full_name.ilike(f"%{q}%"))

    if scope == "consented":

        query = query.where(Person.consented.is_(True))

    rows = db.scalars(query.limit(50)).all()

    return {"scope": scope,

            "results": [{"id": p.id, "full_name": p.full_name, "consented": p.consented,

                         "plates": p.associated_plates or ([p.associated_plate] if p.associated_plate else [])}

                        for p in rows]}

def _plates_for(p: Person) -> list[str]:

    pl = list(p.associated_plates or [])

    if p.associated_plate and p.associated_plate not in pl:

        pl.append(p.associated_plate)

    return [_norm(x) for x in pl if _norm(x)]

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

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

    """Build the dossier: identity + vehicles + cross-state movement (timeline + map) + detections."""

    scope = get_scope(db)

    p = db.get(Person, person_id)

    if not p:

        raise HTTPException(404, "subject not found")

    if scope == "consented" and not p.consented:

        raise HTTPException(403, "profile scope is locked to consented subjects; this subject is not consented")

    plates = _plates_for(p)

    reads = []

    if plates:

        rows = db.execute(

            select(PlateRead.plate_norm, PlateRead.read_ts, PlateRead.confidence,

                   Camera.name, Camera.operator, Camera.state, Camera.area, Location.lat, Location.lon)

            .join(Camera, Camera.id == PlateRead.camera_id, isouter=True)

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

            .where(PlateRead.plate_norm.in_(plates))

            .order_by(PlateRead.read_ts)

        ).all()

        reads = [{"plate_norm": r[0], "read_ts": r[1], "confidence": float(r[2]) if r[2] is not None else None,

                  "camera": r[3], "operator": r[4], "state": r[5], "area": r[6],

                  "lat": r[7], "lon": r[8]} for r in rows]

    states = sorted({r["state"] for r in reads if r["state"]})

    cities = sorted({r["area"] for r in reads if r["area"]})

    detections = db.scalars(select(Detection).where(Detection.plate_norm.in_(plates))

                            .order_by(Detection.read_ts.desc()).limit(50)).all() if plates else []

    db.add(AuditLog(actor_user_id=user.id, action="profile.build",

                    entity_type="person", entity_id=p.id, meta={"scope": scope, "reads": len(reads)}))

    db.commit()

    return {

        "scope": scope,

        "subject": {"id": p.id, "full_name": p.full_name, "consented": p.consented,

                    "plates": plates, "sex": p.sex, "build": p.build, "hair": p.hair,

                    "threat_level": p.threat_level, "notes": p.notes},

        "summary": {"total_reads": len(reads),

                    "first_seen": reads[0]["read_ts"] if reads else None,

                    "last_seen": reads[-1]["read_ts"] if reads else None,

                    "states_visited": states, "cities_visited": cities,

                    "distinct_cameras": len({r["camera"] for r in reads if r["camera"]})},

        "timeline": reads,

        "map_points": [{"lat": r["lat"], "lon": r["lon"], "read_ts": r["read_ts"],

                        "camera": r["camera"], "state": r["state"]} for r in reads if r["lat"]],

        "detections": [{"read_ts": d.read_ts, "clothing_top": d.clothing_top,

                        "clothing_bottom": d.clothing_bottom, "articles": d.articles,

                        "description": d.description} for d in detections],

    }