import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import {
  getGoogleFormsApi,
  normalizeForm,
  normalizeFormId,
} from "@automate.ax/integration-contracts/google-forms"
import { GOOGLE_FORMS_WRITE_REQUIREMENT } from "../lib/scopes"
import {
  FORM_BATCH_UPDATE_SCHEMA,
  FORM_REFERENCE_SCHEMA,
  RAW_FORM_UPDATE_REQUEST_SCHEMA,
} from "@automate.ax/integration-contracts/google-forms"

/**
 * Runs an atomic provider-native Forms batch update.
 *
 * Prefer the high-level item and metadata actions for common operations. This
 * action exists for provider features that do not yet have a code-first shape.
 */
export const batchUpdateGoogleForm = defineAction("Batch update Google form")
  .describe("Runs typed provider-native updates atomically.")
  .account("google", GOOGLE_FORMS_WRITE_REQUIREMENT)
  .input(
    z
      .object({
        /** Form ID or standard Google Forms URL. */
        form: FORM_REFERENCE_SCHEMA,

        /** Whether to return the complete updated form. */
        includeForm: z.boolean().optional(),

        /** Rejects the update unless this is the latest revision ID. */
        requiredRevisionId: z.string().min(1).optional(),

        /** Provider-native Google Forms update requests. */
        requests: RAW_FORM_UPDATE_REQUEST_SCHEMA.array().min(1),

        /** Recent revision to merge changes against. */
        targetRevisionId: z.string().min(1).optional(),
      })
      .refine(
        ({ requiredRevisionId, targetRevisionId }) =>
          !(requiredRevisionId && targetRevisionId),
        "Use only one write-control revision ID.",
      ),
  )
  .output(FORM_BATCH_UPDATE_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    const { data } = await getGoogleFormsApi(account.secret).forms.batchUpdate({
      formId: normalizeFormId(input.form),
      requestBody: {
        includeFormInResponse: input.includeForm,
        requests: input.requests,
        writeControl: input.requiredRevisionId
          ? { requiredRevisionId: input.requiredRevisionId }
          : input.targetRevisionId
            ? { targetRevisionId: input.targetRevisionId }
            : undefined,
      },
    })
    return {
      form: data.form ? normalizeForm(data.form) : undefined,
      replies: (data.replies ?? []).map((reply) => ({
        createdItemId: reply.createItem?.itemId ?? undefined,
        createdQuestionIds: reply.createItem?.questionId ?? [],
      })),
      revisionId:
        data.writeControl?.requiredRevisionId ??
        data.writeControl?.targetRevisionId ??
        undefined,
    }
  })