import redis, psycopg2

r = redis.Redis()

STATIONARY_M = 30       # metres
STOP_DWELL_S = 240      # 4 minutes


def ingest(vehicle_id: str, lat: float, lng: float, ts: int, heading: float):
    """
    Called 648,000 times a day. Does nothing expensive.

    Validated. Stored. Last-known updated. That is all.
    """
    store_raw(vehicle_id, lat, lng, ts, heading)     # append-only

    r.hset(f"veh:{vehicle_id}", mapping={
        "lat": lat, "lng": lng, "ts": ts, "heading": heading,
    })

    # Stop detection is ARITHMETIC. No API.
    if _stationary(vehicle_id, lat, lng, ts):
        emit_stop_event(vehicle_id, lat, lng, ts)     # ← the unit of work

    # Geofence containment is ST_Contains. No API.
    check_geofences(vehicle_id, lat, lng)


def _stationary(vehicle_id, lat, lng, ts) -> bool:
    anchor = r.hgetall(f"anchor:{vehicle_id}")
    if not anchor:
        r.hset(f"anchor:{vehicle_id}", mapping={"lat": lat, "lng": lng, "ts": ts})
        return False

    if _haversine_m(lat, lng, float(anchor[b"lat"]), float(anchor[b"lng"])) > STATIONARY_M:
        r.hset(f"anchor:{vehicle_id}", mapping={"lat": lat, "lng": lng, "ts": ts})
        return False

    return ts - int(anchor[b"ts"]) >= STOP_DWELL_S

import requests, os

MULTI = "https://revgeocode.search.hereapi.com/v1/multi-revgeocode"
REV   = "https://revgeocode.search.hereapi.com/v1/revgeocode"
API_KEY = os.environ["HERE_API_KEY"]

COORD_DP = 5   # ~1 m. GPS jitter defeats an exact-match cache.
_cache: dict[str, str] = {}


def label_stops(stops: list[dict]) -> list[dict]:
    """
    Twelve detected stops. ONE request.

    Looping /revgeocode over a list is the same mistake as looping
    routing to build a matrix.
    """
    uncached = [s for s in stops if _key(s) not in _cache]
    if uncached:
        r = requests.post(MULTI, params={"apiKey": API_KEY}, json={
            "items": [{"id": s["id"], "at": f"{s['lat']},{s['lng']}"}
                      for s in uncached]
        }, timeout=30)
        if r.status_code == 403:
            raise RuntimeError("multi-revgeocode not entitled")
        r.raise_for_status()

        for item in r.json().get("items", []):
            _cache[_key_from_id(item["id"], uncached)] = item.get("title")

    return [{**s, "address": _cache.get(_key(s))} for s in stops]


def label_on_view(vehicle_id: str) -> str | None:
    """
    A dispatcher clicked ONE vehicle. Resolve ONE address.
    Do not pre-resolve the other 199.
    """
    v = r.hgetall(f"veh:{vehicle_id}")
    lat, lng = float(v[b"lat"]), float(v[b"lng"])
    k = f"{lat:.{COORD_DP}f},{lng:.{COORD_DP}f}"
    if k in _cache:
        return _cache[k]

    resp = requests.get(REV, params={
        "at": f"{lat},{lng}", "limit": 1, "apiKey": API_KEY,
    }, timeout=10)
    resp.raise_for_status()
    items = resp.json().get("items", [])
    if not items:
        return None

    _cache[k] = items[0]["address"]["label"]
    return _cache[k]


def _key(s): return f"{s['lat']:.{COORD_DP}f},{s['lng']:.{COORD_DP}f}"

from dataclasses import dataclass

ROUTER = "https://router.hereapi.com/v8/routes"


@dataclass(frozen=True)
class TruckProfile:
    """
    Model data. NEVER hardcoded at a call site.
    A refactor that drops one of these is invisible in code review
    and returns 200.
    """
    height_cm: int          # centimetres. 410 = 4.1 m
    gross_weight_kg: int    # kilograms
    axle_count: int         # base vehicle + ALL trailers


