import { defineAction } from "../../../automation/actions"
import type { Webflow } from "webflow-api"
import * as serializers from "webflow-api/serialization"
import * as z from "zod"
import {
  getWebflowApi,
  webflowAction,
  webflowActionSchemas,
  webflowInputSchema,
  webflowObjectSchema,
  webflowRequest,
  webflowVoidSchema,
  type WebflowInputValue,
} from "../lib"

type SiteInput<T = object> = WebflowInputValue<T> & { siteId: string }
type AssetInput<T = object> = WebflowInputValue<T> & { assetId: string }
type AssetFolderInput<T = object> = WebflowInputValue<T> & {
  assetFolderId: string
}
type FormInput<T = object> = WebflowInputValue<T> & { formId: string }
type SubmissionInput<T = object> = WebflowInputValue<T> & {
  formSubmissionId: string
}
type SiteFormInput<T = object> = FormInput<T> & { siteId: string }
type SiteSubmissionInput<T = object> = SubmissionInput<T> & { siteId: string }

/** Lists assets and optional variants from one Webflow site. */
export const listWebflowAssets = webflowAction<
  SiteInput<Webflow.AssetsListRequest>,
  Webflow.Assets
>(
  defineAction("List Webflow assets")
    .describe("Lists assets and variants from one site with pagination.")
    .account("webflow", "assets:read")
    .input(
      webflowInputSchema<SiteInput<Webflow.AssetsListRequest>>(
        webflowActionSchemas.paginated("siteId"),
      ),
    )
    .output(webflowObjectSchema<Webflow.Assets>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).assets.list(
          input.siteId,
          webflowRequest(input, "siteId"),
        ),
    ),
)

/** Creates upload credentials for a new Webflow asset. */
export const createWebflowAsset = webflowAction<
  SiteInput<Webflow.AssetsCreateRequest>,
  Webflow.AssetUpload
>(
  defineAction("Create Webflow asset")
    .describe("Creates a hosted upload target for a new asset file.")
    .account("webflow", "assets:write")
    .input(
      webflowInputSchema<SiteInput<Webflow.AssetsCreateRequest>>(
        webflowActionSchemas.id("siteId"),
        serializers.AssetsCreateRequest,
      ),
    )
    .output(webflowObjectSchema<Webflow.AssetUpload>())
    .retry({ replaySafety: "unsafe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).assets.create(
          input.siteId,
          webflowRequest(input, "siteId"),
        ),
    ),
)

/** Retrieves one Webflow asset by ID. */
export const getWebflowAsset = webflowAction<AssetInput, Webflow.Asset>(
  defineAction("Get Webflow asset")
    .describe("Retrieves metadata and variants for one asset.")
    .account("webflow", "assets:read")
    .input(webflowInputSchema<AssetInput>(webflowActionSchemas.id("assetId")))
    .output(webflowObjectSchema<Webflow.Asset>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).assets.get(input.assetId),
    ),
)

/** Updates the display name or folder placement of a Webflow asset. */
export const updateWebflowAsset = webflowAction<
  AssetInput<Webflow.AssetsUpdateRequest>,
  Webflow.Asset
>(
  defineAction("Update Webflow asset")
    .describe("Updates asset metadata or moves it between folders.")
    .account("webflow", "assets:write")
    .input(
      webflowInputSchema<AssetInput<Webflow.AssetsUpdateRequest>>(
        webflowActionSchemas.id("assetId"),
        serializers.AssetsUpdateRequest,
      ),
    )
    .output(webflowObjectSchema<Webflow.Asset>())
    .retry({ replaySafety: "unsafe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).assets.update(
          input.assetId,
          webflowRequest(input, "assetId"),
        ),
    ),
)

/** Permanently deletes a Webflow asset. */
export const deleteWebflowAsset = webflowAction<AssetInput, void>(
  defineAction("Delete Webflow asset")
    .describe("Permanently deletes an asset from its Webflow site.")
    .account("webflow", "assets:write")
    .input(webflowInputSchema<AssetInput>(webflowActionSchemas.id("assetId")))
    .output(webflowVoidSchema())
    .retry({ replaySafety: "unsafe" })
    .handler(async ({ account, input }) => {
      await getWebflowApi(account).assets.delete(input.assetId)
    }),
)

/** Lists asset folders in one Webflow site. */
export const listWebflowAssetFolders = webflowAction<
  SiteInput,
  Webflow.AssetFolderList
>(
  defineAction("List Webflow asset folders")
    .describe("Lists the asset folder hierarchy for one site.")
    .account("webflow", "assets:read")
    .input(webflowInputSchema<SiteInput>(webflowActionSchemas.id("siteId")))
    .output(webflowObjectSchema<Webflow.AssetFolderList>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).assets.listFolders(input.siteId),
    ),
)

