"""Generate a NATIONWIDE ALPR dataset as a Flock-style CSV - camera networks in a city for

every U.S. state, vehicles plated across all 50 states, with realistic local commute patterns,

some cross-country travelers, and embedded investigative scenarios:

  * a stolen vehicle on a watchlist, driven across multiple states

  * a cloned plate with physically impossible coast-to-coast transit (anomaly detector)

  * a co-traveling pair repeatedly seen together

  * commuters with stable home/work anchor points per city

Deterministic (seeded). Re-running reproduces the same dataset.

"""

from __future__ import annotations

import csv

import math

import os

import random

import string

from datetime import datetime, timedelta, timezone

random.seed(50)

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

STATE_CITIES = {

    "AL": ("Birmingham", 33.5186, -86.8104), "AK": ("Anchorage", 61.2181, -149.9003),

    "AZ": ("Phoenix", 33.4484, -112.0740), "AR": ("Little Rock", 34.7465, -92.2896),

    "CA": ("Los Angeles", 34.0522, -118.2437), "CO": ("Denver", 39.7392, -104.9903),

    "CT": ("Hartford", 41.7658, -72.6734), "DE": ("Wilmington", 39.7391, -75.5398),

    "FL": ("Miami", 25.7617, -80.1918), "GA": ("Atlanta", 33.7490, -84.3880),

    "HI": ("Honolulu", 21.3069, -157.8583), "ID": ("Boise", 43.6150, -116.2023),

    "IL": ("Chicago", 41.8781, -87.6298), "IN": ("Indianapolis", 39.7684, -86.1581),

    "IA": ("Des Moines", 41.5868, -93.6250), "KS": ("Wichita", 37.6872, -97.3301),

    "KY": ("Louisville", 38.2527, -85.7585), "LA": ("New Orleans", 29.9511, -90.0715),

    "ME": ("Portland", 43.6591, -70.2568), "MD": ("Baltimore", 39.2904, -76.6122),

    "MA": ("Boston", 42.3601, -71.0589), "MI": ("Detroit", 42.3314, -83.0458),

    "MN": ("Minneapolis", 44.9778, -93.2650), "MS": ("Jackson", 32.2988, -90.1848),

    "MO": ("St. Louis", 38.6270, -90.1994), "MT": ("Billings", 45.7833, -108.5007),

    "NE": ("Omaha", 41.2565, -95.9345), "NV": ("Las Vegas", 36.1699, -115.1398),

    "NH": ("Manchester", 42.9956, -71.4548), "NJ": ("Newark", 40.7357, -74.1724),

    "NM": ("Albuquerque", 35.0844, -106.6504), "NY": ("New York", 40.7128, -74.0060),

    "NC": ("Charlotte", 35.2271, -80.8431), "ND": ("Fargo", 46.8772, -96.7898),

    "OH": ("Columbus", 39.9612, -82.9988), "OK": ("Oklahoma City", 35.4676, -97.5164),

    "OR": ("Portland", 45.5152, -122.6784), "PA": ("Philadelphia", 39.9526, -75.1652),

    "RI": ("Providence", 41.8240, -71.4128), "SC": ("Columbia", 34.0007, -81.0348),

    "SD": ("Sioux Falls", 43.5446, -96.7311), "TN": ("Memphis", 35.1495, -90.0490),

    "TX": ("Houston", 29.7604, -95.3698), "UT": ("Salt Lake City", 40.7608, -111.8910),

    "VT": ("Burlington", 44.4759, -73.2121), "VA": ("Richmond", 37.5407, -77.4360),

    "WA": ("Seattle", 47.6062, -122.3321), "WV": ("Charleston", 38.3498, -81.6326),

    "WI": ("Milwaukee", 43.0389, -87.9065), "WY": ("Cheyenne", 41.1400, -104.8202),

}

STREETS = ["Main & 1st", "Central & 5th", "Broadway & Market", "Park & Union", "Highway 90 Ramp"]

CAMERAS: list[tuple] = []

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

for st, (city, lat, lon) in STATE_CITIES.items():

    cams = []

    for i in range(3):

        cid = f"CAM-{st}-{i+1:02d}"

        jlat = lat + random.uniform(-0.05, 0.05)

        jlon = lon + random.uniform(-0.05, 0.05)

        CAMERAS.append((cid, f"{city} - {STREETS[i % len(STREETS)]}", round(jlat, 4),

                        round(jlon, 4), f"{city}, {st}"))

        cams.append(cid)

    CITY_CAMS[st] = cams

CAM_BY_ID = {c[0]: c for c in CAMERAS}

ALL_STATES = list(STATE_CITIES.keys())

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

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

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

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

         ("Tesla", ["Model 3", "Model Y"]), ("Subaru", ["Outback", "Forester"])]

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

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

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

        "Equinox": "SUV", "Silverado": "Pickup", "Altima": "Sedan", "Rogue": "SUV", "Sentra": "Sedan",

        "Grand Cherokee": "SUV", "Wrangler": "SUV", "Charger": "Sedan", "Ram": "Pickup",

        "Elantra": "Sedan", "Sonata": "Sedan", "Tucson": "SUV", "Model 3": "Sedan",

        "Model Y": "SUV", "Outback": "Wagon", "Forester": "SUV"}

DAYS = 21

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

START = END - timedelta(days=DAYS)

