Shipping Methods

"use client"

import * as React from "react"

import type { ShippingRate } from "@/components/blocks/shipping-methods/shipping"
import { ShippingMethods } from "@/components/blocks/shipping-methods/shipping-methods"

type ShopifyDeliveryOption = {
  handle: string
  title: string | null
  description: string | null
  deliveryMethodType: "SHIPPING" | "PICK_UP" | "LOCAL" | "PICKUP_POINT" | "NONE"
  estimatedCost: { amount: string; currencyCode: string }
}

type ShopifyDeliveryGroup = {
  id: string
  deliveryOptions: ShopifyDeliveryOption[]
  selectedDeliveryOption: { handle: string } | null
}

const transitDays: Record<string, [number, number]> = {
  Standard: [3, 5],
  Express: [1, 2],
}

function fromShopify(group: ShopifyDeliveryGroup): ShippingRate[] {
  return group.deliveryOptions.map((option) => ({
    id: option.handle,
    title: option.title ?? "Shipping",
    price: option.estimatedCost,
    delivery: { businessDays: transitDays[option.title ?? ""] ?? [3, 7] },
    kind:
      option.deliveryMethodType === "PICK_UP" ||
      option.deliveryMethodType === "PICKUP_POINT"
        ? "pickup"
        : option.deliveryMethodType === "LOCAL"
          ? "local"
          : "ship",
    pickup:
      option.deliveryMethodType === "PICK_UP"
        ? { name: option.title ?? "Store pickup", address: option.description ?? "" }
        : undefined,
    note: option.deliveryMethodType === "PICK_UP" ? undefined : option.description ?? undefined,
  }))
}

export function CheckoutDelivery({
  group,
  loading,
  selectDeliveryOption,
}: {
  group: ShopifyDeliveryGroup | null
  loading: boolean
  selectDeliveryOption: (groupId: string, handle: string) => Promise<void>
}) {
  const rates = React.useMemo(() => (group ? fromShopify(group) : []), [group])
  return (
    <ShippingMethods
      rates={rates}
      status={loading ? "loading" : "idle"}
      value={group?.selectedDeliveryOption?.handle ?? null}
      onValueChange={(handle) => {
        if (group) void selectDeliveryOption(group.id, handle)
      }}
    />
  )
}

"use client"

import { money } from "../price/money"
import type { ShippingRate } from "@/components/blocks/shipping-methods/shipping"
import { ShippingMethods } from "@/components/blocks/shipping-methods/shipping-methods"

type ShippoRate = {
  object_id: string
  amount: string
  currency: string
  provider: string
  servicelevel: { name: string; token: string }
  estimated_days: number | null
}

type EasyPostRate = {
  id: string
  rate: string
  currency: string
  carrier: string
  service: string
  delivery_days: number | null
  delivery_date: string | null
}

export function fromShippo(rate: ShippoRate): ShippingRate {
  const days = rate.estimated_days ?? 5
  return {
    id: rate.object_id,
    title: rate.servicelevel.name,
    carrier: rate.provider,
    price: money(rate.amount, rate.currency),
    delivery: { businessDays: [days, days] },
    kind: "ship",
  }
}

export function fromEasyPost(rate: EasyPostRate): ShippingRate {
  const days = rate.delivery_days ?? 5
  return {
    id: rate.id,
    title: rate.service.replace(/([a-z])([A-Z])/g, "$1 $2"),
    carrier: rate.carrier,
    price: money(rate.rate, rate.currency),
    delivery: rate.delivery_date
      ? { from: rate.delivery_date.slice(0, 10) }
      : { businessDays: [days, days] },
    kind: "ship",
  }
}

export function CarrierRates({
  rates,
  status,
  selected,
  onSelect,
  refetch,
  editAddress,
}: {
  rates: ShippoRate[]
  status: "idle" | "loading" | "error"
  selected: string | null
  onSelect: (rateId: string) => void
  refetch: () => Promise<void>
  editAddress: () => void
}) {
  return (
    <ShippingMethods
      rates={rates.map(fromShippo)}
      status={status}
      value={selected}
      onValueChange={onSelect}
      onRetry={refetch}
      onChangeAddress={editAddress}
      calendar={{ holidays: ["2026-11-26", "2026-12-25"] }}
    />
  )
}

"use client"

import { fromMinorUnits } from "../price/money"
import type { ShippingRate } from "@/components/blocks/shipping-methods/shipping"
import { ShippingMethods } from "@/components/blocks/shipping-methods/shipping-methods"

type StripeEstimateUnit = "hour" | "day" | "business_day" | "week" | "month"

type StripeShippingRate = {
  id: string
  display_name: string | null
  fixed_amount: { amount: number; currency: string } | null
  delivery_estimate: {
    minimum: { unit: StripeEstimateUnit; value: number } | null
    maximum: { unit: StripeEstimateUnit; value: number } | null
  } | null
}

function toBusinessDays(estimate?: { unit: StripeEstimateUnit; value: number } | null) {
  if (!estimate) return 5
  if (estimate.unit === "hour") return Math.ceil(estimate.value / 24)
  if (estimate.unit === "week") return estimate.value * 5
  if (estimate.unit === "month") return estimate.value * 21
  return estimate.value
}

export function fromStripe(rate: StripeShippingRate): ShippingRate {
  const amount = rate.fixed_amount ?? { amount: 0, currency: "usd" }
  return {
    id: rate.id,
    title: rate.display_name ?? "Shipping",
    price: fromMinorUnits(amount.amount, amount.currency),
    delivery: {
      businessDays: [
        toBusinessDays(rate.delivery_estimate?.minimum),
        toBusinessDays(rate.delivery_estimate?.maximum ?? rate.delivery_estimate?.minimum),
      ],
    },
    kind: "ship",
  }
}

export function StripeShippingOptions({
  shippingRates,
  value,
  updateSession,
}: {
  shippingRates: StripeShippingRate[]
  value: string | null
  updateSession: (shippingRateId: string) => Promise<void>
}) {
  return (
    <ShippingMethods
      rates={shippingRates.map(fromStripe)}
      value={value}
      onValueChange={(id) => void updateSession(id)}
    />
  )
}