import * as z from "zod"
import { defineAction } from "../../automation/actions"
import { getBrowserbaseClient, requestBrowserbase } from "./lib"
import {
  BROWSERBASE_AGENT_MESSAGE_PAGE_SCHEMA,
  BROWSERBASE_AGENT_PAGE_SCHEMA,
  BROWSERBASE_AGENT_RUN_BROWSER_SETTINGS_SCHEMA,
  BROWSERBASE_AGENT_RUN_PAGE_SCHEMA,
  BROWSERBASE_AGENT_RUN_SCHEMA,
  BROWSERBASE_AGENT_RUN_STATUS_SCHEMA,
  BROWSERBASE_AGENT_SCHEMA,
  BROWSERBASE_CURSOR_PAGE_INPUT_SCHEMA,
  BROWSERBASE_DELETE_RECEIPT_SCHEMA,
  BROWSERBASE_ID_SCHEMA,
  BROWSERBASE_JSON_OBJECT_SCHEMA,
} from "./schemas"

const AGENT_FIELDS = {
  name: z.string().trim().min(1).max(255),
  resultSchema: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
  systemPrompt: z.string().min(1).optional(),
}

/** Creates a reusable Browserbase agent. */
export const createBrowserbaseAgent = defineAction("Create Browserbase agent")
  .describe(
    "Creates a reusable agent with an optional system prompt and result schema.",
  )
  .account("browserbase")
  .input(z.object(AGENT_FIELDS))
  .output(BROWSERBASE_AGENT_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_AGENT_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).agents.create(input),
    ),
  )

/** Lists reusable Browserbase agents. */
export const listBrowserbaseAgents = defineAction("List Browserbase agents")
  .describe(
    "Lists one cursor page of agents with optional creation-time filters.",
  )
  .account("browserbase")
  .input(BROWSERBASE_CURSOR_PAGE_INPUT_SCHEMA)
  .output(BROWSERBASE_AGENT_PAGE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_AGENT_PAGE_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).agents.list(input),
    ),
  )

/** Gets one reusable Browserbase agent. */
export const getBrowserbaseAgent = defineAction("Get Browserbase agent")
  .describe("Gets one agent's prompt, result schema, name, and timestamps.")
  .account("browserbase")
  .input(z.object({ agentId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_AGENT_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_AGENT_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).agents.retrieve(input.agentId),
    ),
  )

/** Updates a reusable Browserbase agent. */
export const updateBrowserbaseAgent = defineAction("Update Browserbase agent")
  .describe("Updates an agent's name, system prompt, or default result schema.")
  .account("browserbase")
  .input(
    z
      .object({
        agentId: BROWSERBASE_ID_SCHEMA,
        name: AGENT_FIELDS.name.optional(),
        resultSchema: AGENT_FIELDS.resultSchema,
        systemPrompt: AGENT_FIELDS.systemPrompt,
      })
      .refine(
        ({ name, resultSchema, systemPrompt }) =>
          name !== undefined ||
          resultSchema !== undefined ||
          systemPrompt !== undefined,
        "Provide an agent field to update.",
      ),
  )
  .output(BROWSERBASE_AGENT_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input: { agentId, ...input } }) =>
    BROWSERBASE_AGENT_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).agents.update(agentId, input),
    ),
  )

/** Permanently deletes one reusable Browserbase agent. */
export const deleteBrowserbaseAgent = defineAction("Delete Browserbase agent")
  .describe("Permanently deletes an agent without changing its existing runs.")
  .account("browserbase")
  .input(z.object({ agentId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_DELETE_RECEIPT_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) => {
    await getBrowserbaseClient(account.secret).agents.delete(input.agentId)
    return { deleted: true as const, id: input.agentId }
  })

/** Starts a Browserbase agent run. */
export const runBrowserbaseAgent = defineAction("Run Browserbase agent")
  .describe(
    "Starts an ad-hoc or reusable agent run and returns its initial state.",
  )
  .account("browserbase")
  .input(
    z.object({
      agentId: BROWSERBASE_ID_SCHEMA.optional(),
      browserSettings: BROWSERBASE_AGENT_RUN_BROWSER_SETTINGS_SCHEMA.optional(),
      resultSchema: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
      task: z.string().min(1),
      variables: z
        .record(
          z.string().min(1),
          z.object({
            description: z.string().min(1).optional(),
            value: z.string(),
          }),
        )
        .optional(),
    }),
  )
  .output(BROWSERBASE_AGENT_RUN_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_AGENT_RUN_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).agents.runs.create(input),
    ),
  )

/** Lists Browserbase agent runs. */
export const listBrowserbaseAgentRuns = defineAction(
  "List Browserbase agent runs",
)
  .describe(
    "Lists one cursor page of runs filtered by agent, status, or creation time.",
  )
  .account("browserbase")
  .input(
    BROWSERBASE_CURSOR_PAGE_INPUT_SCHEMA.extend({
      agentId: BROWSERBASE_ID_SCHEMA.optional(),
      status: BROWSERBASE_AGENT_RUN_STATUS_SCHEMA.optional(),
    }),
  )
  .output(BROWSERBASE_AGENT_RUN_PAGE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_AGENT_RUN_PAGE_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).agents.runs.list(input),
    ),
  )

/** Gets one Browserbase agent run. */
export const getBrowserbaseAgentRun = defineAction("Get Browserbase agent run")
  .describe(
    "Gets current state, session identity, result, and failure cause for one run.",
  )
  .account("browserbase")
  .input(z.object({ runId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_AGENT_RUN_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input }) =>
    BROWSERBASE_AGENT_RUN_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).agents.runs.retrieve(
        input.runId,
      ),
    ),
  )

/** Lists chronological messages from a Browserbase agent run. */
export const listBrowserbaseAgentRunMessages = defineAction(
  "List Browserbase agent run messages",
)
  .describe(
    "Lists AI SDK-compatible assistant and tool messages after an optional cursor.",
  )
  .account("browserbase")
  .input(
    z.object({
      all: z.boolean().optional(),
      limit: z.number().int().min(1).max(100).optional(),
      runId: BROWSERBASE_ID_SCHEMA,
      since: z.string().min(1).optional(),
    }),
  )
  .output(BROWSERBASE_AGENT_MESSAGE_PAGE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(async ({ account, input: { runId, ...input } }) =>
    BROWSERBASE_AGENT_MESSAGE_PAGE_SCHEMA.parse(
      await getBrowserbaseClient(account.secret).agents.runs.listMessages(
        runId,
        input,
      ),
    ),
  )

/** Requests that an in-progress Browserbase agent run stop. */
export const stopBrowserbaseAgentRun = defineAction(
  "Stop Browserbase agent run",
)
  .describe("Requests a graceful stop and returns the run's accepted state.")
  .account("browserbase")
  .input(z.object({ runId: BROWSERBASE_ID_SCHEMA }))
  .output(BROWSERBASE_AGENT_RUN_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(async ({ account, input }) =>
    requestBrowserbase(
      account.secret,
      `/v1/agents/runs/${encodeURIComponent(input.runId)}/stop`,
      { method: "POST", responseSchema: BROWSERBASE_AGENT_RUN_SCHEMA },
    ),
  )