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 StripeMutationInput,
  type StripeInputValue,
} from "../lib"

/** Stripe subscription retrieval input with a public resource ID. */
type SubscriptionIdInput<T> = StripeInputValue<T> & { subscriptionId: string }

/** Stripe subscription mutation input with a public resource ID. */
type SubscriptionMutationInput<T> = StripeMutationInput<T> & {
  subscriptionId: string
}

/** Stripe invoice retrieval input with a public resource ID. */
type InvoiceIdInput<T> = StripeInputValue<T> & { invoiceId: string }

/** Stripe invoice mutation input with a public resource ID. */
type InvoiceMutationInput<T> = StripeMutationInput<T> & { invoiceId: string }

/** Creates a Stripe subscription for recurring billing. */
export const createStripeSubscription = stripeAction<
  StripeMutationInput<Stripe.SubscriptionCreateParams>,
  Stripe.Subscription
>(
  defineAction("Create Stripe subscription")
    .describe(
      "Creates a recurring subscription with prices and billing settings.",
    )
    .account("stripe")
    .input(
      stripeMutationSchema<Stripe.SubscriptionCreateParams>(
        stripeActionSchemas.mutation({
          customer: z.string().startsWith("cus_"),
          items: z
            .array(
              z
                .object({
                  price: z.string().startsWith("price_").optional(),
                  quantity: z.int().positive().optional(),
                })
                .loose(),
            )
            .max(20)
            .optional(),
          paymentBehavior: z
            .enum([
              "allow_incomplete",
              "default_incomplete",
              "error_if_incomplete",
              "pending_if_incomplete",
            ])
            .optional(),
        }),
      ),
    )
    .output(stripeObjectSchema<Stripe.Subscription>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const [params, options] =
        stripeMutationArguments<Stripe.SubscriptionCreateParams>(input)
      return fromStripe(
        await getStripeApi(account).subscriptions.create(params, options),
      )
    }),
)

/** Retrieves a Stripe subscription by ID. */
export const getStripeSubscription = stripeAction<
  SubscriptionIdInput<Stripe.SubscriptionRetrieveParams>,
  Stripe.Subscription
>(
  defineAction("Get Stripe subscription")
    .describe("Retrieves one subscription with optional expansions.")
    .account("stripe")
    .input(
      stripeSchema<SubscriptionIdInput<Stripe.SubscriptionRetrieveParams>>(
        stripeActionSchemas.id("subscriptionId", "sub_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Subscription>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) => {
      const { subscriptionId, ...params } = input
      return fromStripe(
        await getStripeApi(account).subscriptions.retrieve(
          subscriptionId,
          toStripeParams(params),
        ),
      )
    }),
)

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

/** Searches subscriptions with Stripe Search Query Language. */
export const searchStripeSubscriptions = stripeAction<
  StripeInputValue<Stripe.SubscriptionSearchParams>,
  Stripe.ApiSearchResult<Stripe.Subscription>
>(
  defineAction("Search Stripe subscriptions")
    .describe("Searches subscriptions with Stripe Search Query Language.")
    .account("stripe")
    .input(
      stripeInputSchema<Stripe.SubscriptionSearchParams>(
        stripeActionSchemas.search,
      ),
    )
    .output(stripeObjectSchema<Stripe.ApiSearchResult<Stripe.Subscription>>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) =>
      fromStripe(
        await getStripeApi(account).subscriptions.search(toStripeParams(input)),
      ),
    ),
)

/** Updates prices, quantities, billing behavior, or cancellation settings. */
export const updateStripeSubscription = stripeAction<
  SubscriptionMutationInput<Stripe.SubscriptionUpdateParams>,
  Stripe.Subscription
