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_current_user, get_db, require

from app.models import (

    AuditLog, EntityRelationship, Investigation, Note, PlateRead, Sighting, User,

)

from app.schemas import InvestigationCreate, InvestigationOut, NoteCreate

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

@router.get("", response_model=list[InvestigationOut])

def list_investigations(status: str | None = None, db: Session = Depends(get_db),

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

    q = select(Investigation).order_by(Investigation.created_at.desc())

    if status:

        q = q.where(Investigation.status == status)

    return db.scalars(q).all()

@router.post("", response_model=InvestigationOut, status_code=201)

def create_investigation(payload: InvestigationCreate, db: Session = Depends(get_db),

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

    inv = Investigation(title=payload.title, summary=payload.summary,

                        priority=payload.priority, organization=payload.organization,

                        lead_user_id=user.id, status="open")

    db.add(inv)

    db.flush()

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

                    entity_type="investigation", entity_id=inv.id))

    db.commit()

    db.refresh(inv)

    return inv

@router.get("/{inv_id}", response_model=InvestigationOut)

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

    inv = db.get(Investigation, inv_id)

    if not inv:

        raise HTTPException(404, "investigation not found")

    return inv

@router.post("/{inv_id}/sightings")

def attach_sightings(inv_id: str, plate_norm: str, db: Session = Depends(get_db),

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

    """Attach all sightings of a plate to this investigation."""

    if not db.get(Investigation, inv_id):

        raise HTTPException(404, "investigation not found")

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

    attached = 0

    for r in reads:

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

        if s and s.investigation_id != inv_id:

            s.investigation_id = inv_id

            attached += 1

    db.add(AuditLog(actor_user_id=user.id, action="investigation.attach_sightings",

                    entity_type="investigation", entity_id=inv_id,

                    meta={"plate_norm": plate_norm, "attached": attached}))

    db.commit()

    return {"attached": attached, "plate_norm": plate_norm}

@router.post("/{inv_id}/notes")

def add_note(inv_id: str, payload: NoteCreate, db: Session = Depends(get_db),

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

    if not db.get(Investigation, inv_id):

        raise HTTPException(404, "investigation not found")

    note = Note(investigation_id=inv_id, author_id=user.id, body=payload.body, pinned=payload.pinned)

    db.add(note)

    db.commit()

    return {"id": note.id}

@router.get("/{inv_id}/timeline")

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

    rows = db.execute(

        select(PlateRead.plate_norm, PlateRead.read_ts, PlateRead.camera_id,

               PlateRead.direction, PlateRead.confidence)

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

        .where(Sighting.investigation_id == inv_id)

        .order_by(PlateRead.read_ts)

    ).all()

    return [{"plate_norm": r[0], "read_ts": r[1], "camera_id": r[2],

             "direction": r[3], "confidence": float(r[4]) if r[4] is not None else None}

            for r in rows]

@router.get("/{inv_id}/graph")

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

    """Build a node-link graph from the investigation's sightings:

    plate -> camera edges, plus any stored entity_relationships touching those nodes."""

    rows = db.execute(

        select(PlateRead.plate_norm, PlateRead.camera_id)

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

        .where(Sighting.investigation_id == inv_id)

    ).all()

    nodes: dict[str, dict] = {}

    edges: list[dict] = []

    seen_edges: set = set()

    for plate, cam in rows:

        if plate:

            nodes[f"plate:{plate}"] = {"id": f"plate:{plate}", "type": "plate", "label": plate}

        if cam:

            nodes[f"camera:{cam}"] = {"id": f"camera:{cam}", "type": "camera", "label": cam}

        if plate and cam:

            key = (plate, cam)

            if key not in seen_edges:

                seen_edges.add(key)

                edges.append({"source": f"plate:{plate}", "target": f"camera:{cam}",

                              "relation": "seen_at"})

    rels = db.scalars(select(EntityRelationship)).all()

    for rel in rels:

        s, t = f"{rel.src_type}:{rel.src_id}", f"{rel.dst_type}:{rel.dst_id}"

        if s in nodes or t in nodes:

            nodes.setdefault(s, {"id": s, "type": rel.src_type, "label": rel.src_id})

            nodes.setdefault(t, {"id": t, "type": rel.dst_type, "label": rel.dst_id})

            edges.append({"source": s, "target": t, "relation": rel.relation})

    return {"nodes": list(nodes.values()), "edges": edges}