import {
  JOB_NIMBUS_TASK_SCHEMA,
  jobNimbusPageSchema,
} from "@automate.ax/integration-contracts/jobnimbus"
import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import {
  JOB_NIMBUS_ACCOUNT,
  getJobNimbusApi,
  JOB_NIMBUS_DATE_INPUT_SCHEMA,
  JOB_NIMBUS_ID_SCHEMA,
  JOB_NIMBUS_LIST_FIELDS,
  JOB_NIMBUS_MUTATION_FIELDS,
  hasJobNimbusUpdate,
  jobNimbusListQuery,
  jobNimbusMutationQuery,
  toJobNimbusUnixSeconds,
} from "./lib"

const TASK_FIELDS = {
  dateEnd: JOB_NIMBUS_DATE_INPUT_SCHEMA.optional(),
  dateStart: JOB_NIMBUS_DATE_INPUT_SCHEMA.optional(),
  description: z.string().nullable().optional(),
  isCompleted: z.boolean().optional(),
  owners: z.object({ id: JOB_NIMBUS_ID_SCHEMA }).array().optional(),
  priority: z.number().int().min(0).optional(),
  recordTypeName: z.string().trim().min(1).optional(),
  related: z.object({ id: JOB_NIMBUS_ID_SCHEMA }).array().optional(),
  tags: z.string().array().optional(),
  title: z.string().trim().min(1).optional(),
}

/** Lists JobNimbus tasks with documented offset and filter controls. */
export const listJobNimbusTasks = defineAction("List JobNimbus tasks")
  .describe("Lists JobNimbus tasks with offset pagination and filters.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(z.object(JOB_NIMBUS_LIST_FIELDS))
  .output(jobNimbusPageSchema(JOB_NIMBUS_TASK_SCHEMA))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getJobNimbusApi(account.secret, "public").request("tasks", {
      query: jobNimbusListQuery(input),
      responseSchema: jobNimbusPageSchema(JOB_NIMBUS_TASK_SCHEMA),
    }),
  )

/** Retrieves one JobNimbus task by JNID. */
export const getJobNimbusTask = defineAction("Get JobNimbus task")
  .describe("Retrieves one JobNimbus task by ID.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(
    z.object({ actor: z.email().optional(), taskId: JOB_NIMBUS_ID_SCHEMA }),
  )
  .output(JOB_NIMBUS_TASK_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getJobNimbusApi(account.secret, "public").request(
      `tasks/${encodeURIComponent(input.taskId)}`,
      {
        query: { actor: input.actor },
        responseSchema: JOB_NIMBUS_TASK_SCHEMA,
      },
    ),
  )

/** Creates a JobNimbus task related to contacts or jobs. */
export const createJobNimbusTask = defineAction("Create JobNimbus task")
  .describe("Creates a JobNimbus task related to contacts or jobs.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(
    z.object({
      ...TASK_FIELDS,
      ...JOB_NIMBUS_MUTATION_FIELDS,
      dateStart: JOB_NIMBUS_DATE_INPUT_SCHEMA,
      recordTypeName: z.string().trim().min(1),
      title: z.string().trim().min(1),
    }),
  )
  .output(JOB_NIMBUS_TASK_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    const { actor, bulk, dateEnd, dateStart, skip, ...fields } = input
    return getJobNimbusApi(account.secret, "public").request("tasks", {
      body: {
        ...fields,
        ...(dateEnd !== undefined && {
          dateEnd: toJobNimbusUnixSeconds(dateEnd),
        }),
        dateStart: toJobNimbusUnixSeconds(dateStart),
      },
      method: "POST",
      query: jobNimbusMutationQuery({ actor, bulk, skip }),
      responseSchema: JOB_NIMBUS_TASK_SCHEMA,
    })
  })

/** Updates mutable fields on one JobNimbus task. */
export const updateJobNimbusTask = defineAction("Update JobNimbus task")
  .describe("Updates mutable fields on one JobNimbus task.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(
    z
      .object({
        ...TASK_FIELDS,
        ...JOB_NIMBUS_MUTATION_FIELDS,
        taskId: JOB_NIMBUS_ID_SCHEMA,
      })
      .refine(
        (input) =>
          hasJobNimbusUpdate(input, ["actor", "bulk", "skip", "taskId"]),
        "Provide a task field to update.",
      ),
  )
  .output(JOB_NIMBUS_TASK_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    const { actor, bulk, dateEnd, dateStart, skip, taskId, ...fields } = input
    return getJobNimbusApi(account.secret, "public").request(
      `tasks/${encodeURIComponent(taskId)}`,
      {
        body: {
          ...fields,
          ...(dateEnd !== undefined && {
            dateEnd: toJobNimbusUnixSeconds(dateEnd),
          }),
          ...(dateStart !== undefined && {
            dateStart: toJobNimbusUnixSeconds(dateStart),
          }),
          jnid: taskId,
        },
        method: "PUT",
        query: jobNimbusMutationQuery({ actor, bulk, skip }),
        responseSchema: JOB_NIMBUS_TASK_SCHEMA,
      },
    )
  })

/** Archives a JobNimbus task using the provider's soft-delete behavior. */
export const archiveJobNimbusTask = defineAction("Archive JobNimbus task")
  .describe("Archives a JobNimbus task by setting isActive to false.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(
    z.object({ ...JOB_NIMBUS_MUTATION_FIELDS, taskId: JOB_NIMBUS_ID_SCHEMA }),
  )
  .output(JOB_NIMBUS_TASK_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    getJobNimbusApi(account.secret, "public").request(
      `tasks/${encodeURIComponent(input.taskId)}`,
      {
        body: { isActive: false, jnid: input.taskId },
        method: "PUT",
        query: jobNimbusMutationQuery(input),
        responseSchema: JOB_NIMBUS_TASK_SCHEMA,
      },
    ),
  )