>(
  defineAction("Update Stripe subscription")
    .describe(
      "Updates items, billing behavior, trials, or cancellation settings.",
    )
    .account("stripe")
    .input(
      stripeSchema<SubscriptionMutationInput<Stripe.SubscriptionUpdateParams>>(
        stripeActionSchemas.id("subscriptionId", "sub_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Subscription>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { subscriptionId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.SubscriptionUpdateParams>(mutation)
      return fromStripe(
        await getStripeApi(account).subscriptions.update(
          subscriptionId,
          params,
          options,
        ),
      )
    }),
)

/** Cancels a Stripe subscription immediately or with invoice handling options. */
export const cancelStripeSubscription = stripeAction<
  SubscriptionMutationInput<Stripe.SubscriptionCancelParams>,
  Stripe.Subscription
>(
  defineAction("Cancel Stripe subscription")
    .describe("Cancels a subscription with proration and invoice options.")
    .account("stripe")
    .input(
      stripeSchema<SubscriptionMutationInput<Stripe.SubscriptionCancelParams>>(
        stripeActionSchemas.id("subscriptionId", "sub_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Subscription>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { subscriptionId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.SubscriptionCancelParams>(mutation)
      return fromStripe(
        await getStripeApi(account).subscriptions.cancel(
          subscriptionId,
          params,
          options,
        ),
      )
    }),
)

/** Resumes a paused Stripe subscription. */
export const resumeStripeSubscription = stripeAction<
  SubscriptionMutationInput<Stripe.SubscriptionResumeParams>,
  Stripe.Subscription
>(
  defineAction("Resume Stripe subscription")
    .describe(
      "Resumes a paused subscription and configures resumption billing.",
    )
    .account("stripe")
    .input(
      stripeSchema<SubscriptionMutationInput<Stripe.SubscriptionResumeParams>>(
        stripeActionSchemas.id("subscriptionId", "sub_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Subscription>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { subscriptionId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.SubscriptionResumeParams>(mutation)
      return fromStripe(
        await getStripeApi(account).subscriptions.resume(
          subscriptionId,
          params,
          options,
        ),
      )
    }),
)

/** Creates a draft Stripe invoice. */
export const createStripeInvoice = stripeAction<
  StripeMutationInput<Stripe.InvoiceCreateParams>,
  Stripe.Invoice
>(
  defineAction("Create Stripe invoice")
    .describe("Creates a draft invoice with collection and payment settings.")
    .account("stripe")
    .input(
      stripeMutationSchema<Stripe.InvoiceCreateParams>(
        stripeActionSchemas.mutation({
          collectionMethod: z
            .enum(["charge_automatically", "send_invoice"])
            .optional(),
          customer: z.string().startsWith("cus_").optional(),
          daysUntilDue: z.int().nonnegative().optional(),
        }),
      ),
    )
    .output(stripeObjectSchema<Stripe.Invoice>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceCreateParams>(input)
      return fromStripe(
        await getStripeApi(account).invoices.create(params, options),
      )
    }),
)

/** Adds an invoice item to a customer or draft invoice. */
export const createStripeInvoiceItem = stripeAction<
  StripeMutationInput<Stripe.InvoiceItemCreateParams>,
  Stripe.InvoiceItem
>(
  defineAction("Create Stripe invoice item")
    .describe("Adds an amount or price to a customer or draft invoice.")
    .account("stripe")
    .input(
      stripeMutationSchema<Stripe.InvoiceItemCreateParams>(
        stripeActionSchemas.mutation({
          amount: z.int().optional(),
          currency: z
            .string()
            .regex(/^[a-z]{3}$/)
            .optional(),
          customer: z.string().startsWith("cus_").optional(),
          invoice: z.string().startsWith("in_").optional(),
        }),
      ),
    )
    .output(stripeObjectSchema<Stripe.InvoiceItem>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceItemCreateParams>(input)
      return fromStripe(
        await getStripeApi(account).invoiceItems.create(params, options),
      )
    }),
)

/** Retrieves a Stripe invoice by ID. */
export const getStripeInvoice = stripeAction<
  InvoiceIdInput<Stripe.InvoiceRetrieveParams>,
  Stripe.Invoice
>(
  defineAction("Get Stripe invoice")
    .describe(
      "Retrieves one draft, open, paid, void, or uncollectible invoice.",
    )
    .account("stripe")
    .input(
      stripeSchema<InvoiceIdInput<Stripe.InvoiceRetrieveParams>>(
        stripeActionSchemas.id("invoiceId", "in_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Invoice>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) => {
      const { invoiceId, ...params } = input
      return fromStripe(
        await getStripeApi(account).invoices.retrieve(
          invoiceId,
          toStripeParams(params),
        ),
      )
    }),
)

/** Lists invoices with customer, subscription, status, and date filters. */
export const listStripeInvoices = stripeAction<
  StripeInputValue<Stripe.InvoiceListParams>,
  Stripe.ApiList<Stripe.Invoice>
>(
  defineAction("List Stripe invoices")
    .describe("Lists invoices with Stripe cursor pagination and filters.")
    .account("stripe")
    .input(
      stripeInputSchema<Stripe.InvoiceListParams>(stripeActionSchemas.list),
    )
    .output(stripeObjectSchema<Stripe.ApiList<Stripe.Invoice>>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) =>
      fromStripe(
        await getStripeApi(account).invoices.list(toStripeParams(input)),
      ),
    ),
)

/** Searches invoices with Stripe Search Query Language. */
export const searchStripeInvoices = stripeAction<
  StripeInputValue<Stripe.InvoiceSearchParams>,
  Stripe.ApiSearchResult<Stripe.Invoice>
>(
  defineAction("Search Stripe invoices")
    .describe("Searches invoices with Stripe Search Query Language.")
    .account("stripe")
    .input(
      stripeInputSchema<Stripe.InvoiceSearchParams>(stripeActionSchemas.search),
    )
    .output(stripeObjectSchema<Stripe.ApiSearchResult<Stripe.Invoice>>())
    .retry({ replaySafety: "safe" })
    .handler(async ({ account, input }) =>
      fromStripe(
        await getStripeApi(account).invoices.search(toStripeParams(input)),
      ),
    ),
)

/** Updates mutable fields on a draft Stripe invoice. */
export const updateStripeInvoice = stripeAction<
  InvoiceMutationInput<Stripe.InvoiceUpdateParams>,
  Stripe.Invoice
>(
  defineAction("Update Stripe invoice")
    .describe("Updates collection, payment, tax, display, or metadata fields.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceMutationInput<Stripe.InvoiceUpdateParams>>(
        stripeActionSchemas.id("invoiceId", "in_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Invoice>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceUpdateParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoices.update(invoiceId, params, options),
      )
    }),
)

