import type Stripe from "stripe"
import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import {
  stripeAction,
  fromStripe,
  getStripeApi,
  stripeActionSchemas,
  stripeInputSchema,
  stripeMutationArguments,
  stripeMutationReplaySafety,
  stripeMutationSchema,
  stripeObjectSchema,
  stripeSchema,
  toStripeParams,
  type StripeInputValue,
  type StripeMutationInput,
} from "../lib"

/** Stripe dispute retrieval input with a public resource ID. */
type DisputeIdInput<T> = StripeInputValue<T> & { disputeId: string }
type DisputeMutationInput<T> = StripeMutationInput<T> & { disputeId: string }

/** Stripe payout retrieval input with a public resource ID. */
type PayoutIdInput<T> = StripeInputValue<T> & { payoutId: string }
type PayoutMutationInput<T> = StripeMutationInput<T> & { payoutId: string }

/** Stripe payout-reversal input with connected-account context. */
type PayoutReversalInput = PayoutMutationInput<Stripe.PayoutReverseParams> & {
  connectedAccountId: string
}

/** Stripe invoice-item retrieval input with a public resource ID. */
type InvoiceItemIdInput<T> = StripeInputValue<T> & { invoiceItemId: string }
type InvoiceItemMutationInput<T> = StripeMutationInput<T> & {
  invoiceItemId: string
}

/** Retrieves a Stripe dispute by ID. */
export const getStripeDispute = stripeAction<
  DisputeIdInput<Stripe.DisputeRetrieveParams>,
  Stripe.Dispute
>(
  defineAction("Get Stripe dispute")
    .describe("Retrieves one dispute with evidence and response deadlines.")
    .account("stripe")
    .input(
      stripeSchema<DisputeIdInput<Stripe.DisputeRetrieveParams>>(
        stripeActionSchemas.id("disputeId", "du_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Dispute>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) => {
      const { disputeId, ...params } = input
      return fromStripe(
        await getStripeApi(account).disputes.retrieve(
          disputeId,
          toStripeParams(params),
        ),
      )
    }),
)

/** Lists Stripe disputes with status and creation filters. */
export const listStripeDisputes = stripeAction<
  StripeInputValue<Stripe.DisputeListParams>,
  Stripe.ApiList<Stripe.Dispute>
>(
  defineAction("List Stripe disputes")
    .describe("Lists disputes with Stripe cursor pagination and filters.")
    .account("stripe")
    .input(
      stripeInputSchema<Stripe.DisputeListParams>(stripeActionSchemas.list),
    )
    .output(stripeObjectSchema<Stripe.ApiList<Stripe.Dispute>>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) =>
      fromStripe(
        await getStripeApi(account).disputes.list(toStripeParams(input)),
      ),
    ),
)

/** Updates evidence and metadata on a Stripe dispute. */
export const updateStripeDispute = stripeAction<
  DisputeMutationInput<Stripe.DisputeUpdateParams>,
  Stripe.Dispute
