Nightly batch + live dispatch

# Late order arrives at 09:30. The current execution day's plan_id is in your
# cache (set by the nightly batch). Driver positions came from the
# route.started webhook earlier this morning.

PLAN_ID="..."            # active plan, status=in_progress
ROUTE_ID="..."           # driver you picked (see TS/Python for picking logic)

# (1) Add the new stop to the active plan. external_id is the late order's ID
#     from your source system — makes the add retry-safe.
curl -X POST "https://api.routal.com/v2/stops?private_key=YOUR_KEY&plan_id=${PLAN_ID}&project_id=YOUR_PROJECT_ID" \
  -H 'Content-Type: application/json' \
  -d '[
    {
      "external_id": "ORDER-9501",
      "label": "Acme Late Order",
      "location": { "lat": 41.22, "lng": 2.07, "address": "456 Industrial Park" },
      "duration": 480,
      "time_windows": [[36000, 64800]],
      "weight": 8,
      "volume": 0.1
    }
  ]'
# → returns the created stop. Save the stop_id.

# (2) The stop landed on the plan but isn't yet on any route. Two options:
#
#  2a. Assign manually to the route you picked, then re-sequence that route.
curl -X PUT "https://api.routal.com/v2/route/${ROUTE_ID}/stops?private_key=YOUR_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "stop_ids": [
      "EXISTING_STOP_1",
      "EXISTING_STOP_2",
      "NEW_STOP_ID",
      "EXISTING_STOP_3"
    ]
  }'
# Then ask Routal to find the best sequence for this route:
curl -X POST "https://api.routal.com/v2/route/${ROUTE_ID}/optimize?private_key=YOUR_KEY"

#  2b. Let Routal pick the best driver — conservative re-balance.
curl -X POST "https://api.routal.com/v2/plan/${PLAN_ID}/optimize?private_key=YOUR_KEY&keep_current_assignment=true"

import createClient from 'openapi-fetch';
import type { paths } from './routal';

const routal = createClient<paths>({ baseUrl: 'https://api.routal.com' });
const ROUTAL_API_KEY = process.env.ROUTAL_API_KEY!;
const PROJECT_ID = process.env.ROUTAL_PROJECT_ID!;

type LateOrder = {
  id: string;
  customer: string;
  lat: number;
  lng: number;
  serviceMinutes: number;
  windowFromSec: number;
  windowToSec: number;
  weightKg?: number;
  volumeM3?: number;
  requires?: string[];          // skills the order needs
};

/**
 * Inject a late order into the active plan using the
 * per-route re-sequence strategy.
 *
 * Steps:
 *  1. Resolve the active plan for today.
 *  2. Pick the best route (driver) for this order.
 *  3. Add the stop to the plan.
 *  4. Insert it into the chosen route's stop list.
 *  5. Ask Routal to re-sequence that route.
 *  6. Return the new stop position so dispatch can notify the driver.
 */
export async function injectLateOrder(order: LateOrder): Promise<{
  planId: string;
  routeId: string;
  stopId: string;
  sequence: number;
}> {
  const planId = await resolveActivePlanForToday();
  const route = await pickBestRoute(planId, order);
  const stopId = await addStopToPlan(planId, order);
  await appendStopToRoute(route.id, route.currentStopIds, stopId);
  const reoptimized = await reSequenceRoute(route.id);
  const sequence = reoptimized.stop_ids.indexOf(stopId);
  return { planId, routeId: route.id, stopId, sequence };
}

async function resolveActivePlanForToday(): Promise<string> {
  const today = new Date().toISOString().slice(0, 10);
  const { data, error } = await routal.GET('/v2/plans', {
    params: {
      query: {
        private_key: ROUTAL_API_KEY,
        project_id: PROJECT_ID,
        limit: 5,
        sort: 'created_at:desc',
      },
    },
  });
  if (error) throw error;
  const active = data!.docs?.find(
    (p) =>
      p.execution_date?.startsWith(today) &&
      (p.status === 'in_progress' || p.status === 'planning'),
  );
  if (!active) throw new Error(`no active plan for ${today}`);
  return active.id!;
}

type RouteSummary = { id: string; currentStopIds: string[]; remainingCapacity: number };

async function pickBestRoute(planId: string, order: LateOrder): Promise<RouteSummary> {
  // Naive heuristic: pick the route with the most remaining max_volume that
  // also covers the order's `requires` skills. Replace with your own logic
  // when you have driver-position data — typically lowest detour cost wins.
  const { data: routes, error } = await routal.GET('/v2/plan/{id}/routes', {
    params: { path: { id: planId }, query: { private_key: ROUTAL_API_KEY } },
  });
  if (error) throw error;
  const candidates = (routes ?? [])
    .filter((r) => r.status !== 'finished')
    .map((r) => ({
      id: r.id!,
      currentStopIds: (r.stops ?? []).map((s: { id?: string }) => s.id!).filter(Boolean),
      remainingCapacity: (r.max_volume ?? 0) - (r.volume ?? 0),
      provides: r.provides ?? [],
    }));
  const matching = candidates.filter((r) =>
    (order.requires ?? []).every((skill) => r.provides.includes(skill)),
  );
  if (matching.length === 0) throw new Error('no route can serve this order today');
  matching.sort((a, b) => b.remainingCapacity - a.remainingCapacity);
  return matching[0];
}