/** Permanently deletes a draft Stripe invoice. */
export const deleteStripeInvoice = stripeAction<
  InvoiceMutationInput<Stripe.InvoiceDeleteParams>,
  Stripe.DeletedInvoice
>(
  defineAction("Delete Stripe invoice")
    .describe("Permanently deletes an invoice while it is still a draft.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceMutationInput<Stripe.InvoiceDeleteParams>>(
        stripeActionSchemas.id("invoiceId", "in_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.DeletedInvoice>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceDeleteParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoices.del(invoiceId, params, options),
      )
    }),
)

/** Finalizes a draft Stripe invoice. */
export const finalizeStripeInvoice = stripeAction<
  InvoiceMutationInput<Stripe.InvoiceFinalizeInvoiceParams>,
  Stripe.Invoice
>(
  defineAction("Finalize Stripe invoice")
    .describe("Finalizes a draft invoice so Stripe can collect or send it.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceMutationInput<Stripe.InvoiceFinalizeInvoiceParams>>(
        stripeActionSchemas.id("invoiceId", "in_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Invoice>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceFinalizeInvoiceParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoices.finalizeInvoice(
          invoiceId,
          params,
          options,
        ),
      )
    }),
)

/** Attempts payment on an open Stripe invoice. */
export const payStripeInvoice = stripeAction<
  InvoiceMutationInput<Stripe.InvoicePayParams>,
  Stripe.Invoice
>(
  defineAction("Pay Stripe invoice")
    .describe("Attempts payment for an open invoice with payment overrides.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceMutationInput<Stripe.InvoicePayParams>>(
        stripeActionSchemas.id("invoiceId", "in_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Invoice>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoicePayParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoices.pay(invoiceId, params, options),
      )
    }),
)

/** Emails a finalized send-invoice Stripe invoice to its customer. */
export const sendStripeInvoice = stripeAction<
  InvoiceMutationInput<Stripe.InvoiceSendInvoiceParams>,
  Stripe.Invoice
>(
  defineAction("Send Stripe invoice")
    .describe("Emails a finalized invoice configured for manual collection.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceMutationInput<Stripe.InvoiceSendInvoiceParams>>(
        stripeActionSchemas.id("invoiceId", "in_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Invoice>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceSendInvoiceParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoices.sendInvoice(
          invoiceId,
          params,
          options,
        ),
      )
    }),
)

/** Voids an open Stripe invoice. */
export const voidStripeInvoice = stripeAction<
  InvoiceMutationInput<Stripe.InvoiceVoidInvoiceParams>,
  Stripe.Invoice
>(
  defineAction("Void Stripe invoice")
    .describe("Voids an open invoice while preserving its audit record.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceMutationInput<Stripe.InvoiceVoidInvoiceParams>>(
        stripeActionSchemas.id("invoiceId", "in_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Invoice>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceVoidInvoiceParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoices.voidInvoice(
          invoiceId,
          params,
          options,
        ),
      )
    }),
)

/** Marks an open Stripe invoice as uncollectible. */
export const markStripeInvoiceUncollectible = stripeAction<
  InvoiceMutationInput<Stripe.InvoiceMarkUncollectibleParams>,
  Stripe.Invoice
>(
  defineAction("Mark Stripe invoice uncollectible")
    .describe("Closes an open invoice as bad debt without voiding it.")
    .account("stripe")
    .input(
      stripeSchema<InvoiceMutationInput<Stripe.InvoiceMarkUncollectibleParams>>(
        stripeActionSchemas.id("invoiceId", "in_"),
      ),
    )
    .output(stripeObjectSchema<Stripe.Invoice>())
    .retry({ replaySafety: stripeMutationReplaySafety })
    .handler(async ({ account, input }) => {
      const { invoiceId, ...mutation } = input
      const [params, options] =
        stripeMutationArguments<Stripe.InvoiceMarkUncollectibleParams>(mutation)
      return fromStripe(
        await getStripeApi(account).invoices.markUncollectible(
          invoiceId,
          params,
          options,
        ),
      )
    }),
)