Order Status

import type { Order, ShipmentStatus } from "@/components/blocks/order-status/order"
import { OrderTracking } from "@/components/blocks/order-status/order-tracking"

type ShopifyMoney = { amount: string; currencyCode: string }

type CustomerAccountOrder = {
  id: string
  name: string
  processedAt: string
  email: string | null
  financialStatus: "PAID" | "PENDING" | "PARTIALLY_REFUNDED" | "REFUNDED" | "VOIDED" | "AUTHORIZED"
  fulfillmentStatus: "FULFILLED" | "UNFULFILLED" | "PARTIALLY_FULFILLED" | "ON_HOLD"
  cancelledAt: string | null
  subtotal: ShopifyMoney
  totalShipping: ShopifyMoney
  totalTax: ShopifyMoney
  totalPrice: ShopifyMoney
  lineItems: {
    nodes: {
      id: string
      title: string
      variantTitle: string | null
      quantity: number
      price: ShopifyMoney
      image: { url: string; altText: string | null } | null
    }[]
  }
  fulfillments: {
    nodes: {
      id: string
      createdAt: string
      latestShipmentStatus: string | null
      estimatedDeliveryAt: string | null
      trackingInformation: { company: string | null; number: string | null; url: string | null }[]
      events: { nodes: { status: string; happenedAt: string }[] }
      fulfillmentLineItems: { nodes: { lineItem: { id: string }; quantity: number }[] }
    }[]
  }
}

const shipmentStatus: Record<string, ShipmentStatus> = {
  LABEL_PRINTED: "label_created",
  IN_TRANSIT: "in_transit",
  OUT_FOR_DELIVERY: "out_for_delivery",
  DELIVERED: "delivered",
  ATTEMPTED_DELIVERY: "attempted",
  DELAYED: "exception",
  FAILURE: "exception",
}

const status = (value: string | null): ShipmentStatus =>
  shipmentStatus[value ?? ""] ?? "in_transit"

export function fromCustomerAccount(order: CustomerAccountOrder): Order {
  return {
    id: order.id,
    name: order.name,
    createdAt: order.processedAt,
    currencyCode: order.totalPrice.currencyCode,
    email: order.email ?? undefined,
    lines: order.lineItems.nodes.map((line) => ({
      id: line.id,
      title: line.title,
      variantTitle: line.variantTitle ?? undefined,
      quantity: line.quantity,
      price: line.price,
      image: line.image
        ? { id: line.image.url, src: line.image.url, alt: line.image.altText ?? line.title }
        : undefined,
      fulfilledQuantity: 0,
      refundedQuantity: 0,
    })),
    subtotal: order.subtotal,
    shipping: order.totalShipping,
    tax: order.totalTax,
    total: order.totalPrice,
    discounts: [],
    paymentStatus: order.financialStatus.toLowerCase() as Order["paymentStatus"],
    fulfillmentStatus: order.fulfillmentStatus.toLowerCase() as Order["fulfillmentStatus"],
    cancelledAt: order.cancelledAt ?? undefined,
    fulfillments: order.fulfillments.nodes.map((fulfillment) => {
      const tracking = fulfillment.trackingInformation[0]
      return {
        id: fulfillment.id,
        createdAt: fulfillment.createdAt,
        status: status(fulfillment.latestShipmentStatus),
        carrier: tracking?.company ?? undefined,
        trackingNumber: tracking?.number ?? undefined,
        trackingUrl: tracking?.url ?? undefined,
        estimatedDelivery: fulfillment.estimatedDeliveryAt
          ? { from: fulfillment.estimatedDeliveryAt.slice(0, 10) }
          : undefined,
        lines: fulfillment.fulfillmentLineItems.nodes.map((item) => ({
          lineId: item.lineItem.id,
          quantity: item.quantity,
        })),
        events: fulfillment.events.nodes.map((event) => ({
          status: status(event.status),
          at: event.happenedAt,
          message: event.status.charAt(0) + event.status.slice(1).toLowerCase().replace(/_/g, " "),
        })),
      }
    }),
    refunds: [],
    events: [],
  }
}

export function OrderStatusPage({ order }: { order: CustomerAccountOrder }) {
  return <OrderTracking order={fromCustomerAccount(order)} />
}

import type { Fulfillment, ShipmentEvent, ShipmentStatus } from "@/components/blocks/order-status/order"

type EasyPostTracker = {
  tracking_code: string
  carrier: string
  public_url: string
  status: string
  est_delivery_date: string | null
  tracking_details: {
    status: string
    message: string
    datetime: string
    tracking_location: { city: string | null; state: string | null }
  }[]
}

const statuses: Record<string, ShipmentStatus> = {
  pre_transit: "label_created",
  in_transit: "in_transit",
  out_for_delivery: "out_for_delivery",
  delivered: "delivered",
  available_for_pickup: "attempted",
  return_to_sender: "exception",
  failure: "exception",
  cancelled: "cancelled",
}

const toStatus = (value: string): ShipmentStatus => statuses[value] ?? "in_transit"

export function applyTrackerUpdate(fulfillment: Fulfillment, tracker: EasyPostTracker): Fulfillment {
  const events: ShipmentEvent[] = tracker.tracking_details.map((detail) => ({
    status: toStatus(detail.status),
    at: detail.datetime,
    message: detail.message,
    location: [detail.tracking_location.city, detail.tracking_location.state]
      .filter(Boolean)
      .join(", ") || undefined,
  }))
  const status = toStatus(tracker.status)
  return {
    ...fulfillment,
    status,
    carrier: tracker.carrier,
    trackingNumber: tracker.tracking_code,
    trackingUrl: tracker.public_url,
    events,
    estimatedDelivery: tracker.est_delivery_date
      ? { from: tracker.est_delivery_date.slice(0, 10) }
      : fulfillment.estimatedDelivery,
    deliveredAt:
      status === "delivered"
        ? events.findLast((event) => event.status === "delivered")?.at
        : undefined,
  }
}

export async function POST(request: Request) {
  const body = (await request.json()) as { description: string; result: EasyPostTracker }
  if (body.description !== "tracker.updated") return new Response(null, { status: 204 })
  const fulfillment = await loadFulfillmentByTracking(body.result.tracking_code)
  await saveFulfillment(applyTrackerUpdate(fulfillment, body.result))
  return new Response(null, { status: 200 })
}

declare function loadFulfillmentByTracking(code: string): Promise<Fulfillment>
declare function saveFulfillment(fulfillment: Fulfillment): Promise<void>

"use client"

import { money } from "../price/money"
import type { Order } from "@/components/blocks/order-status/order"
import { ReturnRequest, type ReturnRequestResult } from "@/components/blocks/order-status/return-request"

export function StartReturn({ order, onClose }: { order: Order; onClose: () => void }) {
  return (
    <ReturnRequest
      order={order}
      windowDays={30}
      returnShippingFee={money("5.95", order.currencyCode)}
      supportHref="/contact"
      onCancel={onClose}
      onDone={onClose}
      onSubmit={async (request) => {
        const response = await fetch(`/api/orders/${order.id}/returns`, {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify(request),
        })
        if (!response.ok) {
          const { message } = (await response.json()) as { message?: string }
          throw new Error(message ?? "We couldn’t start your return. Try again in a minute.")
        }
        return (await response.json()) as ReturnRequestResult
      }}
    />
  )
}