"""Fast bulk seeder for the nationwide POC built on REAL ALPR camera locations

(sample_data/real_cameras.json from fetch_cameras.py / OpenStreetMap-DeFlock).

Loads the real cameras, then bulk-generates a realistic intelligence dataset on top of them:

vehicles + plates (all 50 states), a roster of named persons (some wanted), plate reads with

commute/scenario patterns, sightings, and person detections carrying clothing/article descriptors

so name/outfit search works. Uses core bulk inserts - loads ~100k rows in seconds, not minutes.

Real = camera locations/metadata (operator, direction, zone, coordinates).

Synthetic = plate reads, vehicles, persons, detections (this data is not public; it is generated

realistically against the real camera positions for the proof of concept).

"""

from __future__ import annotations

import json

import os

import random

import string

from datetime import datetime, timedelta, timezone

from sqlalchemy import delete, func, insert, select

from app.core.security import hash_password

from app.db.session import SessionLocal, engine

from app.models import (

    Camera, CameraGroup, Detection, Investigation, LicensePlate, Location, Person, PlateRead,

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

)

from app.services.normalize import dedup_hash

random.seed(2026)

CAMS_JSON = os.path.join(os.path.dirname(__file__), "sample_data", "real_cameras.json")

DAYS = 14

END = datetime(2026, 6, 10, tzinfo=timezone.utc)

START = END - timedelta(days=DAYS)

MAKES = [("Toyota", ["Camry", "Corolla", "RAV4", "Tacoma"]), ("Honda", ["Civic", "Accord", "CR-V"]),

         ("Ford", ["F-150", "Escape", "Explorer", "Mustang"]), ("Chevrolet", ["Malibu", "Equinox", "Silverado", "Tahoe"]),

         ("Nissan", ["Altima", "Rogue", "Sentra"]), ("Jeep", ["Grand Cherokee", "Wrangler"]),

         ("Dodge", ["Charger", "Challenger", "Ram"]), ("Hyundai", ["Elantra", "Sonata", "Tucson"]),

         ("Tesla", ["Model 3", "Model Y"]), ("GMC", ["Sierra", "Yukon"]), ("BMW", ["3 Series", "X5"]),

         ("Kia", ["Optima", "Sorento", "Telluride"])]

BODY = {"Camry": "Sedan", "Corolla": "Sedan", "RAV4": "SUV", "Tacoma": "Pickup", "Civic": "Sedan",

        "Accord": "Sedan", "CR-V": "SUV", "F-150": "Pickup", "Escape": "SUV", "Explorer": "SUV",

        "Mustang": "Coupe", "Malibu": "Sedan", "Equinox": "SUV", "Silverado": "Pickup", "Tahoe": "SUV",

        "Altima": "Sedan", "Rogue": "SUV", "Sentra": "Sedan", "Grand Cherokee": "SUV", "Wrangler": "SUV",

        "Charger": "Sedan", "Challenger": "Coupe", "Ram": "Pickup", "Elantra": "Sedan", "Sonata": "Sedan",

        "Tucson": "SUV", "Model 3": "Sedan", "Model Y": "SUV", "Sierra": "Pickup", "Yukon": "SUV",

        "3 Series": "Sedan", "X5": "SUV", "Optima": "Sedan", "Sorento": "SUV", "Telluride": "SUV"}

COLORS = ["White", "Black", "Silver", "Gray", "Blue", "Red", "Green", "Tan", "Maroon"]

FIRST = ["James", "Maria", "Marcus", "Aisha", "David", "Elena", "Tyler", "Fatima", "Brandon",

         "Sofia", "Andre", "Nina", "Carlos", "Grace", "Dmitri", "Layla", "Hassan", "Chloe",

         "Victor", "Priya", "Omar", "Renee", "Jamal", "Tara", "Sean", "Yuki", "Diego", "Hannah"]

LAST = ["Delgado", "Okafor", "Nguyen", "Reyes", "Carter", "Petrov", "Hassan", "Bauer", "Romano",

        "Cole", "Mbeki", "Larsen", "Castillo", "Fischer", "Abadi", "Walsh", "Kim", "Vega",

        "Donovan", "Sharma", "Cross", "Ibrahim", "Sokolov", "Tanaka", "Mercer", "Quinn"]

