"""Real-data-only seeder for the camera-focused platform.

  Ground cameras    -> real ALPR/Flock camera network from OSM/DeFlock (sample_data/real_cameras.json)

  Satellite cameras -> real imaging satellites (Planet SkySat/Dove + Earth-resources), live SGP4 positions

NO synthetic plate reads / persons / detections. Every row here is real public data with provenance.

"""

from __future__ import annotations

import json

import os

import uuid

from datetime import datetime, timezone

from sqlalchemy import delete, func, insert, select

from app.core.security import hash_password

from app.db.session import SessionLocal

from app.models import (

    Camera, CameraGroup, Detection, EntityPosition, Investigation, LiveEntity, Location,

    Person, PlateRead, SensorAsset, Sighting, Source, User, Vehicle, Watchlist, WatchlistEntry,

    WatchlistHit,

)

from app.services.realsources import (

    az511_cameras, caltrans_cameras, fl511_cameras, imaging_satellites, ne511_cameras,

    nyc_traffic_cameras, tripcheck_cameras,

)

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

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 from OSM/DeFlock")

    db = SessionLocal()

    org = "default"

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

                Investigation, Person, Vehicle, EntityPosition, LiveEntity, SensorAsset,

                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()

    source = db.scalar(select(Source).where(Source.name == "OSM / DeFlock ALPR Network"))

    if not source:

        source = Source(name="OSM / DeFlock ALPR Network", system_type="osm", organization=org,

                        jurisdiction="United States (public)", trust_level=0.85)

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

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

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

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

                                     for st, g in groups.items()])

    loc_rows, cam_rows = [], []

    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"]})

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

        cam_rows.append({"id": cid, "source_id": source.id, "external_camera_id": f"OSM-{c['osm_id']}",

                         "name": nm, "direction_facing": c.get("direction"), "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": {"provenance": "osm/deflock"}})

    db.execute(insert(Location), loc_rows)

    db.execute(insert(Camera), cam_rows)

    db.commit()

    by_op = {}

    for c in real:

        by_op[c["operator"]] = by_op.get(c["operator"], 0) + 1

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

    print("  operators:", sorted(by_op.items(), key=lambda kv: -kv[1])[:6])

    live_total = 0

    seen_ext: set[str] = set()

    for label, fetch in [("NYC DOT - Live Feeds", nyc_traffic_cameras),

                         ("Caltrans - Live Feeds", caltrans_cameras),

                         ("Oregon TripCheck - Live Feeds", tripcheck_cameras),

                         ("Florida FL511 - Live Feeds", fl511_cameras),

                         ("Arizona AZ511 - Live Feeds", az511_cameras),

                         ("New England 511 - Live Feeds", ne511_cameras)]:

        try:

            feed = fetch()

        except Exception as e:

            print(f"  {label}: fetch failed ({e})")

            continue

        if not feed:

            continue

        gid = str(uuid.uuid4())

        db.execute(insert(CameraGroup), [{"id": gid, "name": label, "organization": org}])

        lrows, crows = [], []

        for c in feed:

            ext = c["external_id"]

            if ext in seen_ext:

                continue

            seen_ext.add(ext)

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

            lrows.append({"id": lid, "label": c["name"], "lat": c["lat"], "lon": c["lon"],

                          "jurisdiction": c.get("area")})

            crows.append({"id": cid, "source_id": source.id, "external_camera_id": ext,

                          "name": c["name"], "operator": c["operator"], "state": c["state"],

                          "zone": "traffic", "area": c.get("area"), "location_id": lid,

                          "camera_group_id": gid, "image_url": c["image_url"],

                          "has_live_feed": True, "live_source": c["live_source"],

                          "metadata": {"online": c.get("online", True), "provenance": c["live_source"]}})

        db.execute(insert(Location), lrows)

        db.execute(insert(Camera), crows)

        db.commit()

        live_total += len(crows)

        print(f"inserted {len(crows)} LIVE cameras from {label}")

    print(f"  total live feeds: {live_total}")

    try:

        sats = imaging_satellites()

    except Exception as e:

        print(f"  satellite fetch skipped ({e}); tracker will repopulate from cache")

        sats = []

    now = datetime.now(timezone.utc)

    ent_rows, pos_rows = [], []

    for s in sats:

        ent_rows.append({"id": str(uuid.uuid4()), "kind": "satellite_camera", "source": s["source"],

                         "identifier": s["identifier"], "label": s["label"], "lat": s["lat"],

                         "lon": s["lon"], "altitude_m": s["altitude_m"], "heading": None,

                         "velocity": None, "origin_country": None, "attributes": s["attributes"],

                         "observed_at": now})

        pos_rows.append({"identifier": s["identifier"], "kind": "satellite_camera",

                         "lat": s["lat"], "lon": s["lon"], "altitude_m": s["altitude_m"], "observed_at": now})

    if ent_rows:

        db.execute(insert(LiveEntity), ent_rows)

        db.execute(insert(EntityPosition), pos_rows)

    db.commit()

    print(f"inserted {len(ent_rows)} satellite cameras (imaging sats, live SGP4 positions)")

    nc = db.scalar(select(func.count()).select_from(Camera))

    ns = db.scalar(select(func.count()).select_from(LiveEntity))

    print(f"DONE. ground_cameras={nc}, satellite_cameras={ns}, states={len(states)}")

if __name__ == "__main__":

    main()