import {
  CALENDLY_AVAILABILITY_RULE_SCHEMA,
  CALENDLY_AVAILABILITY_SCHEDULE_SCHEMA,
  CALENDLY_BUSY_TIME_SCHEMA,
  CALENDLY_DATE_TIME_SCHEMA,
  CALENDLY_EVENT_TYPE_AVAILABILITY_SCHEDULE_SCHEMA,
  CALENDLY_MEETING_LOCATION_SCHEMA,
  CALENDLY_URI_SCHEMA,
  CALENDLY_UUID_SCHEMA,
} from "@automate.ax/integration-contracts/calendly"
import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import {
  CALENDLY_ACCOUNT,
  CALENDLY_PAGE_INFO_SCHEMA,
  calendlyAccountRequirement,
  collectionResponse,
  compactCalendlyInput,
  getCalendlyApi,
  resourceResponse,
  toPage,
  validateCalendlyDateRange,
} from "./lib"

const ACCOUNT = calendlyAccountRequirement("availability:read")
const WRITE_ACCOUNT = calendlyAccountRequirement("availability:write")
const LOCATIONS_ACCOUNT = calendlyAccountRequirement("locations:read")

export const listCalendlyEventTypeAvailabilitySchedules = defineAction(
  "List Calendly event type availability schedules",
)
  .describe("Lists the host availability schedule used by an event type.")
  .account(CALENDLY_ACCOUNT, ACCOUNT)
  .input(z.object({ eventType: CALENDLY_URI_SCHEMA }))
  .output(
    z.object({
      items: CALENDLY_EVENT_TYPE_AVAILABILITY_SCHEDULE_SCHEMA.array(),
      pageInfo: CALENDLY_PAGE_INFO_SCHEMA,
    }),
  )
  .retry({ replaySafety: "safe" })
  .handler(({ account, input }) =>
    getCalendlyApi(account)
      .request("event_type_availability_schedules", {
        query: input,
        responseSchema: collectionResponse(
          CALENDLY_EVENT_TYPE_AVAILABILITY_SCHEDULE_SCHEMA,
        ),
      })
      .then(toPage),
  )

export const updateCalendlyEventTypeAvailabilitySchedule = defineAction(
  "Update Calendly event type availability schedule",
)
  .describe(
    "Replaces an event type's host availability rules and source timezone.",
  )
  .account(CALENDLY_ACCOUNT, WRITE_ACCOUNT)
  .input(
    z.object({
      availabilityRule: z.object({
        rules: CALENDLY_AVAILABILITY_RULE_SCHEMA.array().optional(),
        timezone: z.string().trim().min(1),
        user: CALENDLY_URI_SCHEMA.optional(),
      }),
      availabilitySetting: z.literal("host").prefault("host"),
      eventType: CALENDLY_URI_SCHEMA,
    }),
  )
  .output(CALENDLY_EVENT_TYPE_AVAILABILITY_SCHEDULE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(({ account, input: { eventType, ...body } }) =>
    getCalendlyApi(account)
      .request("event_type_availability_schedules", {
        body: compactCalendlyInput(body),
        method: "PATCH",
        query: { eventType },
        responseSchema: resourceResponse(
          CALENDLY_EVENT_TYPE_AVAILABILITY_SCHEDULE_SCHEMA,
        ),
      })
      .then(({ resource }) => resource),
  )

export const listCalendlyUserMeetingLocations = defineAction(
  "List Calendly user meeting locations",
)
  .describe("Lists meeting location types configured for one Calendly user.")
  .account(CALENDLY_ACCOUNT, LOCATIONS_ACCOUNT)
  .input(z.object({ user: CALENDLY_URI_SCHEMA }))
  .output(z.object({ items: CALENDLY_MEETING_LOCATION_SCHEMA.array() }))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) => ({
    items: (
      await getCalendlyApi(account).request("locations", {
        query: input,
        responseSchema: z.object({
          collection: CALENDLY_MEETING_LOCATION_SCHEMA.array(),
        }),
      })
    ).collection,
  }))

export const listCalendlyUserAvailabilitySchedules = defineAction(
  "List Calendly user availability schedules",
)
  .describe("Lists availability schedules for one Calendly user.")
  .account(CALENDLY_ACCOUNT, ACCOUNT)
  .input(z.object({ user: CALENDLY_URI_SCHEMA }))
  .output(z.object({ items: CALENDLY_AVAILABILITY_SCHEDULE_SCHEMA.array() }))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) => ({
    items: (
      await getCalendlyApi(account).request("user_availability_schedules", {
        query: input,
        responseSchema: z.object({
          collection: CALENDLY_AVAILABILITY_SCHEDULE_SCHEMA.array(),
        }),
      })
    ).collection,
  }))

export const getCalendlyUserAvailabilitySchedule = defineAction(
  "Get Calendly user availability schedule",
)
  .describe(
    "Retrieves one Calendly availability schedule and its weekly rules.",
  )
  .account(CALENDLY_ACCOUNT, ACCOUNT)
  .input(z.object({ availabilityScheduleId: CALENDLY_UUID_SCHEMA }))
  .output(CALENDLY_AVAILABILITY_SCHEDULE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(({ account, input }) =>
    getCalendlyApi(account)
      .request(
        `user_availability_schedules/${encodeURIComponent(input.availabilityScheduleId)}`,
        {
          responseSchema: resourceResponse(
            CALENDLY_AVAILABILITY_SCHEDULE_SCHEMA,
          ),
        },
      )
      .then(({ resource }) => resource),
  )

export const listCalendlyUserBusyTimes = defineAction(
  "List Calendly user busy times",
)
  .describe(
    "Lists internal and external busy times across at most seven future days.",
  )
  .account(CALENDLY_ACCOUNT, ACCOUNT)
  .input(
    z
      .object({
        endTime: CALENDLY_DATE_TIME_SCHEMA,
        startTime: CALENDLY_DATE_TIME_SCHEMA,
        user: CALENDLY_URI_SCHEMA,
      })
      .superRefine((value, context) =>
        validateCalendlyDateRange(value, context, 7),
      ),
  )
  .output(z.object({ items: CALENDLY_BUSY_TIME_SCHEMA.array() }))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) => ({
    items: (
      await getCalendlyApi(account).request("user_busy_times", {
        query: input,
        responseSchema: z.object({
          collection: CALENDLY_BUSY_TIME_SCHEMA.array(),
        }),
      })
    ).collection,
  }))