import * as z from "zod"

export const BROWSERBASE_ID_SCHEMA = z.string().min(1)
export const BROWSERBASE_UUID_SCHEMA = z.uuid()
export const BROWSERBASE_DATE_TIME_SCHEMA = z.iso.datetime({ offset: true })
export const BROWSERBASE_JSON_OBJECT_SCHEMA = z.record(z.string(), z.json())

export const BROWSERBASE_REGION_SCHEMA = z.enum([
  "us-west-2",
  "us-east-1",
  "eu-central-1",
  "ap-southeast-1",
])

export const BROWSERBASE_PROXY_SCHEMA = z.discriminatedUnion("type", [
  z.object({
    domainPattern: z.string().min(1).optional(),
    geolocation: z
      .object({
        city: z.string().min(1).optional(),
        country: z.string().length(2),
        state: z.string().length(2).optional(),
      })
      .optional(),
    type: z.literal("browserbase"),
  }),
  z.object({
    domainPattern: z.string().min(1).optional(),
    password: z.string().optional(),
    server: z.url(),
    type: z.literal("external"),
    username: z.string().optional(),
  }),
  z.object({
    domainPattern: z.string().min(1).optional(),
    type: z.literal("none"),
  }),
])

export const BROWSERBASE_CONTEXT_REFERENCE_SCHEMA = z.object({
  id: BROWSERBASE_ID_SCHEMA,
  persist: z.boolean().optional(),
})

export const BROWSERBASE_BROWSER_SETTINGS_SCHEMA = z.object({
  advancedStealth: z.boolean().optional(),
  allowedDomains: z.string().min(1).array().optional(),
  blockAds: z.boolean().optional(),
  captchaImageSelector: z.string().min(1).optional(),
  captchaInputSelector: z.string().min(1).optional(),
  context: BROWSERBASE_CONTEXT_REFERENCE_SCHEMA.optional(),
  extensionId: BROWSERBASE_ID_SCHEMA.optional(),
  ignoreCertificateErrors: z.boolean().optional(),
  logSession: z.boolean().optional(),
  os: z.enum(["windows", "mac", "linux", "mobile", "tablet"]).optional(),
  recordSession: z.boolean().optional(),
  solveCaptchas: z.boolean().optional(),
  verified: z.boolean().optional(),
  viewport: z
    .object({
      height: z.number().int().positive().optional(),
      width: z.number().int().positive().optional(),
    })
    .optional(),
})

export const BROWSERBASE_SESSION_CREATE_SCHEMA = z.object({
  browserSettings: BROWSERBASE_BROWSER_SETTINGS_SCHEMA.optional(),
  extensionId: BROWSERBASE_ID_SCHEMA.optional(),
  keepAlive: z.boolean().optional(),
  projectId: BROWSERBASE_ID_SCHEMA.optional(),
  proxies: z
    .union([z.boolean(), BROWSERBASE_PROXY_SCHEMA.array().min(1)])
    .optional(),
  proxySettings: z
    .object({ caCertificates: BROWSERBASE_UUID_SCHEMA.array().optional() })
    .optional(),
  region: BROWSERBASE_REGION_SCHEMA.optional(),
  timeout: z.number().int().min(60).max(21_600).optional(),
  userMetadata: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
})

export const BROWSERBASE_SESSION_SCHEMA = z.object({
  contextId: z.string().optional(),
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  endedAt: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
  expiresAt: BROWSERBASE_DATE_TIME_SCHEMA,
  id: z.string(),
  keepAlive: z.boolean(),
  projectId: z.string(),
  proxyBytes: z.number().int(),
  region: BROWSERBASE_REGION_SCHEMA,
  startedAt: BROWSERBASE_DATE_TIME_SCHEMA,
  status: z.enum(["PENDING", "RUNNING", "ERROR", "TIMED_OUT", "COMPLETED"]),
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
  userMetadata: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
})

export const BROWSERBASE_SESSION_CREATE_RESPONSE_SCHEMA =
  BROWSERBASE_SESSION_SCHEMA.extend({
    connectUrl: z.url(),
    seleniumRemoteUrl: z.url(),
    signingKey: z.string(),
  })

export const BROWSERBASE_SESSION_RESPONSE_SCHEMA =
  BROWSERBASE_SESSION_SCHEMA.extend({
    connectUrl: z.url().optional(),
    seleniumRemoteUrl: z.url().optional(),
    signingKey: z.string().optional(),
  })

export const BROWSERBASE_SESSION_LIVE_URLS_SCHEMA = z.object({
  debuggerFullscreenUrl: z.url(),
  debuggerUrl: z.url(),
  pages: z
    .object({
      debuggerFullscreenUrl: z.url(),
      debuggerUrl: z.url(),
      faviconUrl: z.union([z.url(), z.literal("")]),
      id: z.string(),
      title: z.string(),
      url: z.url(),
    })
    .array(),
  wsUrl: z.url(),
})