>(
  defineAction("Update Stripe dispute")
    .describe("Updates dispute evidence, metadata, or submission settings.")
    .account("stripe")
    .input(
      stripeSchema<DisputeMutationInput<Stripe.DisputeUpdateParams>>(
        stripeActionSchemas.id("disputeId", "du_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Dispute>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { disputeId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.DisputeUpdateParams>(mutation)
      return fromStripe(
        await getStripeApi(account).disputes.update(disputeId, params, options),
      )
    }),
)

/** Closes a Stripe dispute and accepts it as lost. */
export const closeStripeDispute = stripeAction<
  DisputeMutationInput<Stripe.DisputeCloseParams>,
  Stripe.Dispute
>(
  defineAction("Close Stripe dispute")
    .describe("Irreversibly closes a dispute without further evidence.")
    .account("stripe")
    .input(
      stripeSchema<DisputeMutationInput<Stripe.DisputeCloseParams>>(
        stripeActionSchemas.id("disputeId", "du_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Dispute>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { disputeId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.DisputeCloseParams>(mutation)
      return fromStripe(
        await getStripeApi(account).disputes.close(disputeId, params, options),
      )
    }),
)

/** Creates a manual Stripe payout. */
export const createStripePayout = stripeAction<
  StripeMutationInput<Stripe.PayoutCreateParams>,
  Stripe.Payout
>(
  defineAction("Create Stripe payout")
    .describe("Creates a payout from the available Stripe balance.")
    .account("stripe")
    .input(
      stripeMutationSchema<Stripe.PayoutCreateParams>(
        stripeActionSchemas.mutation({
          amount: z.int().positive(),
          currency: z.string().regex(/^[a-z]{3}$/),
          method: z.enum(["instant", "standard"]).optional(),
          sourceType: z.enum(["bank_account", "card", "fpx"]).optional(),
        }),
      ),
    )
    .output(stripeObjectSchema<Stripe.Payout>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const [params, options] =
        stripeMutationArguments<Stripe.PayoutCreateParams>(input)
      return fromStripe(
        await getStripeApi(account).payouts.create(params, options),
      )
    }),
)

/** Retrieves a Stripe payout by ID. */
export const getStripePayout = stripeAction<
  PayoutIdInput<Stripe.PayoutRetrieveParams>,
  Stripe.Payout
>(
  defineAction("Get Stripe payout")
    .describe("Retrieves one manual or automatic payout.")
    .account("stripe")
    .input(
      stripeSchema<PayoutIdInput<Stripe.PayoutRetrieveParams>>(
        stripeActionSchemas.id("payoutId", "po_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Payout>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) => {
      const { payoutId, ...params } = input
      return fromStripe(
        await getStripeApi(account).payouts.retrieve(
          payoutId,
          toStripeParams(params),
        ),
      )
    }),
)

/** Lists Stripe payouts with destination, status, and creation filters. */
export const listStripePayouts = stripeAction<
  StripeInputValue<Stripe.PayoutListParams>,
  Stripe.ApiList<Stripe.Payout>
>(
  defineAction("List Stripe payouts")
    .describe("Lists payouts with Stripe cursor pagination and filters.")
    .account("stripe")
    .input(stripeInputSchema<Stripe.PayoutListParams>(stripeActionSchemas.list))
    .output(stripeObjectSchema<Stripe.ApiList<Stripe.Payout>>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) =>
      fromStripe(
        await getStripeApi(account).payouts.list(toStripeParams(input)),
      ),
    ),
)

/** Updates metadata on a Stripe payout. */
export const updateStripePayout = stripeAction<
  PayoutMutationInput<Stripe.PayoutUpdateParams>,
  Stripe.Payout
>(
  defineAction("Update Stripe payout")
    .describe("Updates mutable metadata on a payout.")
    .account("stripe")
    .input(
      stripeSchema<PayoutMutationInput<Stripe.PayoutUpdateParams>>(
        stripeActionSchemas.id("payoutId", "po_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Payout>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { payoutId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.PayoutUpdateParams>(mutation)
      return fromStripe(
        await getStripeApi(account).payouts.update(payoutId, params, options),
      )
    }),
)

/** Cancels a pending manual Stripe payout. */
export const cancelStripePayout = stripeAction<
  PayoutMutationInput<Stripe.PayoutCancelParams>,
  Stripe.Payout
>(
  defineAction("Cancel Stripe payout")
    .describe("Cancels a pending manual payout and returns its funds.")
    .account("stripe")
    .input(
      stripeSchema<PayoutMutationInput<Stripe.PayoutCancelParams>>(
        stripeActionSchemas.id("payoutId", "po_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Payout>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { payoutId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.PayoutCancelParams>(mutation)
      return fromStripe(
        await getStripeApi(account).payouts.cancel(payoutId, params, options),
      )
    }),
)

/** Reverses a supported Stripe payout. */
export const reverseStripePayout = stripeAction<
  PayoutReversalInput,
  Stripe.Payout
>(
  defineAction("Reverse Stripe payout")
    .describe("Debits the destination account to reverse a supported payout.")
    .account("stripe")
    .input(
      stripeSchema<PayoutReversalInput>(
        stripeActionSchemas.object({
          connectedAccountId: z.string().startsWith("acct_"),
          payoutId: z.string().startsWith("po_"),
        }),
      ),
    )
    .output(stripeObjectSchema<Stripe.Payout>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { connectedAccountId, payoutId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.PayoutReverseParams>(mutation)
      return fromStripe(
        await getStripeApi(account).payouts.reverse(payoutId, params, {
          ...options,
          stripeContext: connectedAccountId,
        }),
      )
    }),
)

/** Retrieves a Stripe invoice item by ID. */
export const getStripeInvoiceItem = stripeAction<
  InvoiceItemIdInput<Stripe.InvoiceItemRetrieveParams>,
  Stripe.InvoiceItem
>(
  defineAction("Get Stripe invoice item")
    .describe("Retrieves one pending or draft invoice item.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceItemIdInput<Stripe.InvoiceItemRetrieveParams>>(
        stripeActionSchemas.id("invoiceItemId", "ii_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.InvoiceItem>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) => {
      const { invoiceItemId, ...params } = input
      return fromStripe(
        await getStripeApi(account).invoiceItems.retrieve(
          invoiceItemId,
          toStripeParams(params),
        ),
      )
    }),
)

/** Lists Stripe invoice items with customer and invoice filters. */
export const listStripeInvoiceItems = stripeAction<
  StripeInputValue<Stripe.InvoiceItemListParams>,
  Stripe.ApiList<Stripe.InvoiceItem>
>(
  defineAction("List Stripe invoice items")
    .describe("Lists invoice items with Stripe cursor pagination and filters.")
    .account("stripe")
    .input(
      stripeInputSchema<Stripe.InvoiceItemListParams>(stripeActionSchemas.list),
    )
    .output(stripeObjectSchema<Stripe.ApiList<Stripe.InvoiceItem>>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) =>
      fromStripe(
        await getStripeApi(account).invoiceItems.list(toStripeParams(input)),
      ),
    ),
)

/** Updates a pending or draft Stripe invoice item. */
export const updateStripeInvoiceItem = stripeAction<
  InvoiceItemMutationInput<Stripe.InvoiceItemUpdateParams>,
  Stripe.InvoiceItem
>(
  defineAction("Update Stripe invoice item")
    .describe("Updates the amount, pricing, description, or metadata.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceItemMutationInput<Stripe.InvoiceItemUpdateParams>>(
        stripeActionSchemas.id("invoiceItemId", "ii_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.InvoiceItem>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceItemId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceItemUpdateParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoiceItems.update(
          invoiceItemId,
          params,
          options,
        ),
      )
    }),
)

/** Deletes a pending or draft Stripe invoice item. */
export const deleteStripeInvoiceItem = stripeAction<
  InvoiceItemMutationInput<Stripe.InvoiceItemDeleteParams>,
  Stripe.DeletedInvoiceItem
>(
  defineAction("Delete Stripe invoice item")
    .describe("Deletes an invoice item before its invoice closes.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceItemMutationInput<Stripe.InvoiceItemDeleteParams>>(
        stripeActionSchemas.id("invoiceItemId", "ii_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.DeletedInvoiceItem>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceItemId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceItemDeleteParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoiceItems.del(
          invoiceItemId,
          params,
          options,
        ),
      )
    }),
)