def dispatch_route(origin: str, dest: str, p: TruckProfile) -> dict:
    if not 100 <= p.height_cm <= 500:
        raise ValueError(f"height_cm={p.height_cm} — metres, not centimetres?")

    r = requests.get(ROUTER, params={
        "transportMode": "truck",
        "origin": origin, "destination": dest,
        "vehicle[height]": p.height_cm,          # `vehicle` supersedes `truck`
        "vehicle[grossWeight]": p.gross_weight_kg,
        "vehicle[axleCount]": p.axle_count,
        "return": "summary,polyline",
        "departureTime": "now",                  # traffic at DEPARTURE, not now
        "apiKey": API_KEY,
    }, timeout=20)

    if r.status_code == 403:
        raise RuntimeError("Truck routing not entitled")
    r.raise_for_status()

    body = r.json()
    if not body.get("routes"):
        # No LEGAL path. Escalate to a dispatcher.
        # Do NOT fall back to car routing.
        raise NoLegalRouteError(body.get("notice"))

    s = body["routes"][0]["sections"][0]
    return {"duration_s": s["summary"]["duration"],
            "polyline": s["polyline"]}

from flexpolyline import decode


def refresh_eta(vehicle_id: str, planned_polyline: str, planned_duration_s: int) -> dict:
    """
    Recompute remaining duration from GEOMETRY and current position.
    Arithmetic on data you already hold. Zero API calls.

    Re-routing on every GPS ping to refresh an ETA is the
    reverse-geocode-every-ping mistake wearing a different hat.
    """
    v = r.hgetall(f"veh:{vehicle_id}")
    lat, lng = float(v[b"lat"]), float(v[b"lng"])

    coords = decode(planned_polyline).polyline
    idx, off_route_m = _nearest_vertex(coords, lat, lng)

    if off_route_m > DEVIATION_THRESHOLD_M:
        return {"deviated": True}          # ← NOW call routing. Only now.

    remaining_frac = 1.0 - (idx / max(len(coords) - 1, 1))
    return {
        "deviated": False,
        "eta_s": int(planned_duration_s * remaining_frac),
    }

FLOW = "https://data.traffic.hereapi.com/v7/flow"


def route_traffic(planned_polyline: str) -> list[dict]:
    """
    `corridor:` accepts a Flexible Polyline + radius.

    For "what is the traffic on this route," a corridor is dramatically
    cheaper and more relevant than a bbox containing the whole city.
    """
    r = requests.get(FLOW, params={
        "in": f"corridor:{planned_polyline};r=50",
        "locationReferencing": "none",   # MANDATORY. `none` = no geometry back.
        "minJamFactor": 4.0,             # server-side filter
        "apiKey": API_KEY,
    }, timeout=15)
    r.raise_for_status()

    return [{"street": i["location"].get("description"),
             "jam_factor": i["currentFlow"]["jamFactor"]}   # 0 free … 10 closed
            for i in r.json().get("results", [])]

MATCH = "https://routematching.hereapi.com/v8/match/routelinks"


def match_closed_trip(trip_id: str) -> dict:
    """
    Batch. Nothing is waiting. Latency is worth nothing here.

    Segment and downsample BEFORE submission — in real feeds this removes
    a substantial fraction of points at no information cost.
    """
    points = segment_and_downsample(load_raw_trace(trip_id))

    r = requests.post(MATCH, params={
        "routeMatch": 1,
        "mode": "fastest;truck;traffic:disabled",
        "legal": "access,oneway,thrutraf,turn",
        "apiKey": API_KEY,
    }, data=to_csv(points), headers={"Content-Type": "text/plain"},
       timeout=70)                      # HERE cancels around 50 s of compute
    r.raise_for_status()
    body = r.json()

    # THE audit artifact. Anything less is an assertion.
    return {
        "raw_trace": points,                    # immutable source
        "route_links": body["RouteLinks"],      # segments actually driven
        "map_version": body["MapVersion"],      # ← cite this in any dispute
        "matched_at": int(time.time()),
        "low_confidence": [tp for tp in body["TracePoints"]
                           if tp.get("confidenceValue", 0) < 0.6],
    }