async function addStopToPlan(planId: string, order: LateOrder): Promise<string> {
  const { data, error } = await routal.POST('/v2/stops', {
    params: { query: { private_key: ROUTAL_API_KEY, plan_id: planId, project_id: PROJECT_ID } },
    body: [
      {
        external_id: order.id,
        label: order.customer,
        location: { lat: order.lat, lng: order.lng },
        duration: order.serviceMinutes * 60,
        time_windows: [[order.windowFromSec, order.windowToSec]],
        weight: order.weightKg,
        volume: order.volumeM3,
        requires: order.requires,
      },
    ] as never,
  });
  if (error) throw error;
  return (data as { id: string }[])[0].id;
}

async function appendStopToRoute(
  routeId: string,
  currentStopIds: string[],
  newStopId: string,
): Promise<void> {
  const { error } = await routal.PUT('/v2/route/{id}/stops', {
    params: { path: { id: routeId }, query: { private_key: ROUTAL_API_KEY } },
    body: { stop_ids: [...currentStopIds, newStopId] } as never,
  });
  if (error) throw error;
}

async function reSequenceRoute(routeId: string): Promise<{ stop_ids: string[] }> {
  const { data, error } = await routal.POST('/v2/route/{id}/optimize', {
    params: { path: { id: routeId }, query: { private_key: ROUTAL_API_KEY } },
  });
  if (error) throw error;
  return {
    stop_ids: ((data as { stops?: { id: string }[] }).stops ?? []).map((s) => s.id),
  };
}

import os
import requests
from datetime import date

ROUTAL_API_KEY = os.environ["ROUTAL_API_KEY"]
PROJECT_ID = os.environ["ROUTAL_PROJECT_ID"]
BASE = "https://api.routal.com"


def inject_late_order(order: dict) -> dict:
    """
    Inject a late order into the active plan using the per-route
    re-sequence strategy.
    """
    plan_id = resolve_active_plan_for_today()
    route = pick_best_route(plan_id, order)
    stop_id = add_stop_to_plan(plan_id, order)
    append_stop_to_route(route["id"], route["currentStopIds"], stop_id)
    new_sequence = re_sequence_route(route["id"])
    sequence = new_sequence.index(stop_id)
    return {
        "plan_id": plan_id,
        "route_id": route["id"],
        "stop_id": stop_id,
        "sequence": sequence,
    }


def resolve_active_plan_for_today() -> str:
    today = date.today().isoformat()
    resp = requests.get(
        f"{BASE}/v2/plans",
        params={"private_key": ROUTAL_API_KEY, "project_id": PROJECT_ID,
                "limit": 5, "sort": "created_at:desc"},
        timeout=30,
    )
    resp.raise_for_status()
    for plan in resp.json().get("docs", []):
        if (plan.get("execution_date") or "").startswith(today) and \
                plan.get("status") in ("in_progress", "planning"):
            return plan["id"]
    raise RuntimeError(f"no active plan for {today}")


def pick_best_route(plan_id: str, order: dict) -> dict:
    resp = requests.get(
        f"{BASE}/v2/plan/{plan_id}/routes",
        params={"private_key": ROUTAL_API_KEY},
        timeout=30,
    )
    resp.raise_for_status()
    candidates = []
    for r in resp.json():
        if r.get("status") == "finished":
            continue
        candidates.append({
            "id": r["id"],
            "currentStopIds": [s["id"] for s in (r.get("stops") or []) if s.get("id")],
            "remainingCapacity": (r.get("max_volume") or 0) - (r.get("volume") or 0),
            "provides": r.get("provides") or [],
        })
    requires = order.get("requires") or []
    matching = [r for r in candidates if all(s in r["provides"] for s in requires)]
    if not matching:
        raise RuntimeError("no route can serve this order today")
    matching.sort(key=lambda r: r["remainingCapacity"], reverse=True)
    return matching[0]


def add_stop_to_plan(plan_id: str, order: dict) -> str:
    payload = [{
        "external_id": order["id"],
        "label": order["customer"],
        "location": {"lat": order["lat"], "lng": order["lng"]},
        "duration": order["service_minutes"] * 60,
        "time_windows": [[order["window_from_sec"], order["window_to_sec"]]],
        "weight": order.get("weight_kg"),
        "volume": order.get("volume_m3"),
        "requires": order.get("requires"),
    }]
    resp = requests.post(
        f"{BASE}/v2/stops",
        params={"private_key": ROUTAL_API_KEY, "plan_id": plan_id, "project_id": PROJECT_ID},
        json=payload,
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()[0]["id"]


def append_stop_to_route(route_id: str, current_stop_ids: list[str], new_stop_id: str) -> None:
    resp = requests.put(
        f"{BASE}/v2/route/{route_id}/stops",
        params={"private_key": ROUTAL_API_KEY},
        json={"stop_ids": current_stop_ids + [new_stop_id]},
        timeout=30,
    )
    resp.raise_for_status()


def re_sequence_route(route_id: str) -> list[str]:
    resp = requests.post(
        f"{BASE}/v2/route/{route_id}/optimize",
        params={"private_key": ROUTAL_API_KEY},
        timeout=60,
    )
    resp.raise_for_status()
    body = resp.json()
    return [s["id"] for s in body.get("stops", [])]