import type { Encodable } from "@automate.ax/codec"
import type { Vercel } from "@vercel/sdk"
import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import type { IntegrationScopeRequirement } from "../../../automation/integrations"
import {
  getVercelApi,
  getVercelTeamId,
  vercelAccessTokenAccountOptions,
  vercelAccountOptions,
} from "./api"

/** Runtime-validates a provider SDK request while preserving its exact type. */
function vercelRequestSchema<TRequest extends Record<string, unknown>>() {
  return z.custom<TRequest>(
    (value) =>
      typeof value === "object" && value !== null && !Array.isArray(value),
    "Expected a Vercel request object.",
  )
}

/** Runtime-validates an encodable provider SDK response. */
function vercelResultSchema<TResult extends Encodable>() {
  return z.custom<TResult>()
}

/**
 * Adds an OAuth-installed team when the caller did not choose one.
 *
 * @param account - Resolved Vercel integration account.
 * @param request - Provider SDK request to scope.
 */
function withInstalledVercelTeam<TRequest extends Record<string, unknown>>(
  account: Parameters<typeof getVercelTeamId>[0],
  request: TRequest,
) {
  const scope = request as { slug?: string; teamId?: string }
  if (scope.teamId || scope.slug) return request
  const teamId = getVercelTeamId(account)
  return teamId ? { ...request, teamId } : request
}

/**
 * Defines one typed SDK-backed Vercel action with OAuth and token support.
 *
 * @param options - Action metadata and official SDK handler.
 * @param options.description - Public action description.
 * @param options.handler - Official SDK operation to call.
 * @param options.name - Public action name.
 * @param options.replaySafety - Whether retries may replay the request.
 * @param options.scope - OAuth scope requirement for this operation.
 */
export function defineScopedVercelSdkAction<
  TRequest extends Record<string, unknown>,
  TResult extends Encodable,
>(options: {
  description: string
  handler: (api: Vercel, request: TRequest) => Promise<TResult>
  name: string
  replaySafety: "safe" | "unsafe"
  scope: IntegrationScopeRequirement
}) {
  return defineAction(options.name)
    .describe(options.description)
    .account("vercel", vercelAccountOptions(options.scope))
    .input(vercelRequestSchema<TRequest>())
    .output(vercelResultSchema<TResult>())
    .retry({ replaySafety: options.replaySafety })
    .handler(({ account, input }) =>
      options.handler(
        getVercelApi(account),
        withInstalledVercelTeam(account, input),
      ),
    )
}

/**
 * Defines one typed SDK-backed Vercel action for personal access tokens.
 *
 * @param options - Action metadata and official SDK handler.
 * @param options.description - Public action description.
 * @param options.handler - Official SDK operation to call.
 * @param options.name - Public action name.
 * @param options.replaySafety - Whether retries may replay the request.
 */
export function defineTokenVercelSdkAction<
  TRequest extends Record<string, unknown>,
  TResult extends Encodable,
>(options: {
  description: string
  handler: (api: Vercel, request: TRequest) => Promise<TResult>
  name: string
  replaySafety: "safe" | "unsafe"
}) {
  return defineAction(options.name)
    .describe(options.description)
    .account("vercel", vercelAccessTokenAccountOptions())
    .input(vercelRequestSchema<TRequest>())
    .output(vercelResultSchema<TResult>())
    .retry({ replaySafety: options.replaySafety })
    .handler(({ account, input }) =>
      options.handler(getVercelApi(account), input),
    )
}