import os
import time
from dataclasses import dataclass, asdict
import requests

HOST = "https://router.hereapi.com/v8/routes"
API_KEY = os.environ["HERE_API_KEY"]


@dataclass(frozen=True)
class TruckProfile:
    """
    Vehicle constraints. These belong on the VEHICLE RECORD in your database,
    never hardcoded at a call site. A refactor that drops one is invisible in
    code review and returns 200.

    UNITS ARE NOT OBVIOUS AND ARE NOT VALIDATED FOR PLAUSIBILITY.
    """
    height_cm: int          # centimetres. 410 = 4.1 m
    gross_weight_kg: int    # kilograms
    axle_count: int         # base vehicle + ALL trailers
    width_cm: int | None = None
    length_cm: int | None = None
    trailer_count: int | None = None

    def to_params(self) -> dict:
        p = {
            "vehicle[height]": self.height_cm,
            "vehicle[grossWeight]": self.gross_weight_kg,
            "vehicle[axleCount]": self.axle_count,
        }
        if self.width_cm:      p["vehicle[width]"] = self.width_cm
        if self.length_cm:     p["vehicle[length]"] = self.length_cm
        if self.trailer_count: p["vehicle[trailerCount]"] = self.trailer_count
        return p


class EntitlementError(Exception): ...
class NoRouteError(Exception):
    """No LEGAL path exists. Correct outcome. Do not relax constraints."""


def truck_route(origin: str, destination: str, profile: TruckProfile) -> dict:
    if profile.height_cm > 500:
        raise ValueError("height_cm looks like millimetres")
    if profile.height_cm < 100:
        raise ValueError("height_cm looks like metres — you meant centimetres")

    params = {
        "transportMode": "truck",
        "origin": origin,
        "destination": destination,
        "return": "summary,polyline",
        "apiKey": API_KEY,
        **profile.to_params(),
    }

    backoff = 1.0
    for _ in range(3):
        resp = requests.get(HOST, params=params, timeout=20)
        if resp.status_code == 403:
            raise EntitlementError("Truck routing not entitled")
        if resp.status_code == 429 or resp.status_code >= 500:
            time.sleep(backoff); backoff *= 2; continue
        resp.raise_for_status()
        break
    else:
        raise RuntimeError("Truck routing failed after retries")

    body = resp.json()
    if not body.get("routes"):
        raise NoRouteError(str(body.get("notice", [])))

    s = body["routes"][0]["sections"][0]
    return {"duration_s": s["summary"]["duration"],
            "length_m": s["summary"]["length"],
            "polyline": s.get("polyline")}


if __name__ == "__main__":
    fleet_profile = TruckProfile(height_cm=410, gross_weight_kg=35000, axle_count=5)
    try:
        r = truck_route("42.0641,-88.0509", "41.5250,-88.0817", fleet_profile)
        print(r["duration_s"], r["length_m"])
    except NoRouteError:
        # Escalate to a dispatcher. Do NOT fall back to car routing.
        print("No legal route for this vehicle")

const HOST = "https://router.hereapi.com/v8/routes";
const API_KEY = process.env.HERE_API_KEY;

class EntitlementError extends Error {}
class NoRouteError extends Error {}

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

/**
 * @param {{heightCm:number, grossWeightKg:number, axleCount:number}} profile
 *   Constraints belong on the vehicle record. Never hardcode them here.
 *   heightCm is CENTIMETRES. Passing 4.1 declares a 4cm truck.
 */
export async function truckRoute(origin, destination, profile) {
  if (profile.heightCm < 100 || profile.heightCm > 500) {
    throw new Error(`heightCm=${profile.heightCm} — wrong unit?`);
  }

  const params = new URLSearchParams({
    transportMode: "truck",
    origin,
    destination,
    return: "summary,polyline",
    "vehicle[height]": String(profile.heightCm),
    "vehicle[grossWeight]": String(profile.grossWeightKg),
    "vehicle[axleCount]": String(profile.axleCount),
    apiKey: API_KEY,
  });

  let backoff = 1000;
  let resp;
  for (let i = 0; i < 3; i++) {
    const ctrl = new AbortController();
    const t = setTimeout(() => ctrl.abort(), 20_000);
    try { resp = await fetch(`${HOST}?${params}`, { signal: ctrl.signal }); }
    finally { clearTimeout(t); }

    if (resp.status === 403) throw new EntitlementError("Truck routing not entitled");
    if (resp.status === 429 || resp.status >= 500) {
      await sleep(backoff + Math.random() * 250); backoff *= 2; continue;
    }
    if (!resp.ok) throw new Error(`HERE returned ${resp.status}`);
    break;
  }

  const body = await resp.json();
  if (!body.routes?.length) throw new NoRouteError(JSON.stringify(body.notice ?? []));

  const { summary, polyline } = body.routes[0].sections[0];
  return { durationS: summary.duration, lengthM: summary.length, polyline };
}

curl -gX GET 'https://router.hereapi.com/v8/routes' \
  --data-urlencode 'transportMode=truck' \
  --data-urlencode 'origin=42.0641,-88.0509' \
  --data-urlencode 'destination=41.5250,-88.0817' \
  --data-urlencode 'vehicle[height]=410' \
  --data-urlencode 'vehicle[grossWeight]=35000' \
  --data-urlencode 'vehicle[axleCount]=5' \
  --data-urlencode 'return=summary,polyline' \
  --data-urlencode "apiKey=${HERE_API_KEY}" \
  -G