import {
  CLOSE_TASK_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_OR_DAY_INPUT_SCHEMA,
  CLOSE_ID_SCHEMA,
  CLOSE_PAGINATION_SCHEMA,
  hasCloseUpdate,
} from "./lib"

const TASK_FIELDS = {
  assignedTo: CLOSE_ID_SCHEMA.nullable().optional(),
  contactId: CLOSE_ID_SCHEMA.nullable().optional(),
  date: CLOSE_DATE_OR_DAY_INPUT_SCHEMA.optional(),
  dueDate: CLOSE_DATE_OR_DAY_INPUT_SCHEMA.optional(),
  isComplete: z.boolean().optional(),
  isDateless: z.boolean().optional(),
  leadId: CLOSE_ID_SCHEMA.optional(),
  priority: z.enum(["high", "medium"]).optional(),
  text: z.string().optional(),
}
const TASK_TYPE_SCHEMA = z.enum([
  "all",
  "lead",
  "missed_call",
  "voicemail",
  "incoming_email",
  "email_followup",
  "answered_detached_call",
  "opportunity_due",
  "incoming_sms",
  "outgoing_call",
])

/** Lists Close tasks and Inbox views. */
export const listCloseTasks = defineAction("List Close tasks")
  .describe("Lists and filters Close tasks, including inbox and archive views.")
  .account(CLOSE_ACCOUNT)
  .input(
    z.object({
      ...CLOSE_PAGINATION_SCHEMA,
      assignedTo: CLOSE_ID_SCHEMA.optional(),
      complete: z.boolean().optional(),
      leadId: CLOSE_ID_SCHEMA.optional(),
      type: TASK_TYPE_SCHEMA.prefault("all"),
      view: z.enum(["archive", "future", "inbox"]).optional(),
    }),
  )
  .output(closePageSchema(CLOSE_TASK_SCHEMA))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getCloseApi(account.secret).request("task/", {
      query: {
        _limit: input.limit,
        _skip: input.skip,
        _type: input.type,
        assigned_to: input.assignedTo,
        is_complete:
          input.complete === undefined ? undefined : String(input.complete),
        lead_id: input.leadId,
        view: input.view,
      },
      responseSchema: closePageSchema(CLOSE_TASK_SCHEMA),
    }),
  )

/** Retrieves one Close task. */
export const getCloseTask = defineAction("Get Close task")
  .describe("Retrieves one Close task by ID.")
  .account(CLOSE_ACCOUNT)
  .input(z.object({ taskId: CLOSE_ID_SCHEMA }))
  .output(CLOSE_TASK_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getCloseApi(account.secret).request(
      `task/${encodeURIComponent(input.taskId)}/`,
      { responseSchema: CLOSE_TASK_SCHEMA },
    ),
  )

/** Creates a lead or outbound-call Close task. */
export const createCloseTask = defineAction("Create Close task")
  .describe("Creates a lead follow-up or outbound-call task in Close.")
  .account(CLOSE_ACCOUNT)
  .input(
    z.discriminatedUnion("type", [
      z.object({
        ...TASK_FIELDS,
        leadId: CLOSE_ID_SCHEMA,
        text: z.string().trim().min(1),
        type: z.literal("lead"),
      }),
      z.object({
        ...TASK_FIELDS,
        contactId: CLOSE_ID_SCHEMA,
        leadId: CLOSE_ID_SCHEMA,
        type: z.literal("outgoing_call"),
      }),
    ]),
  )
  .output(CLOSE_TASK_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input: { type, ...fields } }) =>
    getCloseApi(account.secret).request("task/", {
      body: { _type: type, ...fields },
      method: "POST",
      responseSchema: CLOSE_TASK_SCHEMA,
    }),
  )

/** Updates a Close task or marks it complete. */
export const updateCloseTask = defineAction("Update Close task")
  .describe("Updates assignment, schedule, text, priority, or completion.")
  .account(CLOSE_ACCOUNT)
  .input(
    z
      .object({ taskId: CLOSE_ID_SCHEMA, ...TASK_FIELDS })
      .refine(
        (input) => hasCloseUpdate(input, "taskId"),
        "Provide a task field to update.",
      ),
  )
  .output(CLOSE_TASK_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input: { taskId, ...body } }) =>
    getCloseApi(account.secret).request(`task/${encodeURIComponent(taskId)}/`, {
      body,
      method: "PUT",
      responseSchema: CLOSE_TASK_SCHEMA,
    }),
  )

/** Permanently deletes a Close task. */
export const deleteCloseTask = defineAction("Delete Close task")
  .describe("Permanently deletes one Close task.")
  .account(CLOSE_ACCOUNT)
  .input(z.object({ taskId: CLOSE_ID_SCHEMA }))
  .output(z.object({ deleted: z.literal(true), taskId: z.string() }))
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    await getCloseApi(account.secret).request(
      `task/${encodeURIComponent(input.taskId)}/`,
      { method: "DELETE", responseSchema: CLOSE_VALUE_SCHEMA },
    )
    return { deleted: true as const, taskId: input.taskId }
  })