/** Creates a folder in a Webflow site's asset library. */
export const createWebflowAssetFolder = webflowAction<
  SiteInput<Webflow.AssetsCreateFolderRequest>,
  Webflow.AssetFolder
>(
  defineAction("Create Webflow asset folder")
    .describe("Creates an asset folder, optionally beneath a parent folder.")
    .account("webflow", "assets:write")
    .input(
      webflowInputSchema<SiteInput<Webflow.AssetsCreateFolderRequest>>(
        webflowActionSchemas.id("siteId"),
        serializers.AssetsCreateFolderRequest,
      ),
    )
    .output(webflowObjectSchema<Webflow.AssetFolder>())
    .retry({ replaySafety: "unsafe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).assets.createFolder(
          input.siteId,
          webflowRequest(input, "siteId"),
        ),
    ),
)

/** Retrieves one Webflow asset folder. */
export const getWebflowAssetFolder = webflowAction<
  AssetFolderInput,
  Webflow.AssetFolder
>(
  defineAction("Get Webflow asset folder")
    .describe("Retrieves one asset folder and its parent relationship.")
    .account("webflow", "assets:read")
    .input(
      webflowInputSchema<AssetFolderInput>(
        webflowActionSchemas.id("assetFolderId"),
      ),
    )
    .output(webflowObjectSchema<Webflow.AssetFolder>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).assets.getFolder(input.assetFolderId),
    ),
)

/** Lists forms defined in one Webflow site. */
export const listWebflowForms = webflowAction<
  SiteInput<Webflow.FormsListRequest>,
  Webflow.FormList
>(
  defineAction("List Webflow forms")
    .describe("Lists forms and their field schemas for one site.")
    .account("webflow", "forms:read")
    .input(
      webflowInputSchema<SiteInput<Webflow.FormsListRequest>>(
        webflowActionSchemas.paginated("siteId"),
      ),
    )
    .output(webflowObjectSchema<Webflow.FormList>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).forms.list(
          input.siteId,
          webflowRequest(input, "siteId"),
        ),
    ),
)

/** Retrieves the field schema for one Webflow form. */
export const getWebflowForm = webflowAction<FormInput, Webflow.Form>(
  defineAction("Get Webflow form")
    .describe("Retrieves one form and its current field schema.")
    .account("webflow", "forms:read")
    .input(webflowInputSchema<FormInput>(webflowActionSchemas.id("formId")))
    .output(webflowObjectSchema<Webflow.Form>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).forms.get(input.formId),
    ),
)

/** Lists submissions for one Webflow form. */
export const listWebflowFormSubmissions = webflowAction<
  FormInput<Webflow.FormsListSubmissionsRequest>,
  Webflow.FormSubmissionList
>(
  defineAction("List Webflow form submissions")
    .describe("Lists submissions for one form with pagination and filters.")
    .account("webflow", "forms:read")
    .input(
      webflowInputSchema<FormInput<Webflow.FormsListSubmissionsRequest>>(
        webflowActionSchemas.paginated("formId"),
      ),
    )
    .output(webflowObjectSchema<Webflow.FormSubmissionList>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).forms.listSubmissions(
          input.formId,
          webflowRequest(input, "formId"),
        ),
    ),
)

/** Lists submissions across every form in one Webflow site. */
export const listWebflowSiteFormSubmissions = webflowAction<
  SiteInput<Webflow.sites.FormsListSubmissionsBySiteRequest>,
  Webflow.FormSubmissionList
>(
  defineAction("List Webflow site form submissions")
    .describe("Lists submissions across every form in one Webflow site.")
    .account("webflow", "forms:read")
    .input(
      webflowInputSchema<
        SiteInput<Webflow.sites.FormsListSubmissionsBySiteRequest>
      >(
        webflowActionSchemas.parameters(["siteId"], {
          elementId: z.string().trim().min(1).optional(),
          limit: z.number().int().min(1).max(100).optional(),
          offset: z.number().int().nonnegative().optional(),
        }),
      ),
    )
    .output(webflowObjectSchema<Webflow.FormSubmissionList>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).sites.forms.listSubmissionsBySite(
          input.siteId,
          webflowRequest(input, "siteId"),
        ),
    ),
)

/** Lists submissions for one form through its Webflow site route. */
export const listWebflowSiteFormSubmissionsForForm = webflowAction<
  SiteFormInput<Webflow.sites.FormsListSubmissionsRequest>,
  Webflow.FormSubmissionList
>(
  defineAction("List Webflow site form submissions for form")
    .describe("Lists one form's submissions through its site-scoped route.")
    .account("webflow", "forms:read")
    .input(
      webflowInputSchema<
        SiteFormInput<Webflow.sites.FormsListSubmissionsRequest>
      >(webflowActionSchemas.paginated("siteId", "formId")),
    )
    .output(webflowObjectSchema<Webflow.FormSubmissionList>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).sites.forms.listSubmissions(
          input.siteId,
          input.formId,
          webflowRequest(input, "siteId", "formId"),
        ),
    ),
)

