import {z} from 'zod'

export type WebhookConfiguration = {webhook_url?: (string | null) | undefined, webhook_headers?: ({[key: string]: string} | null) | undefined, webhook_signing_secret?: (string | null) | undefined, webhook_events?: (Array<'extract.pending' | 'extract.running' | 'extract.success' | 'extract.error' | 'extract.partial_success' | 'extract.cancelled' | 'parse.pending' | 'parse.running' | 'parse.success' | 'parse.error' | 'parse.partial_success' | 'parse.cancelled' | 'classify.pending' | 'classify.running' | 'classify.success' | 'classify.error' | 'classify.partial_success' | 'classify.cancelled' | 'sheets.pending' | 'sheets.success' | 'sheets.error' | 'sheets.partial_success' | 'sheets.cancelled' | 'split.pending' | 'split.processing' | 'split.success' | 'split.error' | 'split.cancelled' | 'batch.pending' | 'batch.running' | 'batch.success' | 'batch.error' | 'batch.cancelled' | 'verify.pending' | 'verify.running' | 'verify.success' | 'verify.error' | 'verify.cancelled' | 'unmapped_event'> | null) | undefined, webhook_output_format?: (string | null) | undefined};

export type ExtractTarget = 'PER_DOC' | 'PER_PAGE' | 'PER_TABLE_ROW';

export type ExtractMode = 'FAST' | 'BALANCED' | 'PREMIUM' | 'MULTIMODAL';

export type PublicModelName = 'openai-gpt-4o' | 'openai-gpt-4o-mini' | 'openai-gpt-4-1' | 'openai-gpt-4-1-mini' | 'openai-gpt-4-1-nano' | 'openai-gpt-5' | 'openai-gpt-5-mini' | 'openai-gpt-5-nano' | 'openai-text-embedding-3-large' | 'openai-text-embedding-3-small' | 'openai-whisper-1' | 'anthropic-sonnet-3.5' | 'anthropic-sonnet-3.5-v2' | 'anthropic-sonnet-3.7' | 'anthropic-sonnet-4.0' | 'anthropic-sonnet-4.5' | 'anthropic-haiku-3.5' | 'anthropic-haiku-4.5' | 'gemini-2.5-flash' | 'gemini-3.0-pro' | 'gemini-3.1-pro' | 'gemini-2.5-pro' | 'gemini-2.0-flash' | 'gemini-2.0-flash-lite' | 'gemini-2.5-flash-lite';

export type ExtractModels = 'openai-gpt-4-1' | 'openai-gpt-4-1-mini' | 'openai-gpt-4-1-nano' | 'openai-gpt-5' | 'openai-gpt-5-mini' | 'gemini-2.0-flash' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite' | 'gemini-2.5-pro' | 'openai-gpt-4o' | 'openai-gpt-4o-mini';

export type DocumentChunkMode = 'PAGE' | 'SECTION';

export type ExtractConfig = {priority?: ('low' | 'medium' | 'high' | 'critical' | null) | undefined, extraction_target?: ExtractTarget | undefined, extraction_mode?: ExtractMode | undefined, parse_model?: (PublicModelName | null) | undefined, extract_model?: (ExtractModels | string | null) | undefined, multimodal_fast_mode?: boolean | undefined, system_prompt?: (string | null) | undefined, use_reasoning?: boolean | undefined, cite_sources?: boolean | undefined, citation_bbox?: boolean | undefined, confidence_scores?: boolean | undefined, chunk_mode?: DocumentChunkMode | undefined, high_resolution_mode?: boolean | undefined, invalidate_cache?: boolean | undefined, num_pages_context?: (number | null) | undefined, page_range?: (string | null) | undefined};

export type ExtractJobCreateBatch = {webhook_configurations?: (Array<WebhookConfiguration> | null) | undefined, extraction_agent_id: string, file_ids: Array<string>, data_schema_override?: ({[key: string]: {[key: string]: unknown} | Array<unknown> | string | number | number | boolean | null} | string | null) | undefined, config_override?: (ExtractConfig | null) | undefined};

export type CreateApiApiV1ExtractionJobsBatchArgs = {from_ui?: boolean | undefined, project_id?: (string | null) | undefined, session?: (string | null) | undefined, body: ExtractJobCreateBatch};

export type CreateApiApiV1ExtractionJobsBatchOptions = {baseUrl: string, HTTPBearer?: string | undefined, fetch?: typeof fetch | undefined};

export const extractTarget = z.enum(["PER_DOC", "PER_PAGE", "PER_TABLE_ROW"]);

export const extractMode = z.enum(["FAST", "BALANCED", "PREMIUM", "MULTIMODAL"]);

