import * as z from "zod"
import { defineAction } from "../../automation/actions"
import { getResendApi, RESEND_FULL_ACCESS_ACCOUNT_OPTIONS } from "./lib"

const RESEND_ACCOUNT = "resend"
const SEGMENT_MUTATION_SCHEMA = z.object({
  id: z.string(),
  name: z.string(),
  object: z.literal("segment"),
})
const SEGMENT_WIRE_SCHEMA = SEGMENT_MUTATION_SCHEMA.extend({
  created_at: z.string(),
})
const SEGMENT_SCHEMA = SEGMENT_WIRE_SCHEMA.transform(
  ({ created_at: createdAt, ...segment }) => ({ ...segment, createdAt }),
)
const SEGMENT_SUMMARY_WIRE_SCHEMA = SEGMENT_WIRE_SCHEMA.omit({ object: true })
const SEGMENT_SUMMARY_SCHEMA = SEGMENT_SUMMARY_WIRE_SCHEMA.transform(
  ({ created_at: createdAt, ...segment }) => ({ ...segment, createdAt }),
)
const SEGMENT_LIST_WIRE_SCHEMA = z.object({
  data: SEGMENT_SUMMARY_WIRE_SCHEMA.array(),
  has_more: z.boolean(),
  object: z.literal("list"),
})
const SEGMENT_LIST_SCHEMA = z
  .object({
    data: SEGMENT_SUMMARY_SCHEMA.array(),
    has_more: z.boolean(),
    object: z.literal("list"),
  })
  .transform(({ has_more: hasMore, ...result }) => ({ ...result, hasMore }))
const SEGMENT_DELETE_SCHEMA = z.object({
  deleted: z.boolean(),
  id: z.string(),
  object: z.literal("segment"),
})
const PAGINATION_SCHEMA = z
  .object({
    after: z.string().min(1).optional(),
    before: z.string().min(1).optional(),
    limit: z.number().int().min(1).max(100).prefault(20),
  })
  .refine(({ after, before }) => !(after && before), {
    message: "after and before cannot be used together.",
  })

/** Creates a Resend segment for grouping contacts. */
export const createResendSegment = defineAction("Create Resend segment")
  .describe("Creates a reusable segment for grouping Resend contacts.")
  .account(RESEND_ACCOUNT, RESEND_FULL_ACCESS_ACCOUNT_OPTIONS)
  .input(z.object({ name: z.string().trim().min(1) }))
  .output(SEGMENT_MUTATION_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(
    async ({ account, input }) =>
      await getResendApi(account).call("segments", {
        body: input,
        httpMethod: "POST",
        responseSchema: SEGMENT_MUTATION_SCHEMA,
      }),
  )

/** Retrieves one Resend segment by ID. */
export const getResendSegment = defineAction("Get Resend segment")
  .describe("Retrieves one Resend contact segment by ID.")
  .account(RESEND_ACCOUNT, RESEND_FULL_ACCESS_ACCOUNT_OPTIONS)
  .input(z.object({ segmentId: z.string().min(1) }))
  .output(SEGMENT_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(
    async ({ account, input }) =>
      await getResendApi(account).call(
        `segments/${encodeURIComponent(input.segmentId)}`,
        { responseSchema: SEGMENT_WIRE_SCHEMA },
      ),
  )

/** Lists Resend contact segments with cursor pagination. */
export const listResendSegments = defineAction("List Resend segments")
  .describe("Lists Resend contact segments with cursor pagination.")
  .account(RESEND_ACCOUNT, RESEND_FULL_ACCESS_ACCOUNT_OPTIONS)
  .input(PAGINATION_SCHEMA)
  .output(SEGMENT_LIST_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(
    async ({ account, input }) =>
      await getResendApi(account).call("segments", {
        query: input,
        responseSchema: SEGMENT_LIST_WIRE_SCHEMA,
      }),
  )

/** Permanently deletes a Resend contact segment. */
export const deleteResendSegment = defineAction("Delete Resend segment")
  .describe("Permanently deletes a Resend contact segment.")
  .account(RESEND_ACCOUNT, RESEND_FULL_ACCESS_ACCOUNT_OPTIONS)
  .input(z.object({ segmentId: z.string().min(1) }))
  .output(SEGMENT_DELETE_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(
    async ({ account, input }) =>
      await getResendApi(account).call(
        `segments/${encodeURIComponent(input.segmentId)}`,
        { httpMethod: "DELETE", responseSchema: SEGMENT_DELETE_SCHEMA },
      ),
  )