"""Proof-of-concept seed: stand up the named camera network, ingest the generated dataset

through the real pipeline, and build watchlists + investigations around the embedded scenarios.

Idempotent where practical. Run after `python generate_data.py`."""

from __future__ import annotations

import hashlib

import os

import time

from sqlalchemy import select

from app.core.security import hash_password

from app.db.session import SessionLocal

from app.models import (

    Camera, CameraGroup, Import, Investigation, LicensePlate, Location, PlateRead,

    Sighting, Source, User, Vehicle, Watchlist, WatchlistEntry,

)

from app.services.ingest import process_import

from generate_data import CAMERAS

SAMPLE = os.path.join(os.path.dirname(__file__), "sample_data", "poc_reads.csv")

def get_or_create(db, model, defaults=None, **flt):

    obj = db.scalar(select(model).filter_by(**flt))

    if obj:

        return obj, False

    obj = model(**flt, **(defaults or {}))

    db.add(obj)

    db.flush()

    return obj, True

def main():

    db = SessionLocal()

    try:

        admin, created = get_or_create(db, User, email="admin@sightline.app",

            defaults={"hashed_password": hash_password("changeme123"), "full_name": "Lead Analyst", "role": "admin"})

        if created:

            print("admin: admin@sightline.app / changeme123")

        get_or_create(db, User, email="analyst@sightline.app",

            defaults={"hashed_password": hash_password("analyst123"), "full_name": "Field Analyst", "role": "analyst"})

        get_or_create(db, User, email="viewer@sightline.app",

            defaults={"hashed_password": hash_password("viewer1234"), "full_name": "Watch Desk", "role": "viewer"})

        source, _ = get_or_create(db, Source, name="National ALPR Aggregate",

            defaults={"system_type": "flock", "organization": "default",

                      "jurisdiction": "Multi-state (US)", "trust_level": 0.92})

        groups: dict[str, CameraGroup] = {}

        for cid, name, lat, lon, grp in CAMERAS:

            g = groups.get(grp)

            if not g:

                g, _ = get_or_create(db, CameraGroup, name=grp, defaults={"organization": "default"})

                groups[grp] = g

            cam = db.scalar(select(Camera).where(Camera.source_id == source.id,

                                                 Camera.external_camera_id == cid))

            if not cam:

                loc = Location(label=name, lat=lat, lon=lon, jurisdiction="Shelby County, TN")

                db.add(loc); db.flush()

                db.add(Camera(source_id=source.id, external_camera_id=cid, name=name,

                              location_id=loc.id, camera_group_id=g.id))

        db.commit()

        print(f"camera network: {len(CAMERAS)} cameras in {len(groups)} groups")

        with open(SAMPLE, "rb") as fh:

            data = fh.read()

        sha = hashlib.sha256(data).hexdigest()

        imp = db.scalar(select(Import).where(Import.sha256 == sha))

        if imp and imp.status == "done":

            print(f"dataset already ingested ({imp.row_count} reads)")

        else:

            if not imp:

                imp = Import(source_id=source.id, filename="poc_reads.csv", content_type="text/csv",

                             sha256=sha, raw_blob_ref=SAMPLE, status="received", created_by=admin.id)

                db.add(imp); db.commit()

            print(f"ingesting {SAMPLE} ...")

            t0 = time.time()

            summary = process_import(db, imp.id)

            print(f"ingested in {time.time()-t0:.1f}s: {summary}")

        bolo, _ = get_or_create(db, Watchlist, name="Stolen Vehicles - Active BOLO",

            defaults={"kind": "plate", "organization": "default", "created_by": admin.id})

        if not db.scalar(select(WatchlistEntry).where(WatchlistEntry.plate_norm == "BNDT447")):

            db.add(WatchlistEntry(watchlist_id=bolo.id, plate_norm="BNDT447",

                                  reason="Reported stolen - INC-2026-0440 (black Dodge Charger)"))

        poi, _ = get_or_create(db, Watchlist, name="Persons of Interest",

            defaults={"kind": "plate", "organization": "default", "created_by": admin.id})

        if not db.scalar(select(WatchlistEntry).where(WatchlistEntry.partial_plate == "ESC81")):

            db.add(WatchlistEntry(watchlist_id=poi.id, partial_plate="ESC81",

                                  reason="Associated vehicles - co-travel pattern under review"))

        db.commit()

        from app.services.watchlist import WatchEntry, match_all

        from app.models import WatchlistHit

        entries = db.scalars(select(WatchlistEntry)).all()

        we = [WatchEntry(id=e.id, plate_norm=e.plate_norm, partial_plate=e.partial_plate,

                         vehicle_desc=e.vehicle_desc) for e in entries]

        existing_hits = {(h.watchlist_entry_id, h.plate_read_id)

                         for h in db.scalars(select(WatchlistHit)).all()}

        hit_count = 0

        for r in db.scalars(select(PlateRead)).all():

            for m in match_all(we, r.plate_norm, None):

                if (m["entry_id"], r.id) in existing_hits:

                    continue

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

                db.add(WatchlistHit(watchlist_entry_id=m["entry_id"], plate_read_id=r.id,

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

                hit_count += 1

        db.commit()

        print(f"watchlist hits backfilled: {hit_count}")

        def attach(inv, plate):

            n = 0

            for r in db.scalars(select(PlateRead).where(PlateRead.plate_norm == plate)).all():

                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; n += 1

            return n

        inv1, c1 = get_or_create(db, Investigation, title="Operation Nightshade - Stolen Charger",

            defaults={"summary": "Tracking stolen black Dodge Charger (BNDT447), INC-2026-0440, "

                                 "across the Memphis ALPR network to establish pattern of life.",

                      "priority": "high", "status": "active", "organization": "default", "lead_user_id": admin.id})

        if c1:

            print(f"  Operation Nightshade: attached {attach(inv1, 'BNDT447')} sightings")

        inv2, c2 = get_or_create(db, Investigation, title="Cloned Plate Review - CLN9921",

            defaults={"summary": "Plate CLN9921 shows physically impossible transit times - "

                                 "suspected cloned/duplicated plate. Validate via anomaly analytics.",

                      "priority": "normal", "status": "open", "organization": "default", "lead_user_id": admin.id})

        if c2:

            print(f"  Cloned Plate Review: attached {attach(inv2, 'CLN9921')} sightings")

        inv3, c3 = get_or_create(db, Investigation, title="Co-Travel Analysis - ESC8120 / ESC8121",

            defaults={"summary": "Two vehicles repeatedly observed together along the East Memphis "

                                 "→ Downtown corridor. Assess association.",

                      "priority": "normal", "status": "active", "organization": "default", "lead_user_id": admin.id})

        if c3:

            print(f"  Co-Travel Analysis: attached {attach(inv3, 'ESC8120') + attach(inv3, 'ESC8121')} sightings")

        db.commit()

        total = db.scalar(select(PlateRead).limit(1))

        print("POC seed complete." if total else "POC seed FAILED - no reads.")

    finally:

        db.close()

if __name__ == "__main__":

    main()