import {
  CLOSE_SEQUENCE_SCHEMA,
  CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA,
  CLOSE_VALUE_SCHEMA,
  closePageSchema,
} from "@automate.ax/integration-contracts/close"
import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import {
  CLOSE_ACCOUNT,
  getCloseApi,
  CLOSE_DATE_INPUT_SCHEMA,
  CLOSE_ID_SCHEMA,
  CLOSE_PAGINATION_SCHEMA,
} from "./lib"

/** Lists Close sequences. */
export const listCloseSequences = defineAction("List Close sequences")
  .describe("Lists Close sales sequences and workflows.")
  .account(CLOSE_ACCOUNT)
  .input(z.object(CLOSE_PAGINATION_SCHEMA))
  .output(closePageSchema(CLOSE_SEQUENCE_SCHEMA))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getCloseApi(account.secret).request("sequence/", {
      query: { _limit: input.limit, _skip: input.skip },
      responseSchema: closePageSchema(CLOSE_SEQUENCE_SCHEMA),
    }),
  )

/** Retrieves one Close sequence. */
export const getCloseSequence = defineAction("Get Close sequence")
  .describe("Retrieves one Close sequence and its steps.")
  .account(CLOSE_ACCOUNT)
  .input(z.object({ sequenceId: CLOSE_ID_SCHEMA }))
  .output(CLOSE_SEQUENCE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getCloseApi(account.secret).request(
      `sequence/${encodeURIComponent(input.sequenceId)}/`,
      { responseSchema: CLOSE_SEQUENCE_SCHEMA },
    ),
  )

/** Lists Close sequence subscriptions. */
export const listCloseSequenceSubscriptions = defineAction(
  "List Close sequence subscriptions",
)
  .describe(
    "Lists sequence enrollments with optional contact and sequence filters.",
  )
  .account(CLOSE_ACCOUNT)
  .input(
    z
      .object({
        ...CLOSE_PAGINATION_SCHEMA,
        contactId: CLOSE_ID_SCHEMA.optional(),
        leadId: CLOSE_ID_SCHEMA.optional(),
        sequenceId: CLOSE_ID_SCHEMA.optional(),
      })
      .refine(
        ({ contactId, leadId, sequenceId }) =>
          Boolean(contactId || leadId || sequenceId),
        "Provide contactId, leadId, or sequenceId.",
      ),
  )
  .output(closePageSchema(CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getCloseApi(account.secret).request("sequence_subscription/", {
      query: {
        _limit: input.limit,
        _skip: input.skip,
        contact_id: input.contactId,
        lead_id: input.leadId,
        sequence_id: input.sequenceId,
      },
      responseSchema: closePageSchema(CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA),
    }),
  )

/** Retrieves one Close sequence subscription. */
export const getCloseSequenceSubscription = defineAction(
  "Get Close sequence subscription",
)
  .describe("Retrieves one Close sequence enrollment by ID.")
  .account(CLOSE_ACCOUNT)
  .input(z.object({ subscriptionId: CLOSE_ID_SCHEMA }))
  .output(CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getCloseApi(account.secret).request(
      `sequence_subscription/${encodeURIComponent(input.subscriptionId)}/`,
      { responseSchema: CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA },
    ),
  )

/** Subscribes a Close contact to a sequence. */
export const subscribeCloseContactToSequence = defineAction(
  "Subscribe Close contact to sequence",
)
  .describe("Enrolls one Close contact and email address in a sales sequence.")
  .account(CLOSE_ACCOUNT)
  .input(
    z.object({
      callsAssignedTo: CLOSE_ID_SCHEMA.array().optional(),
      contactEmail: z.email(),
      contactId: CLOSE_ID_SCHEMA,
      senderAccountId: CLOSE_ID_SCHEMA.optional(),
      senderEmail: z.email().optional(),
      senderName: z.string().optional(),
      sequenceId: CLOSE_ID_SCHEMA,
      startDate: CLOSE_DATE_INPUT_SCHEMA.nullable().optional(),
    }),
  )
  .output(CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    getCloseApi(account.secret).request("sequence_subscription/", {
      body: input,
      method: "POST",
      responseSchema: CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA,
    }),
  )

/** Pauses or resumes a Close sequence subscription. */
export const updateCloseSequenceSubscription = defineAction(
  "Update Close sequence subscription",
)
  .describe("Pauses or resumes one Close sequence subscription.")
  .account(CLOSE_ACCOUNT)
  .input(
    z.object({
      status: z.enum(["active", "paused"]),
      subscriptionId: CLOSE_ID_SCHEMA,
    }),
  )
  .output(CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    getCloseApi(account.secret).request(
      `sequence_subscription/${encodeURIComponent(input.subscriptionId)}/`,
      {
        body: { status: input.status },
        method: "PUT",
        responseSchema: CLOSE_SEQUENCE_SUBSCRIPTION_SCHEMA,
      },
    ),
  )

/** Removes a contact from a Close sequence. */
export const deleteCloseSequenceSubscription = defineAction(
  "Delete Close sequence subscription",
)
  .describe("Removes one contact enrollment from a Close sequence.")
  .account(CLOSE_ACCOUNT)
  .input(z.object({ subscriptionId: CLOSE_ID_SCHEMA }))
  .output(z.object({ deleted: z.literal(true), subscriptionId: z.string() }))
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    await getCloseApi(account.secret).request(
      `sequence_subscription/${encodeURIComponent(input.subscriptionId)}/`,
      { method: "DELETE", responseSchema: CLOSE_VALUE_SCHEMA },
    )
    return { deleted: true as const, subscriptionId: input.subscriptionId }
  })