export const BROWSERBASE_SESSION_LOG_SCHEMA = z.object({
  frameId: z.string().optional(),
  loaderId: z.string().optional(),
  method: z.string(),
  pageId: z.number().int(),
  request: z
    .object({
      params: BROWSERBASE_JSON_OBJECT_SCHEMA,
      rawBody: z.string(),
      timestamp: z.number().int().optional(),
    })
    .optional(),
  response: z
    .object({
      rawBody: z.string(),
      result: BROWSERBASE_JSON_OBJECT_SCHEMA,
      timestamp: z.number().int().optional(),
    })
    .optional(),
  sessionId: z.string(),
  timestamp: z.number().int().optional(),
})

export const BROWSERBASE_RECORDING_DOWNLOAD_SCHEMA = z.object({
  completedAt: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
  downloadUrl: z.url().optional(),
  pageId: z.string(),
  status: z.enum(["NOT_REQUESTED", "PENDING", "COMPLETED", "FAILED"]),
})

export const BROWSERBASE_RECORDING_DOWNLOADS_SCHEMA = z.object({
  downloads: BROWSERBASE_RECORDING_DOWNLOAD_SCHEMA.array(),
})

export const BROWSERBASE_SESSION_REPLAY_SCHEMA = z.object({
  pageCount: z.number().int().nonnegative(),
  pages: z
    .object({
      endTimeMs: z.number().int(),
      pageId: z.string(),
      startTimeMs: z.number().int(),
      url: z.string(),
    })
    .array(),
})

export const BROWSERBASE_PROJECT_SCHEMA = z.object({
  concurrency: z.number().int().positive(),
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  defaultTimeout: z.number().int().min(60).max(21_600),
  id: z.string(),
  name: z.string().min(1),
  ownerId: z.string(),
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
})

export const BROWSERBASE_PROJECT_USAGE_SCHEMA = z.object({
  browserMinutes: z.number().int().nonnegative(),
  proxyBytes: z.number().int().nonnegative(),
})

export const BROWSERBASE_CONTEXT_SCHEMA = z.object({
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  id: z.string(),
  name: z.string().min(1).max(128).optional(),
  projectId: z.string(),
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
})

export const BROWSERBASE_CONTEXT_CREATE_RESPONSE_SCHEMA = z.object({
  cipherAlgorithm: z.string(),
  id: z.string(),
  initializationVectorSize: z.number().int().positive(),
  publicKey: z.string(),
})

export const BROWSERBASE_EXTENSION_SCHEMA = z.object({
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  fileName: z.string().min(1),
  id: z.string(),
  projectId: z.string(),
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
})

export const BROWSERBASE_CERTIFICATE_SCHEMA = z.object({
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  id: z.string(),
  projectId: z.string(),
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
})

export const BROWSERBASE_AGENT_SCHEMA = z.object({
  agentId: z.string(),
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  name: z.string().min(1).max(255),
  resultSchema: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
  systemPrompt: z.string().optional(),
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
})

export const BROWSERBASE_AGENT_RUN_STATUS_SCHEMA = z.enum([
  "PENDING",
  "RUNNING",
  "COMPLETED",
  "FAILED",
  "STOPPED",
  "TIMED_OUT",
])

export const BROWSERBASE_AGENT_RUN_SCHEMA = z.object({
  agentId: z.string().optional(),
  cause: z
    .object({
      code: z.string().max(64),
      message: z.string().max(500).optional(),
    })
    .optional(),
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  endedAt: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
  result: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
  resultSchema: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
  runId: z.string(),
  sandboxId: z.string().optional(),
  sessionId: z.string().optional(),
  startedAt: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
  status: BROWSERBASE_AGENT_RUN_STATUS_SCHEMA,
  task: z.string(),
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
})

export const BROWSERBASE_AGENT_RUN_BROWSER_SETTINGS_SCHEMA = z.object({
  context: BROWSERBASE_CONTEXT_REFERENCE_SCHEMA.optional(),
  proxies: z
    .union([z.boolean(), BROWSERBASE_PROXY_SCHEMA.array().min(1)])
    .optional(),
  verified: z.boolean().optional(),
})

export const BROWSERBASE_CURSOR_PAGE_INPUT_SCHEMA = z.object({
  cursor: z.string().min(1).optional(),
  endAt: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
  limit: z.number().int().min(1).max(1_000).optional(),
  startAt: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
})

export const BROWSERBASE_AGENT_PAGE_SCHEMA = z.object({
  data: BROWSERBASE_AGENT_SCHEMA.array(),
  limit: z.number().int().positive(),
  nextCursor: z.string().nullable(),
})

export const BROWSERBASE_AGENT_RUN_PAGE_SCHEMA = z.object({
  data: BROWSERBASE_AGENT_RUN_SCHEMA.array(),
  limit: z.number().int().positive(),
  nextCursor: z.string().nullable(),
})

const BROWSERBASE_MESSAGE_PART_SCHEMA = z.object({
  data: z.string().optional(),
  input: z.json().optional(),
  mediaType: z.string().optional(),
  output: z.json().optional(),
  text: z.string().optional(),
  toolCallId: z.string().optional(),
  toolName: z.string().optional(),
  type: z.string(),
})

