import { toFile } from "@browserbasehq/sdk"
import * as z from "zod"
import { defineAction } from "../../automation/actions"
import { getBrowserbaseClient } from "./lib"
import {
  BROWSERBASE_CERTIFICATE_SCHEMA,
  BROWSERBASE_CONTEXT_CREATE_RESPONSE_SCHEMA,
  BROWSERBASE_CONTEXT_SCHEMA,
  BROWSERBASE_DELETE_RECEIPT_SCHEMA,
  BROWSERBASE_EXTENSION_SCHEMA,
  BROWSERBASE_ID_SCHEMA,
  BROWSERBASE_PROJECT_SCHEMA,
  BROWSERBASE_PROJECT_USAGE_SCHEMA,
} from "./schemas"

/** Lists projects available to the connected Browserbase API key. */
export const listBrowserbaseProjects = defineAction("List Browserbase projects")
  .describe(
    "Lists every Browserbase project available to the connected API key.",
  )
  .account("browserbase")
  .output(BROWSERBASE_PROJECT_SCHEMA.array())
  .retry({ replaySafety: "safe" })
  .handler(async ({ account }) =>
    BROWSERBASE_PROJECT_SCHEMA.array().parse(
      await getBrowserbaseClient(account.secret).projects.list(),
    ),
  )

/** Gets one Browserbase project. */
export const getBrowserbaseProject = defineAction("Get Browserbase project")
  .describe(
    "Gets project timeout, concurrency, ownership, and identity details.",
  )
  .account("browserbase")
  .input(z.object({ projectId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_PROJECT_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_PROJECT_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).projects.retrieve(
        input.projectId,
      ),
    ),
  )

/** Gets Browserbase project browser and proxy usage. */
export const getBrowserbaseProjectUsage = defineAction(
  "Get Browserbase project usage",
)
  .describe("Gets accumulated browser minutes and proxy bytes for one project.")
  .account("browserbase")
  .input(z.object({ projectId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_PROJECT_USAGE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_PROJECT_USAGE_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).projects.usage(
        input.projectId,
      ),
    ),
  )

/** Creates a reusable Browserbase browser context. */
export const createBrowserbaseContext = defineAction(
  "Create Browserbase context",
)
  .describe(
    "Creates a context for cookies, authentication, and browser storage.",
  )
  .account("browserbase")
  .input(
    z.object({
      name: z.string().trim().min(1).max(128).optional(),
      projectId: BROWSERBASE_ID_SCHEMA.optional(),
    }),
  )
  .output(BROWSERBASE_CONTEXT_CREATE_RESPONSE_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_CONTEXT_CREATE_RESPONSE_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).contexts.create(input),
    ),
  )

/** Gets one reusable Browserbase browser context. */
export const getBrowserbaseContext = defineAction("Get Browserbase context")
  .describe("Gets a context's project, optional name, and timestamps.")
  .account("browserbase")
  .input(z.object({ contextId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_CONTEXT_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_CONTEXT_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).contexts.retrieve(
        input.contextId,
      ),
    ),
  )

/** Permanently deletes one Browserbase context. */
export const deleteBrowserbaseContext = defineAction(
  "Delete Browserbase context",
)
  .describe("Permanently deletes a stored browser context.")
  .account("browserbase")
  .input(z.object({ contextId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_DELETE_RECEIPT_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    await getBrowserbaseClient(account.secret).contexts.delete(input.contextId)
    return { deleted: true as const, id: input.contextId }
  })

/** Uploads a Chrome extension to Browserbase. */
export const uploadBrowserbaseExtension = defineAction(
  "Upload Browserbase extension",
)
  .describe("Uploads a Chrome extension archive for use in later sessions.")
  .account("browserbase")
  .input(
    z.object({
      file: z.instanceof(Blob),
      filename: z.string().min(1).max(255),
    }),
  )
  .output(BROWSERBASE_EXTENSION_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    return BROWSERBASE_EXTENSION_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).extensions.create({
        file: await toFile(await input.file.arrayBuffer(), input.filename, {
          type: input.file.type,
        }),
      }),
    )
  })

/** Gets one uploaded Browserbase extension. */
export const getBrowserbaseExtension = defineAction("Get Browserbase extension")
  .describe("Gets an uploaded extension's filename, project, and timestamps.")
  .account("browserbase")
  .input(z.object({ extensionId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_EXTENSION_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_EXTENSION_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).extensions.retrieve(
        input.extensionId,
      ),
    ),
  )

/** Permanently deletes one Browserbase extension. */
export const deleteBrowserbaseExtension = defineAction(
  "Delete Browserbase extension",
)
  .describe("Permanently deletes an uploaded extension.")
  .account("browserbase")
  .input(z.object({ extensionId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_DELETE_RECEIPT_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    await getBrowserbaseClient(account.secret).extensions.delete(
      input.extensionId,
    )
    return { deleted: true as const, id: input.extensionId }
  })

/** Uploads a trusted TLS certificate to Browserbase. */
export const uploadBrowserbaseCertificate = defineAction(
  "Upload Browserbase certificate",
)
  .describe(
    "Uploads a TLS certificate that sessions can trust through proxy settings.",
  )
  .account("browserbase")
  .input(
    z.object({
      file: z.instanceof(Blob),
      filename: z.string().min(1).max(255),
    }),
  )
  .output(BROWSERBASE_CERTIFICATE_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    return BROWSERBASE_CERTIFICATE_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).certificates.create({
        file: await toFile(await input.file.arrayBuffer(), input.filename, {
          type: input.file.type,
        }),
      }),
    )
  })

/** Lists uploaded Browserbase TLS certificates. */
export const listBrowserbaseCertificates = defineAction(
  "List Browserbase certificates",
)
  .describe(
    "Lists uploaded TLS certificates available to Browserbase sessions.",
  )
  .account("browserbase")
  .output(BROWSERBASE_CERTIFICATE_SCHEMA.array())
  .retry({ replaySafety: "safe" })
  .handler(async ({ account }) =>
    BROWSERBASE_CERTIFICATE_SCHEMA.array().parse(
      await getBrowserbaseClient(account.secret).certificates.list(),
    ),
  )

/** Gets one uploaded Browserbase TLS certificate. */
export const getBrowserbaseCertificate = defineAction(
  "Get Browserbase certificate",
)
  .describe("Gets one uploaded certificate's project and timestamps.")
  .account("browserbase")
  .input(z.object({ certificateId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_CERTIFICATE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_CERTIFICATE_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).certificates.retrieve(
        input.certificateId,
      ),
    ),
  )

/** Permanently deletes one Browserbase TLS certificate. */
export const deleteBrowserbaseCertificate = defineAction(
  "Delete Browserbase certificate",
)
  .describe("Permanently deletes an uploaded TLS certificate.")
  .account("browserbase")
  .input(z.object({ certificateId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_DELETE_RECEIPT_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    await getBrowserbaseClient(account.secret).certificates.delete(
      input.certificateId,
    )
    return { deleted: true as const, id: input.certificateId }
  })