Refund

"use client"

import type { Order, Refund } from "../order-status/order"
import { RefundSheet } from "@/components/blocks/refund/refund-sheet"
import type { RefundRequest } from "@/components/blocks/refund/refund-form"

type ShopifyMoneyBag = { shopMoney: { amount: string; currencyCode: string } }

type RefundCreateResponse = {
  refund: {
    id: string
    createdAt: string
    totalRefundedSet: ShopifyMoneyBag
    transactions: { nodes: { status: "SUCCESS" | "PENDING" | "FAILURE" | "ERROR"; errorCode: string | null }[] }
  } | null
  userErrors: { field: string[] | null; message: string }[]
}

async function admin<T>(query: string, variables: Record<string, unknown>): Promise<T> {
  const response = await fetch("/api/shopify/admin", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ query, variables }),
  })
  const { data, errors } = await response.json()
  if (errors?.length) throw new Error(errors[0].message)
  return data
}

const SUGGESTED_REFUND = `
  query Suggested($id: ID!, $lines: [RefundLineItemInput!], $shipping: Money) {
    order(id: $id) {
      suggestedRefund(refundLineItems: $lines, shippingAmount: $shipping) {
        suggestedTransactions { gateway parentTransaction { id } amountSet { shopMoney { amount } } }
      }
    }
  }
`

const REFUND_CREATE = `
  mutation Refund($input: RefundInput!) {
    refundCreate(input: $input) {
      refund {
        id
        createdAt
        totalRefundedSet { shopMoney { amount currencyCode } }
        transactions(first: 5) { nodes { status errorCode } }
      }
      userErrors { field message }
    }
  }
`

async function refundOnShopify(request: RefundRequest): Promise<Refund> {
  const lines = request.lines.map((line) => ({
    lineItemId: line.lineId,
    quantity: line.quantity,
    restockType: line.restock ? "RETURN" : "NO_RESTOCK",
    locationId: line.restock ? request.restockLocationId : undefined,
  }))
  const suggested = await admin<{
    order: {
      suggestedRefund: {
        suggestedTransactions: {
          gateway: string
          parentTransaction: { id: string }
          amountSet: { shopMoney: { amount: string } }
        }[]
      }
    }
  }>(SUGGESTED_REFUND, { id: request.orderId, lines, shipping: request.shipping.amount })

  let left = Number(request.amount.amount)
  const transactions = suggested.order.suggestedRefund.suggestedTransactions.map((item) => {
    const amount = Math.min(left, Number(item.amountSet.shopMoney.amount))
    left -= amount
    return {
      orderId: request.orderId,
      gateway: item.gateway,
      kind: "REFUND",
      parentId: item.parentTransaction.id,
      amount: amount.toFixed(2),
    }
  })

  const { refundCreate } = await admin<{ refundCreate: RefundCreateResponse }>(REFUND_CREATE, {
    input: {
      orderId: request.orderId,
      note: [request.reason, request.note].filter(Boolean).join(": "),
      notify: request.notify,
      refundLineItems: lines,
      shipping: { amount: request.shipping.amount },
      transactions,
    },
  })
  if (refundCreate.userErrors.length > 0) throw new Error(refundCreate.userErrors[0].message)
  const refund = refundCreate.refund!
  const states = refund.transactions.nodes.map((item) => item.status)
  return {
    id: refund.id,
    createdAt: refund.createdAt,
    status: states.includes("FAILURE") || states.includes("ERROR")
      ? "failed"
      : states.includes("PENDING")
        ? "pending"
        : "succeeded",
    amount: {
      amount: refund.totalRefundedSet.shopMoney.amount,
      currencyCode: refund.totalRefundedSet.shopMoney.currencyCode,
    },
    shipping: request.shipping,
    lines: request.lines,
    reason: request.reason ?? undefined,
    failureMessage: refund.transactions.nodes.find((item) => item.errorCode)?.errorCode ?? undefined,
  }
}

export function ShopifyRefund({ order, onRefunded }: { order: Order; onRefunded: (refund: Refund) => void }) {
  return (
    <RefundSheet
      order={order}
      locations={[
        { id: "gid://shopify/Location/1", name: "Hayes Valley store" },
        { id: "gid://shopify/Location/2", name: "Oakland warehouse" },
      ]}
      onRefund={refundOnShopify}
      onComplete={onRefunded}
    />
  )
}

"use server"

import { toMinorUnits } from "../price/money"
import type { Refund } from "../order-status/order"
import type { RefundRequest } from "@/components/blocks/refund/refund-form"