TOPS = ["black hoodie", "red t-shirt", "blue windbreaker", "gray sweatshirt", "white polo",

        "camouflage jacket", "yellow rain jacket", "green flannel shirt", "navy peacoat",

        "orange hi-vis vest", "leather jacket", "purple track top"]

BOTTOMS = ["blue jeans", "black sweatpants", "khaki shorts", "tactical cargo pants", "gray slacks",

           "dark wash jeans", "athletic leggings", "carpenter pants"]

ARTICLES = ["backpack", "baseball cap", "sunglasses", "duffel bag", "face mask", "beanie",

            "crossbody bag", "work boots", "gloves", "messenger bag", "umbrella", "lanyard"]

HAIR = ["black", "brown", "blonde", "gray", "red", "bald", "shaved"]

BUILD = ["slim", "medium", "athletic", "heavy", "tall/lean"]

def plate():

    n = random.choice([3, 3, 4])

    return "".join(random.choices(string.ascii_uppercase, k=n)) + "".join(random.choices("0123456789", k=7 - n))

def main():

    if not os.path.exists(CAMS_JSON):

        raise SystemExit(f"missing {CAMS_JSON} - run fetch_cameras.py first")

    with open(CAMS_JSON) as fh:

        real = [c for c in json.load(fh) if c.get("lat") and c.get("lon")]

    print(f"loaded {len(real)} real ALPR cameras")

    db = SessionLocal()

    org = "default"

    for tbl in (Detection, WatchlistHit, Sighting, PlateRead, WatchlistEntry, Watchlist,

                Investigation, Person, Vehicle, LicensePlate, Camera, Location, CameraGroup):

        db.execute(delete(tbl))

    db.commit()

    for email, pw, name, role in [("admin@sightline.app", "changeme123", "Lead Analyst", "admin"),

                                  ("analyst@sightline.app", "analyst123", "Field Analyst", "analyst"),

                                  ("viewer@sightline.app", "viewer1234", "Watch Desk", "viewer")]:

        if not db.scalar(select(User).where(User.email == email)):

            db.add(User(email=email, hashed_password=hash_password(pw), full_name=name, role=role))

    db.commit()

    admin = db.scalar(select(User).where(User.email == "admin@sightline.app"))

    source, _ = (db.scalar(select(Source).where(Source.name == "National ALPR Aggregate")), None)

    if not source:

        source = Source(name="National ALPR Aggregate", system_type="flock", organization=org,

                        jurisdiction="Multi-state (US)", trust_level=0.9)

        db.add(source); db.commit()

    import uuid

    states = sorted({c["state"] for c in real})

    groups = {st: str(uuid.uuid4()) for st in states}

    db.execute(insert(CameraGroup), [{"id": gid, "name": f"{st} - Statewide",

                "organization": org} for st, gid in groups.items()])

    loc_rows, cam_rows = [], []

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

    for c in real:

        lid, cid = str(uuid.uuid4()), str(uuid.uuid4())

        loc_rows.append({"id": lid, "label": f"{c['operator']} ALPR ({c['state']})",

                         "lat": c["lat"], "lon": c["lon"], "jurisdiction": c["state"]})

        name = f"{c['operator']} - {c['state']}" + (f" · {c['zone']}" if c.get("zone") else "")

        cam = {"id": cid, "source_id": source.id, "external_camera_id": f"OSM-{c['osm_id']}",

               "name": name, "direction_facing": (c.get("direction") or None),

               "operator": c["operator"], "manufacturer": c.get("manufacturer"),

               "zone": c.get("zone"), "state": c["state"], "osm_id": str(c["osm_id"]),

               "location_id": lid, "camera_group_id": groups[c["state"]], "metadata": {}}

        cam_rows.append(cam)

        cams_by_state.setdefault(c["state"], []).append({"id": cid, "lat": c["lat"], "lon": c["lon"]})

    db.execute(insert(Location), loc_rows)

    db.execute(insert(Camera), cam_rows)

    db.commit()

    print(f"inserted {len(cam_rows)} cameras, {len(states)} states")

    plate_rows, veh_rows = [], []

    vehicles: list[dict] = []

    used_plates = set()

    for st in states:

        for _ in range(max(8, len(cams_by_state[st]) // 6)):

            p = plate()

            while p in used_plates:

                p = plate()

            used_plates.add(p)

            mk, models = random.choice(MAKES); model = random.choice(models)

            pid, vid = str(uuid.uuid4()), str(uuid.uuid4())

            color = random.choice(COLORS)

            plate_rows.append({"id": pid, "plate_raw": p, "plate_norm": p, "state": st, "plate_type": "passenger"})

            veh_rows.append({"id": vid, "primary_plate_id": pid, "make": mk, "model": model,

                             "color": color, "body_type": BODY[model], "year": random.randint(2012, 2025)})

            vehicles.append({"plate": p, "state": st, "vehicle_id": vid, "plate_id": pid,

                             "make": mk, "model": model, "color": color})

    db.execute(insert(LicensePlate), plate_rows)

    db.execute(insert(Vehicle), veh_rows)

    db.commit()

    print(f"inserted {len(veh_rows)} vehicles/plates")

    veh_by_plate = {v["plate"]: v for v in vehicles}

    person_rows = []

    persons = []

    sample_v = random.sample(vehicles, min(450, len(vehicles)))

    for i, v in enumerate(sample_v):

        nm = f"{random.choice(FIRST)} {random.choice(LAST)}"

        wanted = i < 60

        pid = str(uuid.uuid4())

        person_rows.append({"id": pid, "full_name": nm,

                            "aliases": [f"{nm.split()[0][0]}. {nm.split()[1]}"] if random.random() < 0.4 else [],

                            "dob": f"19{random.randint(60,99)}-{random.randint(1,12):02d}-{random.randint(1,28):02d}",

                            "sex": random.choice(["M", "F"]), "height_cm": random.randint(155, 196),

                            "build": random.choice(BUILD), "hair": random.choice(HAIR),

                            "eyes": random.choice(["brown", "blue", "green", "hazel"]),

                            "distinguishing_marks": random.choice([None, None, "tattoo left forearm",

                                "scar over right eye", "neck tattoo", "limp (left leg)"]),

                            "associated_plate": v["plate"],

                            "threat_level": "high" if wanted and i < 20 else "medium" if wanted else random.choice(["none","none","low"]),

                            "wanted": wanted, "notes": "Subject of active inquiry." if wanted else None})

        persons.append({"id": pid, "plate": v["plate"], "state": v["state"]})

    db.execute(insert(Person), person_rows)

    db.commit()

    print(f"inserted {len(person_rows)} persons ({sum(1 for p in person_rows if p['wanted'])} wanted)")

    read_rows, seen_hashes = [], set()

    def add_read(v, cam, ts, hotlist=False, incident=""):

        dh = dedup_hash(org, v["plate"], cam["id"], ts, 1)

        if dh in seen_hashes:

            return None

        seen_hashes.add(dh)

        read_rows.append({"import_id": None, "source_id": source.id, "camera_id": cam["id"],

                          "plate_id": v["plate_id"], "plate_norm": v["plate"], "read_ts": ts,

                          "direction": random.choice(["N", "NE", "E", "SE", "S", "SW", "W", "NW"]),

                          "confidence": round(random.uniform(0.82, 0.99), 3), "lane": None,

                          "lat": cam["lat"], "lon": cam["lon"], "hotlist_hit": hotlist,

                          "incident_ref": incident or None, "burst_count": 1,

                          "raw_read": {}, "dedup_hash": dh})

        return read_rows[-1]

    for v in vehicles:

        cams = cams_by_state.get(v["state"]) or []

        if len(cams) < 2:

            continue

        home, work = random.sample(cams, 2)

        for day in range(DAYS):

            d = START + timedelta(days=day)

            if d.weekday() >= 5 or random.random() < 0.2:

                continue

            am = d.replace(hour=random.randint(6, 8), minute=random.randint(0, 59), second=random.randint(0, 59))

            for k, cam in enumerate([home, random.choice(cams), work]):

                add_read(v, cam, am + timedelta(minutes=8 * k + random.randint(0, 4)))

            pm = d.replace(hour=random.randint(16, 18), minute=random.randint(0, 59), second=random.randint(0, 59))

            for k, cam in enumerate([work, random.choice(cams), home]):

                add_read(v, cam, pm + timedelta(minutes=8 * k + random.randint(0, 4)))

    for v in random.sample(vehicles, min(40, len(vehicles))):

        visit = random.sample(states, k=random.randint(3, 6))

        day = random.randint(0, DAYS - 1)

        for st in visit:

            cams = cams_by_state.get(st) or []

            if not cams:

                continue

            d = START + timedelta(days=day)

            add_read(v, random.choice(cams), d.replace(hour=random.randint(8, 20), minute=random.randint(0, 59)))

            day = min(DAYS - 1, day + 1)

    stolen_v = {"plate": "BNDT447", "state": "TN", "plate_id": None, "vehicle_id": None,

                "make": "Dodge", "model": "Charger", "color": "Black"}

    spid, svid = str(uuid.uuid4()), str(uuid.uuid4())

    db.execute(insert(LicensePlate), [{"id": spid, "plate_raw": "BNDT447", "plate_norm": "BNDT447", "state": "TN", "plate_type": "passenger"}])

    db.execute(insert(Vehicle), [{"id": svid, "primary_plate_id": spid, "make": "Dodge", "model": "Charger", "color": "Black", "body_type": "Sedan", "year": 2021}])

    stolen_v["plate_id"], stolen_v["vehicle_id"] = spid, svid

    veh_by_plate["BNDT447"] = stolen_v

    for st in ["TN", "MS", "AL", "GA", "AR", "MO", "KY"]:

        for cam in (cams_by_state.get(st) or [])[:3]:

            d = START + timedelta(days=random.randint(DAYS - 7, DAYS - 1))

            add_read(stolen_v, cam, d.replace(hour=random.randint(0, 23), minute=random.randint(0, 59)),

                     hotlist=True, incident="INC-2026-0440")

    clone_v = {"plate": "CLN9921", "state": "CA", "plate_id": None, "vehicle_id": None}

    cpid, cvid = str(uuid.uuid4()), str(uuid.uuid4())

    db.execute(insert(LicensePlate), [{"id": cpid, "plate_raw": "CLN9921", "plate_norm": "CLN9921", "state": "CA", "plate_type": "passenger"}])

    db.execute(insert(Vehicle), [{"id": cvid, "primary_plate_id": cpid, "make": "Honda", "model": "Accord", "color": "White", "body_type": "Sedan", "year": 2019}])

    clone_v["plate_id"], clone_v["vehicle_id"] = cpid, cvid

    veh_by_plate["CLN9921"] = clone_v

    base = (START + timedelta(days=DAYS - 3)).replace(hour=14, minute=0, second=0)

    far = []

    for st in ["CA", "NY", "FL"]:

        cs = cams_by_state.get(st) or []

        if cs:

            far.append(cs[0])

    for k, cam in enumerate(far):

        add_read(clone_v, cam, base + timedelta(seconds=120 * k))

    db.execute(insert(PlateRead), read_rows)

    db.commit()

    print(f"inserted {len(read_rows)} plate reads")

    id_by_hash = {bytes(h): rid for rid, h in db.execute(select(PlateRead.id, PlateRead.dedup_hash)).all()}

    sight_rows = []

    for r in read_rows:

        rid = id_by_hash.get(r["dedup_hash"])

        v = veh_by_plate.get(r["plate_norm"])

        if rid and v:

            sight_rows.append({"plate_read_id": rid, "vehicle_id": v["vehicle_id"], "camera_id": r["camera_id"],

                               "read_ts": r["read_ts"], "confidence": r["confidence"]})

    db.execute(insert(Sighting), sight_rows)

    db.commit()

    print(f"inserted {len(sight_rows)} sightings")

    det_rows = []

    person_by_plate = {p["plate"]: p for p in persons}

    for r in random.sample(read_rows, min(9000, len(read_rows))):

        p = person_by_plate.get(r["plate_norm"])

        top, bottom = random.choice(TOPS), random.choice(BOTTOMS)

        arts = random.sample(ARTICLES, k=random.randint(0, 3))

        det_rows.append({"person_id": p["id"] if p else None, "camera_id": r["camera_id"],

                         "sighting_id": None, "read_ts": r["read_ts"], "plate_norm": r["plate_norm"],

                         "occupant_role": random.choice(["driver", "driver", "passenger"]),

                         "clothing_top": top, "clothing_bottom": bottom, "articles": arts,

                         "description": f"{random.choice(BUILD)} build, wearing {top} and {bottom}"

                                        + (f", carrying {', '.join(arts)}" if arts else ""),

                         "confidence": round(random.uniform(0.6, 0.95), 3)})

    marcus = db.scalar(select(Person).where(Person.wanted.is_(True)).order_by(Person.full_name).limit(1))

    if marcus:

        marcus.associated_plate = "BNDT447"; marcus.threat_level = "high"; marcus.notes = "Linked to stolen vehicle INC-2026-0440."

        for r in [x for x in read_rows if x["plate_norm"] == "BNDT447"][:8]:

            det_rows.append({"person_id": marcus.id, "camera_id": r["camera_id"], "sighting_id": None,

                             "read_ts": r["read_ts"], "plate_norm": "BNDT447", "occupant_role": "driver",

                             "clothing_top": "black hoodie", "clothing_bottom": "dark wash jeans",

                             "articles": ["backpack", "baseball cap"],

                             "description": "medium build, black hoodie, baseball cap, carrying a backpack",

                             "confidence": 0.88})

    db.execute(insert(Detection), det_rows)

    db.commit()

    print(f"inserted {len(det_rows)} detections")

    bolo = Watchlist(name="Stolen Vehicles - Active BOLO", kind="plate", organization=org, created_by=admin.id)

    poi = Watchlist(name="Persons of Interest", kind="plate", organization=org, created_by=admin.id)

    db.add_all([bolo, poi]); db.flush()

    e1 = WatchlistEntry(watchlist_id=bolo.id, plate_norm="BNDT447", reason="Reported stolen - INC-2026-0440")

    e2 = WatchlistEntry(watchlist_id=poi.id, plate_norm="CLN9921", reason="Suspected cloned plate")

    db.add_all([e1, e2]); db.flush()

    hit_rows = []

    for r in db.execute(select(PlateRead.id, PlateRead.plate_norm)).all():

        if r[1] == "BNDT447":

            hit_rows.append({"watchlist_entry_id": e1.id, "plate_read_id": r[0], "matched_on": "exact_plate"})

        elif r[1] == "CLN9921":

            hit_rows.append({"watchlist_entry_id": e2.id, "plate_read_id": r[0], "matched_on": "exact_plate"})

    if hit_rows:

        db.execute(insert(WatchlistHit), hit_rows)

    db.commit()

    print(f"watchlist hits: {len(hit_rows)}")

    def attach(inv_id, plate):

        ids = [r[0] for r in db.execute(select(PlateRead.id).where(PlateRead.plate_norm == plate)).all()]

        if ids:

            db.execute(Sighting.__table__.update().where(Sighting.plate_read_id.in_(ids)).values(investigation_id=inv_id))

        return len(ids)

    inv1 = Investigation(title="Operation Nightshade - Stolen Charger", priority="high", status="active",

                         organization=org, lead_user_id=admin.id,

                         summary="Stolen black Dodge Charger (BNDT447), INC-2026-0440, tracked multi-state.")

    inv2 = Investigation(title="Cloned Plate Review - CLN9921", priority="normal", status="open",

                         organization=org, lead_user_id=admin.id,

                         summary="Plate CLN9921 shows impossible cross-country transit - suspected clone.")

    db.add_all([inv1, inv2]); db.flush()

    attach(inv1.id, "BNDT447"); attach(inv2.id, "CLN9921")

    db.commit()

    n = db.scalar(select(func.count()).select_from(PlateRead))

    print(f"DONE. reads={n}, cameras={len(cam_rows)}, vehicles={len(veh_rows)}, persons={len(person_rows)}, detections={len(det_rows)}")

if __name__ == "__main__":

    main()