import {
  JOB_NIMBUS_ACTIVITY_PAGE_SCHEMA,
  JOB_NIMBUS_ACTIVITY_RECORD_INPUT_SCHEMA,
  JOB_NIMBUS_ACTIVITY_SCHEMA,
  JOB_NIMBUS_ACTIVITY_TYPE_SCHEMA,
  JOB_NIMBUS_ID_SCHEMA,
  JOB_NIMBUS_RESPONSE_SCHEMA,
  jobNimbusDataSchema,
} from "@automate.ax/integration-contracts/jobnimbus"
import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import { getJobNimbusApi, JOB_NIMBUS_ACCOUNT } from "./lib"

const ACTIVITY_CREATE_FIELDS = {
  activityAction: z.string().trim().min(1),
  activityTypeId: z.number().int().nullable(),
  content: z.string(),
  isPrivate: z.boolean().prefault(false),
  primaryRecord: JOB_NIMBUS_ACTIVITY_RECORD_INPUT_SCHEMA,
  relatedRecords: JOB_NIMBUS_ACTIVITY_RECORD_INPUT_SCHEMA.array().nullable(),
}

const JSON_PATCH_OPERATION_SCHEMA = z.discriminatedUnion("op", [
  z.object({
    op: z.enum(["add", "replace"]),
    path: z.string().startsWith("/"),
    value: z.json(),
  }),
  z.object({
    op: z.literal("remove"),
    path: z.string().startsWith("/"),
  }),
])

/** Lists JobNimbus Platform activities with cursor pagination. */
export const listJobNimbusActivities = defineAction("List JobNimbus activities")
  .describe("Lists current JobNimbus activities with cursor pagination.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(
    z.object({
      activityTypeId: z.number().int().optional(),
      activityTypeIds: z.number().int().array().optional(),
      createdById: JOB_NIMBUS_ID_SCHEMA.optional(),
      cursor: z.string().optional(),
      pageSize: z.number().int().min(1).max(200).prefault(100),
      primaryRecordId: JOB_NIMBUS_ID_SCHEMA.optional(),
      primaryRecordType: z.string().trim().min(1).optional(),
      relationshipDepth: z.enum(["connected", "self"]).optional(),
      sort: z.enum(["-createdAt", "createdAt"]).prefault("-createdAt"),
    }),
  )
  .output(JOB_NIMBUS_ACTIVITY_PAGE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getJobNimbusApi(account.secret, "activities").request("activities", {
      query: {
        ...input,
      },
      responseSchema: JOB_NIMBUS_ACTIVITY_PAGE_SCHEMA,
    }),
  )

/** Retrieves one current JobNimbus activity by ID. */
export const getJobNimbusActivity = defineAction("Get JobNimbus activity")
  .describe("Retrieves one current JobNimbus activity by ID.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(z.object({ activityId: JOB_NIMBUS_ID_SCHEMA }))
  .output(JOB_NIMBUS_ACTIVITY_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getJobNimbusApi(account.secret, "activities")
      .request(`activities/${encodeURIComponent(input.activityId)}`, {
        responseSchema: jobNimbusDataSchema(JOB_NIMBUS_ACTIVITY_SCHEMA),
      })
      .then(({ data }) => data),
  )

/** Creates an activity on a JobNimbus primary record. */
export const createJobNimbusActivity = defineAction("Create JobNimbus activity")
  .describe("Creates an activity on a JobNimbus primary record.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(z.object(ACTIVITY_CREATE_FIELDS))
  .output(JOB_NIMBUS_ACTIVITY_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    getJobNimbusApi(account.secret, "activities")
      .request("activities", {
        body: input,
        method: "POST",
        responseSchema: jobNimbusDataSchema(JOB_NIMBUS_ACTIVITY_SCHEMA),
      })
      .then(({ data }) => data),
  )

/** Applies JSON Patch operations to an editable JobNimbus activity. */
export const updateJobNimbusActivity = defineAction("Update JobNimbus activity")
  .describe("Applies JSON Patch operations to an editable activity.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(
    z.object({
      activityId: JOB_NIMBUS_ID_SCHEMA,
      operations: JSON_PATCH_OPERATION_SCHEMA.array().min(1),
    }),
  )
  .output(JOB_NIMBUS_ACTIVITY_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    getJobNimbusApi(account.secret, "activities")
      .request(`activities/${encodeURIComponent(input.activityId)}`, {
        body: input.operations,
        contentType: "application/json-patch+json",
        method: "PATCH",
        responseSchema: jobNimbusDataSchema(JOB_NIMBUS_ACTIVITY_SCHEMA),
      })
      .then(({ data }) => data),
  )

/** Deletes an editable JobNimbus activity. */
export const deleteJobNimbusActivity = defineAction("Delete JobNimbus activity")
  .describe("Permanently deletes an editable JobNimbus activity.")
  .account(JOB_NIMBUS_ACCOUNT)
  .input(z.object({ activityId: JOB_NIMBUS_ID_SCHEMA }))
  .output(z.null())
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    getJobNimbusApi(account.secret, "activities")
      .request(`activities/${encodeURIComponent(input.activityId)}`, {
        method: "DELETE",
        responseSchema: JOB_NIMBUS_RESPONSE_SCHEMA,
      })
      .then(() => null),
  )

/** Lists activity types configured for the JobNimbus company. */
export const listJobNimbusActivityTypes = defineAction(
  "List JobNimbus activity types",
)
  .describe("Lists activity types configured for the JobNimbus company.")
  .account(JOB_NIMBUS_ACCOUNT)
  .output(JOB_NIMBUS_ACTIVITY_TYPE_SCHEMA.array())
  .retry({ replaySafety: "safe" })
  .handler(async ({ account }) =>
    getJobNimbusApi(account.secret, "activities")
      .request("activity-types", {
        responseSchema: jobNimbusDataSchema(
          JOB_NIMBUS_ACTIVITY_TYPE_SCHEMA.array(),
        ),
      })
      .then(({ data }) => data),
  )