export const BROWSERBASE_AGENT_MESSAGE_PAGE_SCHEMA = z.object({
  data: z
    .object({
      createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
      id: z.string(),
      message: z.object({
        content: z.union([z.string(), BROWSERBASE_MESSAGE_PART_SCHEMA.array()]),
        role: z.enum(["assistant", "tool"]),
      }),
    })
    .array(),
  nextSince: z.string().nullable(),
})

export const BROWSERBASE_DOWNLOAD_SCHEMA = z.object({
  checksum: z.string(),
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  filename: z.string(),
  id: z.string(),
  mimeType: z.string(),
  sessionId: z.string(),
  size: z.number().nonnegative(),
})

export const BROWSERBASE_DOWNLOAD_PAGE_SCHEMA = z.object({
  downloads: BROWSERBASE_DOWNLOAD_SCHEMA.array(),
  limit: z.number().int().positive(),
  offset: z.number().int().nonnegative(),
  total: z.number().int().nonnegative(),
})

export const BROWSERBASE_FUNCTION_SCHEMA = z.object({
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  id: BROWSERBASE_UUID_SCHEMA,
  name: z.string().min(1),
  projectId: BROWSERBASE_UUID_SCHEMA,
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
})

export const BROWSERBASE_FUNCTION_VERSION_SCHEMA = z.object({
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  functionBuildId: BROWSERBASE_UUID_SCHEMA,
  functionId: BROWSERBASE_UUID_SCHEMA,
  id: BROWSERBASE_UUID_SCHEMA,
  projectId: BROWSERBASE_UUID_SCHEMA,
  sessionCreateParams: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
  userParamsSchema: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
})

export const BROWSERBASE_FUNCTION_BUILD_STATUS_SCHEMA = z.enum([
  "PENDING",
  "RUNNING",
  "COMPLETED",
  "FAILED",
])

export const BROWSERBASE_FUNCTION_BUILD_SCHEMA = z.object({
  builtFunctions: z
    .object({
      ...BROWSERBASE_FUNCTION_SCHEMA.shape,
      createdVersion: BROWSERBASE_FUNCTION_VERSION_SCHEMA,
    })
    .array()
    .optional(),
  cause: z
    .object({
      code: z.enum([
        "NO_MANIFESTS_FOUND",
        "TOO_MANY_MANIFESTS",
        "MANIFEST_TOO_LARGE",
        "INVALID_SESSION_CREATE_PARAMS",
        "TIMED_OUT",
        "WORKLOAD_ERROR",
      ]),
      message: z.string().min(1).optional(),
    })
    .optional(),
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  endedAt: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
  expiresAt: BROWSERBASE_DATE_TIME_SCHEMA,
  id: BROWSERBASE_UUID_SCHEMA,
  projectId: BROWSERBASE_UUID_SCHEMA,
  request: z.object({
    entrypoint: z.string().min(1),
    functionNames: z.string().min(1).array().optional(),
  }),
  startedAt: BROWSERBASE_DATE_TIME_SCHEMA,
  status: BROWSERBASE_FUNCTION_BUILD_STATUS_SCHEMA,
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
})

export const BROWSERBASE_INVOCATION_STATUS_SCHEMA = z.enum([
  "PENDING",
  "RUNNING",
  "COMPLETED",
  "FAILED",
])

export const BROWSERBASE_INVOCATION_SCHEMA = z.object({
  cause: z
    .object({
      code: z.enum(["TIMED_OUT", "INTERNAL_ERROR", "WORKLOAD_ERROR"]),
      message: z.string().min(1).optional(),
    })
    .optional(),
  createdAt: BROWSERBASE_DATE_TIME_SCHEMA,
  endedAt: BROWSERBASE_DATE_TIME_SCHEMA.optional(),
  expiresAt: BROWSERBASE_DATE_TIME_SCHEMA,
  functionId: BROWSERBASE_UUID_SCHEMA,
  id: BROWSERBASE_UUID_SCHEMA,
  params: BROWSERBASE_JSON_OBJECT_SCHEMA.optional(),
  projectId: BROWSERBASE_UUID_SCHEMA,
  region: z.string().min(1).optional(),
  results: z.json().nullable().optional(),
  sessionId: BROWSERBASE_UUID_SCHEMA,
  startedAt: BROWSERBASE_DATE_TIME_SCHEMA,
  status: BROWSERBASE_INVOCATION_STATUS_SCHEMA,
  updatedAt: BROWSERBASE_DATE_TIME_SCHEMA,
  versionId: BROWSERBASE_UUID_SCHEMA,
})

export const BROWSERBASE_LOG_ENTRY_SCHEMA = z.object({
  message: z.string(),
  timestamp: z.number(),
})

export const BROWSERBASE_LOG_PAGE_SCHEMA = z.object({
  logs: BROWSERBASE_LOG_ENTRY_SCHEMA.array(),
  total: z.number().int().nonnegative(),
})

export const BROWSERBASE_OFFSET_PAGE_INPUT_SCHEMA = z.object({
  limit: z.number().int().min(1).max(100).optional(),
  offset: z.number().int().nonnegative().optional(),
})

export const BROWSERBASE_DELETE_RECEIPT_SCHEMA = z.object({
  deleted: z.literal(true),
  id: z.string(),
})