import {z} from 'zod'

export type GetApiTasksTaskIdStreamArgs = {task_id: string};

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

export const startPart = z.object({type: z.literal("start").optional()});

export const streamMetadata = z.object({cacheCreationInputTokens: z.number().int().nullable().optional(), cacheReadInputTokens: z.number().int().nullable().optional(), costUsd: z.number().nullable().optional(), durationMs: z.number().int().nullable().optional(), parentToolUseId: z.string().nullable().optional()});

export const startStepPart = z.object({metadata: streamMetadata.nullable().optional(), request: z.record(z.string(), z.unknown()).nullable().optional(), type: z.literal("start-step").optional(), warnings: z.array(z.unknown()).nullable().optional()});

export const finishReason = z.enum(["stop", "tool-calls", "length", "content-filter", "error", "other"]);

export const streamUsage = z.object({inputTokens: z.number().int(), outputTokens: z.number().int(), totalTokens: z.number().int().nullable().optional()});

export const finishStepPart = z.object({finishReason: finishReason, metadata: streamMetadata.nullable().optional(), type: z.literal("finish-step").optional(), usage: streamUsage});

export const finishPart = z.object({finishReason: finishReason, metadata: streamMetadata.nullable().optional(), totalUsage: streamUsage, type: z.literal("finish").optional()});

export const handlerCompletePart = z.object({durationMs: z.number().int().nullable().optional(), error: z.string().nullable().optional(), eventId: z.string(), success: z.boolean(), taskId: z.string(), type: z.literal("handler-complete").optional()});

export const textStartPart = z.object({id: z.string(), metadata: streamMetadata.nullable().optional(), type: z.literal("text-start").optional()});

export const textDeltaPart = z.object({id: z.string(), metadata: streamMetadata.nullable().optional(), text: z.string(), type: z.literal("text-delta").optional()});

export const textEndPart = z.object({id: z.string(), metadata: streamMetadata.nullable().optional(), type: z.literal("text-end").optional()});

export const reasoningStartPart = z.object({id: z.string(), metadata: streamMetadata.nullable().optional(), type: z.literal("reasoning-start").optional()});

export const reasoningDeltaPart = z.object({id: z.string(), metadata: streamMetadata.nullable().optional(), text: z.string(), type: z.literal("reasoning-delta").optional()});

export const reasoningEndPart = z.object({id: z.string(), metadata: streamMetadata.nullable().optional(), type: z.literal("reasoning-end").optional()});

export const toolInputStartPart = z.object({id: z.string(), metadata: streamMetadata.nullable().optional(), toolName: z.string(), type: z.literal("tool-input-start").optional()});

export const toolInputDeltaPart = z.object({delta: z.string(), id: z.string(), metadata: streamMetadata.nullable().optional(), type: z.literal("tool-input-delta").optional()});

export const toolInputEndPart = z.object({id: z.string(), metadata: streamMetadata.nullable().optional(), type: z.literal("tool-input-end").optional()});

export const toolCallPart = z.object({input: z.record(z.string(), z.unknown()), metadata: streamMetadata.nullable().optional(), toolCallId: z.string(), toolName: z.string(), type: z.literal("tool-call").optional()});

export const toolResultPart = z.object({metadata: streamMetadata.nullable().optional(), output: z.unknown(), toolCallId: z.string(), toolName: z.string(), type: z.literal("tool-result").optional()});

export const streamErrorPart = z.object({error: z.string(), rawContent: z.unknown(), type: z.literal("error").optional()});

export const textStreamPartWrapper = z.discriminatedUnion("type", [startPart, startStepPart, finishStepPart, finishPart, handlerCompletePart, textStartPart, textDeltaPart, textEndPart, reasoningStartPart, reasoningDeltaPart, reasoningEndPart, toolInputStartPart, toolInputDeltaPart, toolInputEndPart, toolCallPart, toolResultPart, streamErrorPart]);

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
};

/**
 * Stream Task Events by ID
 * 
 * GET /tasks/{task_id}/stream
 */
export const getApiTasksTaskIdStream = async (args: GetApiTasksTaskIdStreamArgs, options: GetApiTasksTaskIdStreamOptions) => {
const {baseUrl, fetch: fetchFn = fetch} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

const url = `${baseUrl.replace(/\/+$/, '')}/tasks/${encodeURIComponent(String(args.task_id))}/stream${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

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

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