import * as z from "zod"
import { defineAction } from "../../automation/actions"
import {
  requestBrowserbase,
  requestBrowserbaseBlob,
  requestBrowserbaseEmpty,
} from "./lib"
import {
  BROWSERBASE_DATE_TIME_SCHEMA,
  BROWSERBASE_DELETE_RECEIPT_SCHEMA,
  BROWSERBASE_DOWNLOAD_PAGE_SCHEMA,
  BROWSERBASE_DOWNLOAD_SCHEMA,
  BROWSERBASE_ID_SCHEMA,
} from "./schemas"

/** Lists files downloaded by a Browserbase session. */
export const listBrowserbaseDownloads = defineAction(
  "List Browserbase downloads",
)
  .describe("Lists one filtered page of files downloaded by a session.")
  .account("browserbase")
  .input(
    z
      .object({
        createdAfter: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
        createdBefore: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
        filename: z.string().min(1).max(255).optional(),
        limit: z.number().int().min(1).max(100).optional(),
        maxSize: z.number().nonnegative().optional(),
        mimeType: z.string().min(1).max(255).optional(),
        minSize: z.number().nonnegative().optional(),
        offset: z.number().int().nonnegative().optional(),
        sessionId: BROWSERBASE_ID_SCHEMA,
      })
      .refine(
        ({ maxSize, minSize }) =>
          maxSize === undefined || minSize === undefined || minSize <= maxSize,
        { message: "minSize must not exceed maxSize.", path: ["minSize"] },
      ),
  )
  .output(BROWSERBASE_DOWNLOAD_PAGE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    requestBrowserbase(account.secret, "/v1/downloads", {
      query: input,
      responseSchema: BROWSERBASE_DOWNLOAD_PAGE_SCHEMA,
    }),
  )

/** Gets metadata for one Browserbase session download. */
export const getBrowserbaseDownload = defineAction("Get Browserbase download")
  .describe(
    "Gets filename, type, size, checksum, and session metadata for one download.",
  )
  .account("browserbase")
  .input(z.object({ downloadId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_DOWNLOAD_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    requestBrowserbase(
      account.secret,
      `/v1/downloads/${encodeURIComponent(input.downloadId)}`,
      { responseSchema: BROWSERBASE_DOWNLOAD_SCHEMA },
    ),
  )

/** Downloads the bytes of one Browserbase session file. */
export const downloadBrowserbaseFile = defineAction("Download Browserbase file")
  .describe("Returns the binary content stored for one Browserbase download.")
  .account("browserbase")
  .input(z.object({ downloadId: BROWSERBASE_ID_SCHEMA }))
  .output(z.instanceof(Blob))
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    requestBrowserbaseBlob(
      account.secret,
      `/v1/downloads/${encodeURIComponent(input.downloadId)}`,
    ),
  )

/** Permanently deletes a Browserbase session download. */
export const deleteBrowserbaseDownload = defineAction(
  "Delete Browserbase download",
)
  .describe("Deletes a downloaded file from Browserbase storage.")
  .account("browserbase")
  .input(z.object({ downloadId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_DELETE_RECEIPT_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    await requestBrowserbaseEmpty(
      account.secret,
      `/v1/downloads/${encodeURIComponent(input.downloadId)}`,
      "DELETE",
    )
    return { deleted: true as const, id: input.downloadId }
  })