FROM WHITEBOARD CHAOS TO A SELF-DRIVING DISPATCH ENGINE.

CREATE TYPE delivery_stage AS ENUM (
  'pending_quote',
  'assigned',
  'in_transit',
  'delivered'
);

CREATE OR REPLACE FUNCTION assign_driver_atomic(
  p_order_id UUID,
  p_driver_id UUID
) RETURNS orders AS $$
DECLARE
  v_order orders;
BEGIN
  PERFORM 1 FROM drivers
  WHERE id = p_driver_id AND status = 'available'
  FOR UPDATE NOWAIT;

  UPDATE drivers SET status = 'on_route' WHERE id = p_driver_id;

  UPDATE orders
  SET stage = 'assigned',
      driver_id = p_driver_id,
      assigned_at = NOW()
  WHERE id = p_order_id AND stage = 'pending_quote'
  RETURNING * INTO v_order;

  RETURN v_order;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;

export async function approveAndDispatchOrder(
  orderId: string,
  driverId: string
) {
  const { data: lockedOrder, error } = await supabase.rpc(
    "assign_driver_atomic",
    { p_order_id: orderId, p_driver_id: driverId }
  );

  if (error || !lockedOrder) {
    throw new Error("Driver is already assigned to an active route.");
  }

  await supabase.channel(`order:${orderId}`).send({
    type: "broadcast",
    event: "STAGE_LOCKED",
    payload: { stage: "assigned", driverId, timestamp: Date.now() },
  });

  return lockedOrder;
}

export function useLiveOrderTracker(trackingToken: string) {
  const [order, setOrder] = useState<OrderRecord | null>(null);

  useEffect(() => {
    const channel = supabase
      .channel(`tracker:${trackingToken}`)
      .on(
        "postgres_changes",
        {
          event: "UPDATE",
          schema: "public",
          table: "orders",
          filter: `tracking_token=eq.${trackingToken}`,
        },
        (payload) => setOrder(payload.new as OrderRecord)
      )
      .subscribe();

    return () => { void supabase.removeChannel(channel); };
  }, [trackingToken]);

  return order;
}

export async function completeDeliveryWithPod(
  orderId: string,
  signatureBlob: Blob,
  recipientName: string
) {
  const filePath = `pod/${orderId}_${Date.now()}.png`;
  const { error: uploadErr } = await supabase.storage
    .from("delivery-proofs")
    .upload(filePath, signatureBlob, { contentType: "image/png" });

  if (uploadErr) throw uploadErr;

  return supabase
    .from("orders")
    .update({
      stage: "delivered",
      pod_signature_path: filePath,
      received_by: recipientName,
      delivered_at: new Date().toISOString(),
    })
    .eq("id", orderId);
}