def haversine_km(a, b):

    la1, lo1 = CAM_BY_ID[a][2], CAM_BY_ID[a][3]

    la2, lo2 = CAM_BY_ID[b][2], CAM_BY_ID[b][3]

    r = 6371.0

    p1, p2 = math.radians(la1), math.radians(la2)

    dphi, dlam = math.radians(la2 - la1), math.radians(lo2 - lo1)

    h = math.sin(dphi / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dlam / 2) ** 2

    return 2 * r * math.asin(math.sqrt(h))

def bearing(a, b):

    la1, lo1 = map(math.radians, (CAM_BY_ID[a][2], CAM_BY_ID[a][3]))

    la2, lo2 = map(math.radians, (CAM_BY_ID[b][2], CAM_BY_ID[b][3]))

    dl = lo2 - lo1

    y = math.sin(dl) * math.cos(la2)

    x = math.cos(la1) * math.sin(la2) - math.sin(la1) * math.cos(la2) * math.cos(dl)

    deg = (math.degrees(math.atan2(y, x)) + 360) % 360

    return ["N", "NE", "E", "SE", "S", "SW", "W", "NW"][int((deg + 22.5) % 360 // 45)]

def plate_for(state):

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

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

def make_vehicle(state, plate=None):

    mk, models = random.choice(MAKES)

    model = random.choice(models)

    return {"plate": plate or plate_for(state), "state": state, "make": mk,

            "color": random.choice(COLORS), "body": BODY[model]}

def emit(rows, veh, cam, dt, hotlist=False, incident="", prev=None):

    c = CAM_BY_ID[cam]

    rows.append({

        "Plate": veh["plate"], "State": veh["state"],

        "Timestamp": dt.strftime("%Y-%m-%dT%H:%M:%SZ"), "Camera": cam,

        "Latitude": f"{c[2]:.4f}", "Longitude": f"{c[3]:.4f}",

        "Direction": bearing(prev, cam) if prev else random.choice(["N", "E", "S", "W"]),

        "Confidence": random.randint(82, 99),

        "Make": veh["make"], "Color": veh["color"], "VehicleType": veh["body"],

        "Hotlist": "true" if hotlist else "false", "IncidentID": incident,

    })

def emit_trip(rows, veh, seq, depart, hotlist=False, incident=""):

    t, prev = depart, None

    for cam in seq:

        if prev:

            km = haversine_km(prev, cam)

            t = t + timedelta(hours=km / random.uniform(35, 75)) + timedelta(seconds=random.randint(0, 40))

        emit(rows, veh, cam, t, hotlist, incident, prev)

        prev = cam

def main():

    rows: list[dict] = []

    for st in ALL_STATES:

        cams = CITY_CAMS[st]

        for _ in range(4):

            veh = make_vehicle(st)

            home, work = cams[0], cams[-1]

            for day in range(DAYS):

                d = START + timedelta(days=day)

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

                    continue

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

                emit_trip(rows, veh, [home, cams[1], work], am)

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

                emit_trip(rows, veh, [work, cams[1], home], pm)

    for _ in range(25):

        st = random.choice(ALL_STATES)

        veh = make_vehicle(st)

        visited = random.sample(ALL_STATES, k=random.randint(2, 4))

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

        for st2 in visited:

            d = START + timedelta(days=day)

            cam = random.choice(CITY_CAMS[st2])

            t = d.replace(hour=random.randint(8, 20), minute=random.randint(0, 59), second=0)

            emit(rows, veh, cam, t)

            day = min(DAYS - 1, day + random.randint(1, 2))

    stolen = {"plate": "BNDT447", "state": "TN", "make": "Dodge", "color": "Black", "body": "Sedan"}

    route_states = ["TN", "MS", "AL", "GA", "TN", "AR", "MO"]

    day = DAYS - 8

    for st in route_states:

        d = START + timedelta(days=day)

        for cam in random.sample(CITY_CAMS[st], k=2):

            t = d.replace(hour=random.randint(0, 23), minute=random.randint(0, 59), second=0)

            emit(rows, stolen, cam, t, hotlist=True, incident="INC-2026-0440")

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

    clone = {"plate": "CLN9921", "state": "CA", "make": "Honda", "color": "White", "body": "Sedan"}

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

    for cam, off in [("CAM-CA-01", 0), ("CAM-NY-01", 120), ("CAM-FL-02", 240)]:

        emit(rows, clone, cam, base + timedelta(seconds=off))

    lead = make_vehicle("TX", "ESC8120"); tail = make_vehicle("TX", "ESC8121")

    for day in range(DAYS - 10, DAYS):

        d = START + timedelta(days=day)

        if d.weekday() >= 5:

            continue

        seq = CITY_CAMS["TX"]

        depart = d.replace(hour=7, minute=random.randint(20, 40), second=0)

        emit_trip(rows, lead, seq, depart)

        emit_trip(rows, tail, seq, depart + timedelta(seconds=random.randint(15, 50)))

    rows.sort(key=lambda r: r["Timestamp"])

    os.makedirs(os.path.dirname(OUT), exist_ok=True)

    cols = ["Plate", "State", "Timestamp", "Camera", "Latitude", "Longitude", "Direction",

            "Confidence", "Make", "Color", "VehicleType", "Hotlist", "IncidentID"]

    with open(OUT, "w", newline="") as fh:

        w = csv.DictWriter(fh, fieldnames=cols)

        w.writeheader()

        w.writerows(rows)

    states = {r["State"] for r in rows}

    plates = {r["Plate"] for r in rows}

    print(f"wrote {len(rows)} reads, {len(plates)} plates, {len(states)} states, "

          f"{len(CAMERAS)} cameras in {len(STATE_CITIES)} cities -> {OUT}")

if __name__ == "__main__":

    main()