Package tracking

# (1) Create a delivery stop carrying three tracked parcels. Only `identifier`
#     is accepted per package — status is server-managed.
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": "ORD-7741",
      "label": "Pharma Plus — Calle Mayor 3",
      "location": { "lat": 40.4168, "lng": -3.7038, "address": "Calle Mayor 3, 28013 Madrid" },
      "duration": 240,
      "weight": 14.0,
      "packages": [
        { "identifier": "PKG-7741-01" },
        { "identifier": "PKG-7741-02" },
        { "identifier": "PKG-7741-03" }
      ],
      "tasks": [
        { "type": "signature", "label": "Receiver signature" }
      ]
    }
  ]'

# (2) Optimize + dispatch — identical to any other plan.
curl -X POST "https://api.routal.com/v2/plan/PLAN_ID/optimize/async?private_key=YOUR_KEY"
curl -X POST "https://api.routal.com/v2/route/ROUTE_ID/dispatch?private_key=YOUR_KEY"

# (3) Reconcile after stop.reported — read per-parcel status off the stop.
curl -s "https://api.routal.com/v2/stop/STOP_ID?private_key=YOUR_KEY" | \
  jq '.packages[] | { identifier, status, delivered_at }'
# => { "identifier": "PKG-7741-01", "status": "delivered", "delivered_at": "..." }
#    { "identifier": "PKG-7741-02", "status": "delivered", "delivered_at": "..." }
#    { "identifier": "PKG-7741-03", "status": "picked",    "delivered_at": null }   ← came back on the van

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 ParcelDelivery = {
  orderId: string;          // becomes external_id
  receiver: string;
  addressLine: string;
  lat: number;
  lng: number;
  weightKg: number;
  parcelIds: string[];      // your barcodes / SSCCs — become package identifiers
};

/** Create one delivery stop per order, each carrying its tracked parcels. */
export async function pushDeliveries(planId: string, deliveries: ParcelDelivery[]) {
  if (deliveries.length === 0) return { created: 0 };

  const { error } = await routal.POST('/v2/stops', {
    params: { query: { private_key: ROUTAL_API_KEY, plan_id: planId, project_id: PROJECT_ID } },
    body: deliveries.map((d) => ({
      external_id: d.orderId,
      label: `${d.receiver} — ${d.addressLine}`,
      location: { lat: d.lat, lng: d.lng, address: d.addressLine },
      duration: 240,
      weight: d.weightKg,
      // Only `identifier` is read on input. Never set status here.
      packages: d.parcelIds.map((identifier) => ({ identifier })),
      tasks: [{ type: 'signature', label: 'Receiver signature' }],
    })) as never,
  });
  if (error) throw error;
  return { created: deliveries.length };
}

type Package = {
  identifier: string;
  status: 'pending' | 'picked' | 'delivered';
  picked_at?: string;
  delivered_at?: string;
};

/**
 * Reconcile parcels after `stop.reported`. The webhook payload does NOT carry
 * package status — read it off the stop. Partial-aware: every parcel is written
 * back individually, never collapsed into one stop outcome.
 */
export async function reconcileStopParcels(stopId: string) {
  const { data, error } = await routal.GET('/v2/stop/{stop_id}', {
    params: { path: { stop_id: stopId }, query: { private_key: ROUTAL_API_KEY } },
  });
  if (error) throw error;

  const packages = ((data as { packages?: Package[] }).packages ?? []);
  const delivered = packages.filter((p) => p.status === 'delivered');
  const notDelivered = packages.filter((p) => p.status !== 'delivered');

  for (const p of delivered) {
    await markParcelInWms(p.identifier, 'delivered', p.delivered_at);
  }
  for (const p of notDelivered) {
    // status is 'picked' (on the van) or 'pending' (never loaded). Trigger the
    // right WMS rule: re-attempt tomorrow, return to depot, customer outreach.
    await markParcelInWms(p.identifier, p.status, undefined);
  }

  return {
    total: packages.length,
    delivered: delivered.length,
    partial: delivered.length > 0 && notDelivered.length > 0,
  };
}

declare function markParcelInWms(id: string, status: string, at?: string): Promise<void>;

import os, requests

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


def push_deliveries(plan_id: str, deliveries: list[dict]) -> dict:
    """deliveries: [{order_id, receiver, address, lat, lng, weight_kg, parcel_ids}, ...]"""
    if not deliveries:
        return {"created": 0}

    payload = [
        {
            "external_id": d["order_id"],
            "label": f"{d['receiver']} — {d['address']}",
            "location": {"lat": d["lat"], "lng": d["lng"], "address": d["address"]},
            "duration": 240,
            "weight": d["weight_kg"],
            # Only `identifier` is read on input. Status is server-managed.
            "packages": [{"identifier": pid} for pid in d["parcel_ids"]],
            "tasks": [{"type": "signature", "label": "Receiver signature"}],
        }
        for d in deliveries
    ]
    resp = requests.post(
        f"{BASE}/v2/stops",
        params={"private_key": ROUTAL_API_KEY, "plan_id": plan_id, "project_id": PROJECT_ID},
        json=payload,
        timeout=60,
    )
    resp.raise_for_status()
    return {"created": len(deliveries)}


def reconcile_stop_parcels(stop_id: str) -> dict:
    """Call on stop.reported. The webhook does NOT carry package status — read the stop."""
    resp = requests.get(
        f"{BASE}/v2/stop/{stop_id}",
        params={"private_key": ROUTAL_API_KEY},
        timeout=30,
    )
    resp.raise_for_status()
    packages = resp.json().get("packages", [])

    delivered = [p for p in packages if p.get("status") == "delivered"]
    not_delivered = [p for p in packages if p.get("status") != "delivered"]

    for p in delivered:
        mark_parcel_in_wms(p["identifier"], "delivered", p.get("delivered_at"))
    for p in not_delivered:
        # 'picked' = still on the van, 'pending' = never loaded.
        mark_parcel_in_wms(p["identifier"], p.get("status"), None)

    return {
        "total": len(packages),
        "delivered": len(delivered),
        "partial": len(delivered) > 0 and len(not_delivered) > 0,
    }