type StripeRefund = {
  id: string
  amount: number
  currency: string
  created: number
  status: "pending" | "requires_action" | "succeeded" | "failed" | "canceled"
  failure_reason?: "charge_for_pending_refund_disputed" | "declined" | "expired_or_canceled_card" | "insufficient_funds" | "lost_or_stolen_card" | "merchant_request" | "unknown"
}

const failureMessages: Record<NonNullable<StripeRefund["failure_reason"]>, string> = {
  charge_for_pending_refund_disputed: "The customer disputed this charge, so the refund was canceled.",
  declined: "The card issuer declined the refund. Try store credit instead.",
  expired_or_canceled_card: "The card has expired or was canceled. Refund to store credit or by bank transfer.",
  insufficient_funds: "Your Stripe balance is too low to cover this refund.",
  lost_or_stolen_card: "The card was reported lost or stolen. Refund another way.",
  merchant_request: "The refund was canceled from your Stripe dashboard.",
  unknown: "Stripe couldn’t complete the refund. Nothing was charged.",
}

async function stripeRefund(paymentIntent: string, amount: number, idempotencyKey: string, metadata: Record<string, string>) {
  const body = new URLSearchParams({ payment_intent: paymentIntent, amount: String(amount) })
  for (const [key, value] of Object.entries(metadata)) body.append(`metadata[${key}]`, value)
  const response = await fetch("https://api.stripe.com/v1/refunds", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.STRIPE_SECRET_KEY}`,
      "Content-Type": "application/x-www-form-urlencoded",
      "Idempotency-Key": idempotencyKey,
    },
    body,
  })
  const json = await response.json()
  if (!response.ok) throw new Error(json.error?.message ?? "Stripe couldn’t create the refund.")
  return json as StripeRefund
}

export async function refundWithStripe(
  request: RefundRequest,
  paymentIntents: Record<string, string>,
  idempotencyKey: string
): Promise<Refund> {
  const results = await Promise.all(
    request.transactions.map((transaction, index) =>
      stripeRefund(
        paymentIntents[transaction.paymentId],
        toMinorUnits(transaction.amount),
        `${idempotencyKey}-${index}`,
        { order_id: request.orderId, reason: request.reason ?? "" }
      )
    )
  )
  const failed = results.find((item) => item.status === "failed" || item.status === "canceled")
  return {
    id: results.map((item) => item.id).join(","),
    createdAt: new Date(Math.max(...results.map((item) => item.created)) * 1000).toISOString(),
    status: failed ? "failed" : results.every((item) => item.status === "succeeded") ? "succeeded" : "pending",
    amount: request.amount,
    shipping: request.shipping,
    lines: request.lines,
    reason: request.reason ?? undefined,
    note: request.note || undefined,
    failureMessage: failed ? failureMessages[failed.failure_reason ?? "unknown"] : undefined,
  }
}

"use client"

import { money, toNumber } from "../price/money"
import type { Order, Refund } from "../order-status/order"
import { RefundForm, type RefundRequest } from "@/components/blocks/refund/refund-form"

type MedusaPayment = { id: string; amount: number; refunded_amount?: number; provider_id: string; currency_code: string }

async function medusa<T>(path: string, body: unknown): Promise<T> {
  const response = await fetch(`${process.env.NEXT_PUBLIC_MEDUSA_URL}/admin${path}`, {
    method: "POST",
    credentials: "include",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(body),
  })
  const json = await response.json()
  if (!response.ok) throw new Error(json.message ?? "Medusa couldn’t refund this payment.")
  return json as T
}

export function MedusaRefund({
  order,
  payments,
  reasonIds,
}: {
  order: Order
  payments: MedusaPayment[]
  reasonIds: Record<string, string>
}) {
  const refund = async (request: RefundRequest): Promise<Refund> => {
    for (const transaction of request.transactions) {
      await medusa(`/payments/${transaction.paymentId}/refund`, {
        amount: toNumber(transaction.amount),
        refund_reason_id: request.reason ? reasonIds[request.reason] : undefined,
        note: request.note || undefined,
      })
    }
    return {
      id: `refund_${Date.now()}`,
      createdAt: new Date().toISOString(),
      status: "succeeded",
      amount: request.amount,
      shipping: request.shipping,
      lines: request.lines,
      reason: request.reason ?? undefined,
    }
  }

  return (
    <RefundForm
      order={order}
      reasons={Object.keys(reasonIds)}
      payments={payments.map((payment) => ({
        id: payment.id,
        label: payment.provider_id === "pp_system_default" ? "Manual payment" : payment.provider_id,
        amount: money(payment.amount, payment.currency_code),
        refunded: money(payment.refunded_amount ?? 0, payment.currency_code),
      }))}
      onRefund={refund}
    />
  )
}