/** Retrieves one Webflow form submission. */
export const getWebflowFormSubmission = webflowAction<
  SubmissionInput,
  Webflow.FormSubmission
>(
  defineAction("Get Webflow form submission")
    .describe("Retrieves one form submission and its submitted values.")
    .account("webflow", "forms:read")
    .input(
      webflowInputSchema<SubmissionInput>(
        webflowActionSchemas.id("formSubmissionId"),
      ),
    )
    .output(webflowObjectSchema<Webflow.FormSubmission>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).forms.getSubmission(
          input.formSubmissionId,
        ),
    ),
)

/** Retrieves one form submission through its Webflow site route. */
export const getWebflowSiteFormSubmission = webflowAction<
  SiteSubmissionInput,
  Webflow.FormSubmission
>(
  defineAction("Get Webflow site form submission")
    .describe("Retrieves one form submission through its site-scoped route.")
    .account("webflow", "forms:read")
    .input(
      webflowInputSchema<SiteSubmissionInput>(
        webflowActionSchemas.ids("siteId", "formSubmissionId"),
      ),
    )
    .output(webflowObjectSchema<Webflow.FormSubmission>())
    .retry({ replaySafety: "safe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).sites.forms.getSubmission(
          input.siteId,
          input.formSubmissionId,
        ),
    ),
)

/** Updates editable metadata on one Webflow form submission. */
export const updateWebflowFormSubmission = webflowAction<
  SubmissionInput<Webflow.FormsUpdateSubmissionRequest>,
  Webflow.FormSubmission
>(
  defineAction("Update Webflow form submission")
    .describe("Updates editable form-submission metadata such as spam state.")
    .account("webflow", "forms:write")
    .input(
      webflowInputSchema<SubmissionInput<Webflow.FormsUpdateSubmissionRequest>>(
        webflowActionSchemas.id("formSubmissionId"),
        serializers.FormsUpdateSubmissionRequest,
      ),
    )
    .output(webflowObjectSchema<Webflow.FormSubmission>())
    .retry({ replaySafety: "unsafe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).forms.updateSubmission(
          input.formSubmissionId,
          webflowRequest(input, "formSubmissionId"),
        ),
    ),
)

/** Updates one form submission through its Webflow site route. */
export const updateWebflowSiteFormSubmission = webflowAction<
  SiteSubmissionInput<Webflow.sites.FormsUpdateSubmissionRequest>,
  Webflow.FormSubmission
>(
  defineAction("Update Webflow site form submission")
    .describe("Updates form-submission metadata through its site-scoped route.")
    .account("webflow", "forms:write")
    .input(
      webflowInputSchema<
        SiteSubmissionInput<Webflow.sites.FormsUpdateSubmissionRequest>
      >(
        webflowActionSchemas.ids("siteId", "formSubmissionId"),
        serializers.sites.FormsUpdateSubmissionRequest,
      ),
    )
    .output(webflowObjectSchema<Webflow.FormSubmission>())
    .retry({ replaySafety: "unsafe" })
    .handler(
      async ({ account, input }) =>
        await getWebflowApi(account).sites.forms.updateSubmission(
          input.siteId,
          input.formSubmissionId,
          webflowRequest(input, "siteId", "formSubmissionId"),
        ),
    ),
)

/** Permanently deletes one Webflow form submission. */
export const deleteWebflowFormSubmission = webflowAction<SubmissionInput, void>(
  defineAction("Delete Webflow form submission")
    .describe("Permanently deletes one form submission.")
    .account("webflow", "forms:write")
    .input(
      webflowInputSchema<SubmissionInput>(
        webflowActionSchemas.id("formSubmissionId"),
      ),
    )
    .output(webflowVoidSchema())
    .retry({ replaySafety: "unsafe" })
    .handler(async ({ account, input }) => {
      await getWebflowApi(account).forms.deleteSubmission(
        input.formSubmissionId,
      )
    }),
)

/** Permanently deletes one form submission through its Webflow site route. */
export const deleteWebflowSiteFormSubmission = webflowAction<
  SiteSubmissionInput,
  void
>(
  defineAction("Delete Webflow site form submission")
    .describe("Permanently deletes one submission through its site route.")
    .account("webflow", "forms:write")
    .input(
      webflowInputSchema<SiteSubmissionInput>(
        webflowActionSchemas.ids("siteId", "formSubmissionId"),
      ),
    )
    .output(webflowVoidSchema())
    .retry({ replaySafety: "unsafe" })
    .handler(async ({ account, input }) => {
      await getWebflowApi(account).sites.forms.deleteSubmission(
        input.siteId,
        input.formSubmissionId,
      )
    }),
)