export const publicModelName = z.enum(["openai-gpt-4o", "openai-gpt-4o-mini", "openai-gpt-4-1", "openai-gpt-4-1-mini", "openai-gpt-4-1-nano", "openai-gpt-5", "openai-gpt-5-mini", "openai-gpt-5-nano", "openai-text-embedding-3-large", "openai-text-embedding-3-small", "openai-whisper-1", "anthropic-sonnet-3.5", "anthropic-sonnet-3.5-v2", "anthropic-sonnet-3.7", "anthropic-sonnet-4.0", "anthropic-sonnet-4.5", "anthropic-haiku-3.5", "anthropic-haiku-4.5", "gemini-2.5-flash", "gemini-3.0-pro", "gemini-3.1-pro", "gemini-2.5-pro", "gemini-2.0-flash", "gemini-2.0-flash-lite", "gemini-2.5-flash-lite"]);

export const extractModels = z.enum(["openai-gpt-4-1", "openai-gpt-4-1-mini", "openai-gpt-4-1-nano", "openai-gpt-5", "openai-gpt-5-mini", "gemini-2.0-flash", "gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.5-pro", "openai-gpt-4o", "openai-gpt-4o-mini"]);

export const documentChunkMode = z.enum(["PAGE", "SECTION"]);

export const extractConfig = z.object({priority: z.enum(["low", "medium", "high", "critical"]).nullable().optional(), extraction_target: extractTarget.optional(), extraction_mode: extractMode.optional(), parse_model: publicModelName.nullable().optional(), extract_model: z.union([extractModels, z.string()]).nullable().optional(), multimodal_fast_mode: z.boolean().optional(), system_prompt: z.string().nullable().optional(), use_reasoning: z.boolean().optional(), cite_sources: z.boolean().optional(), citation_bbox: z.boolean().optional(), confidence_scores: z.boolean().optional(), chunk_mode: documentChunkMode.optional(), high_resolution_mode: z.boolean().optional(), invalidate_cache: z.boolean().optional(), num_pages_context: z.number().int().gte(1).nullable().optional(), page_range: z.string().nullable().optional()});

export const extractAgent = z.object({id: z.string(), name: z.string(), project_id: z.string(), data_schema: z.record(z.string(), z.union([z.record(z.string(), z.unknown()), z.array(z.unknown()), z.string(), z.number().int(), z.number(), z.boolean()]).nullable()), config: extractConfig, custom_configuration: z.literal("default").nullable().optional(), created_at: z.string().nullable().optional(), updated_at: z.string().nullable().optional()});

export const file = z.object({id: z.string(), created_at: z.string().nullable().optional(), updated_at: z.string().nullable().optional(), name: z.string().min(1).max(3000), external_file_id: z.string().nullable().optional(), file_size: z.number().int().gte(0).nullable().optional(), file_type: z.string().min(1).max(3000).nullable().optional(), project_id: z.string(), last_modified_at: z.string().nullable().optional(), resource_info: z.record(z.string(), z.union([z.record(z.string(), z.unknown()), z.array(z.unknown()), z.string(), z.number().int(), z.number(), z.boolean()]).nullable()).nullable().optional(), permission_info: z.record(z.string(), z.union([z.record(z.string(), z.unknown()), z.array(z.unknown()), z.string(), z.number().int(), z.number(), z.boolean()]).nullable()).nullable().optional(), data_source_id: z.string().nullable().optional(), expires_at: z.string().nullable().optional(), purpose: z.string().nullable().optional()});

export const extractJob = z.object({id: z.string(), extraction_agent: extractAgent, status: z.enum(["PENDING", "SUCCESS", "ERROR", "PARTIAL_SUCCESS", "CANCELLED"]), error: z.string().nullable().optional(), file_id: z.string().nullable().optional(), file: file.nullable().optional()});

export const createApiApiV1ExtractionJobsBatchResponse = z.array(extractJob);

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * Run Batch Jobs
 * 
 * POST /api/v1/extraction/jobs/batch
 */
export const createApiApiV1ExtractionJobsBatch = async (args: CreateApiApiV1ExtractionJobsBatchArgs, options: CreateApiApiV1ExtractionJobsBatchOptions) => {
const {baseUrl, fetch: fetchFn = fetch, HTTPBearer} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
const cookies: string[] = []
headers.set('content-type', "application/json")
headers.set('accept', "application/json")

if (args.from_ui != null) query.append("from_ui", String(args.from_ui))
if (args.project_id != null) query.append("project_id", String(args.project_id))
if (args.session != null) cookies.push("session=" + encodeURIComponent(String(args.session)))
if (HTTPBearer !== undefined) headers.set('authorization', `Bearer ${HTTPBearer}`)
if (cookies.length > 0) headers.set('cookie', cookies.join('; '))

const url = `${baseUrl.replace(/\/+$/, '')}/api/v1/extraction/jobs/batch${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "POST", headers, body: JSON.stringify(args.body)})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(createApiApiV1ExtractionJobsBatchResponse, await res.json())
};