import os
import time
import requests
from flexpolyline import decode  # pip install flexpolyline

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


class EntitlementError(Exception): ...
class NoIsolineError(Exception):
    """isolineCalculationFailed — e.g. origin in the ocean."""


def isolines(
    origin: str,                    # "lat,lng"
    range_values: list[int],        # seconds (time), metres (distance), Wh (consumption)
    range_type: str = "time",       # "time" | "distance" | "consumption"
    transport_mode: str = "car",
    departure_time: str | None = None,
    max_points: int = 200,          # >=30 enforced; >100 recommended for quality
) -> list[dict]:
    """
    Compute one or more isoline bands from a single origin.

    Multiple range values in ONE call. Do not loop this endpoint to get
    10/20/30-minute bands — request all three at once.
    """
    params = {
        "transportMode": transport_mode,
        "origin": origin,
        "range[type]": range_type,
        # Comma-separated. One request, three polygons.
        "range[values]": ",".join(str(v) for v in range_values),
        "shape[maxPoints]": max_points,
        "apiKey": API_KEY,
    }
    if departure_time:
        # A 3am polygon applied to 5pm operations is a fiction.
        params["departureTime"] = departure_time

    backoff = 1.0
    for _ in range(3):
        resp = requests.get(HOST, params=params, timeout=30)
        if resp.status_code == 403:
            raise EntitlementError("Isoline 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("Isoline failed after retries")

    body = resp.json()

    # Failure is signalled in `notices`, not in the HTTP status.
    if not body.get("isolines"):
        raise NoIsolineError(str(body.get("notices", [])))

    out = []
    for iso in body["isolines"]:
        # Each isoline has 1..n polygons. Multiple polygons occur when the
        # reachable area is disconnected — islands, ferries, one-way systems.
        rings = []
        for poly in iso["polygons"]:
            # Flexible Polyline, NOT Google's encoded polyline algorithm.
            rings.append(decode(poly["outer"]))
        out.append({
            "range_type": iso["range"]["type"],
            "range_value": iso["range"]["value"],
            "rings": rings,          # list of [(lat, lng), ...]
        })
    return out


if __name__ == "__main__":
    # Three delivery bands, one request, computed at peak departure.
    bands = isolines(
        origin="41.8845,-87.6386",
        range_values=[600, 1200, 1800],   # 10, 20, 30 minutes
        range_type="time",
        departure_time="2026-07-15T17:30:00",
    )
    for b in bands:
        n = sum(len(r) for r in b["rings"])
        print(f"{b['range_value']}s band: {len(b['rings'])} polygon(s), {n} vertices")
        # Next: simplify, then INSERT into PostGIS. Never call this at request time.

import { decode } from "@here/flexpolyline";

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

class EntitlementError extends Error {}
class NoIsolineError extends Error {}

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

export async function isolines(origin, rangeValues, {
  rangeType = "time",
  transportMode = "car",
  departureTime,
  maxPoints = 200,
} = {}) {
  const params = new URLSearchParams({
    transportMode,
    origin,
    "range[type]": rangeType,
    "range[values]": rangeValues.join(","),   // one call, many bands
    "shape[maxPoints]": String(maxPoints),
    apiKey: API_KEY,
  });
  if (departureTime) params.set("departureTime", departureTime);

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

    if (resp.status === 403) throw new EntitlementError("Isoline 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.isolines?.length) throw new NoIsolineError(JSON.stringify(body.notices ?? []));

  return body.isolines.map((iso) => ({
    rangeType: iso.range.type,
    rangeValue: iso.range.value,
    rings: iso.polygons.map((p) => decode(p.outer).polyline),
  }));
}

# Three time bands in one request
curl -gX GET 'https://isoline.router.hereapi.com/v8/isolines' \
  --data-urlencode 'transportMode=car' \
  --data-urlencode 'origin=41.8845,-87.6386' \
  --data-urlencode 'range[type]=time' \
  --data-urlencode 'range[values]=600,1200,1800' \
  --data-urlencode 'shape[maxPoints]=200' \
  --data-urlencode "apiKey=${HERE_API_KEY}" \
  -G

# Truck service area — smaller and differently shaped than a car isoline.
# NOTE: vehicle[...] supersedes the deprecated truck[...] parameters.
curl -gX GET 'https://isoline.router.hereapi.com/v8/isolines' \
  --data-urlencode 'transportMode=truck' \
  --data-urlencode 'origin=41.8845,-87.6386' \
  --data-urlencode 'range[type]=time' \
  --data-urlencode 'range[values]=1800' \
  --data-urlencode 'vehicle[height]=410' \
  --data-urlencode 'vehicle[grossWeight]=35000' \
  --data-urlencode "apiKey=${HERE_API_KEY}" \
  -G

# EV consumption isoline — "everywhere reachable on this charge", in Wh
curl -gX GET 'https://isoline.router.hereapi.com/v8/isolines' \
  --data-urlencode 'transportMode=car' \
  --data-urlencode 'origin=41.8845,-87.6386' \
  --data-urlencode 'range[type]=consumption' \
  --data-urlencode 'range[values]=20000' \
  --data-urlencode "apiKey=${HERE_API_KEY}" \
  -G