import {
  CLICKUP_USER_SCHEMA,
  CLICKUP_WORKSPACE_SCHEMA,
} from "@automate.ax/integration-contracts/clickup"
import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import {
  CLICKUP_ACCOUNT,
  CLICKUP_ACCOUNT_REQUIREMENT,
  CLICKUP_ID_SCHEMA,
  getClickUpApi,
} from "./lib"

const USER_RESPONSE_SCHEMA = z.object({ user: CLICKUP_USER_SCHEMA })
const WORKSPACE_RESPONSE_SCHEMA = z.object({
  teams: CLICKUP_WORKSPACE_SCHEMA.array(),
})
const MEMBERS_RESPONSE_SCHEMA = z.object({
  members: CLICKUP_USER_SCHEMA.array(),
})

/** Gets the user represented by the connected ClickUp account. */
export const getCurrentClickUpUser = defineAction("Get current ClickUp user")
  .describe("Gets the user represented by the connected ClickUp account.")
  .account(CLICKUP_ACCOUNT, CLICKUP_ACCOUNT_REQUIREMENT)
  .output(CLICKUP_USER_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(
    async ({ account }) =>
      (
        await getClickUpApi(account).request("user", {
          responseSchema: USER_RESPONSE_SCHEMA,
        })
      ).user,
  )

/** Lists Workspaces authorized for the connected account. */
export const listClickUpWorkspaces = defineAction("List ClickUp Workspaces")
  .describe("Lists Workspaces authorized for the connected ClickUp account.")
  .account(CLICKUP_ACCOUNT, CLICKUP_ACCOUNT_REQUIREMENT)
  .output(z.object({ workspaces: CLICKUP_WORKSPACE_SCHEMA.array() }))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account }) => ({
    workspaces: (
      await getClickUpApi(account).request("team", {
        responseSchema: WORKSPACE_RESPONSE_SCHEMA,
      })
    ).teams,
  }))

/** Gets one authorized ClickUp Workspace. */
export const getClickUpWorkspace = defineAction("Get ClickUp Workspace")
  .describe("Gets one Workspace authorized for the connected account.")
  .account(CLICKUP_ACCOUNT, CLICKUP_ACCOUNT_REQUIREMENT)
  .input(z.object({ workspaceId: CLICKUP_ID_SCHEMA }))
  .output(CLICKUP_WORKSPACE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) => {
    const { teams } = await getClickUpApi(account).request("team", {
      responseSchema: WORKSPACE_RESPONSE_SCHEMA,
    })
    const workspace = teams.find(({ id }) => id === input.workspaceId)
    if (!workspace) {
      throw new Error(
        `ClickUp Workspace ${input.workspaceId} is not authorized.`,
      )
    }
    return workspace
  })

/** Lists users included in an authorized Workspace. */
export const listClickUpWorkspaceUsers = defineAction(
  "List ClickUp Workspace users",
)
  .describe("Lists users included in one authorized ClickUp Workspace.")
  .account(CLICKUP_ACCOUNT, CLICKUP_ACCOUNT_REQUIREMENT)
  .input(z.object({ workspaceId: CLICKUP_ID_SCHEMA }))
  .output(z.object({ users: CLICKUP_USER_SCHEMA.array() }))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) => {
    const { teams } = await getClickUpApi(account).request("team", {
      responseSchema: WORKSPACE_RESPONSE_SCHEMA,
    })
    const workspace = teams.find(({ id }) => id === input.workspaceId)
    if (!workspace) {
      throw new Error(
        `ClickUp Workspace ${input.workspaceId} is not authorized.`,
      )
    }
    return { users: workspace.members.map(({ user }) => user) }
  })

/** Lists members with access to a ClickUp List. */
export const listClickUpListMembers = defineAction("List ClickUp List members")
  .describe("Lists users with access to a ClickUp List.")
  .account(CLICKUP_ACCOUNT, CLICKUP_ACCOUNT_REQUIREMENT)
  .input(z.object({ listId: CLICKUP_ID_SCHEMA }))
  .output(MEMBERS_RESPONSE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getClickUpApi(account).request(`list/${input.listId}/member`, {
      responseSchema: MEMBERS_RESPONSE_SCHEMA,
    }),
  )

/** Lists members with access to a ClickUp task. */
export const listClickUpTaskMembers = defineAction("List ClickUp task members")
  .describe("Lists users with access to a ClickUp task.")
  .account(CLICKUP_ACCOUNT, CLICKUP_ACCOUNT_REQUIREMENT)
  .input(z.object({ taskId: CLICKUP_ID_SCHEMA }))
  .output(MEMBERS_RESPONSE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    getClickUpApi(account).request(`task/${input.taskId}/member`, {
      responseSchema: MEMBERS_RESPONSE_SCHEMA,
    }),
  )