import {z} from 'zod'

export type OpenAIFunction = {name: string};

export type OpenAIToolChoice = {type?: string | undefined, function: OpenAIFunction};

export type ModelLifecycleState = 'active' | 'deprecated' | 'retired';

export type LLMIntegration = 'anthropic' | 'aws_bedrock' | 'aws_sagemaker' | 'azure' | 'custom' | 'databricks' | 'mistral' | 'nvidia' | 'openai' | 'vertex_ai' | 'writer';

export type ContentModality = 'text' | 'document' | 'image' | 'audio' | 'video';

export type ModelCostBy = 'tokens' | 'characters';

export type RunParamsMap = {model?: (string | null) | undefined, temperature?: (string | null) | undefined, max_tokens?: (string | null) | undefined, stop_sequences?: (string | null) | undefined, top_p?: (string | null) | undefined, top_k?: (string | null) | undefined, frequency_penalty?: (string | null) | undefined, presence_penalty?: (string | null) | undefined, echo?: (string | null) | undefined, logprobs?: (string | null) | undefined, top_logprobs?: (string | null) | undefined, n?: (string | null) | undefined, api_version?: (string | null) | undefined, tools?: (string | null) | undefined, tool_choice?: (string | null) | undefined, response_format?: (string | null) | undefined, reasoning_effort?: (string | null) | undefined, verbosity?: (string | null) | undefined, deployment_name?: (string | null) | undefined};

export type OutputMap = {response: string, token_count?: (string | null) | undefined, input_token_count?: (string | null) | undefined, output_token_count?: (string | null) | undefined, completion_reason?: (string | null) | undefined};

export type InputMap = {prompt: string, prefix?: string | undefined, suffix?: string | undefined};

export type Model = {lifecycle_state?: ModelLifecycleState | undefined, replacement_alias?: (string | null) | undefined, deprecation_date?: (string | null) | undefined, retirement_date?: (string | null) | undefined, name: string, alias: string, display_name?: string | undefined, integration?: LLMIntegration | undefined, user_role?: (string | null) | undefined, assistant_role?: (string | null) | undefined, system_supported?: boolean | undefined, input_modalities?: Array<ContentModality> | undefined, alternative_names?: Array<string> | undefined, input_token_limit?: (number | null) | undefined, output_token_limit?: (number | null) | undefined, token_limit?: (number | null) | undefined, cost_by?: ModelCostBy | undefined, is_chat?: boolean | undefined, provides_log_probs?: boolean | undefined, formatting_tokens?: number | undefined, response_prefix_tokens?: number | undefined, api_version?: (string | null) | undefined, legacy_mistral_prompt_format?: boolean | undefined, requires_max_tokens?: boolean | undefined, supports_structured_output?: boolean | undefined, max_top_p?: (number | null) | undefined, params_map?: RunParamsMap | undefined, output_map?: (OutputMap | null) | undefined, input_map?: (InputMap | null) | undefined};

export type PromptRunSettingsInput = {logprobs?: boolean | undefined, top_logprobs?: number | undefined, echo?: boolean | undefined, n?: number | undefined, reasoning_effort?: string | undefined, verbosity?: string | undefined, deployment_name?: (string | null) | undefined, model_alias?: string | undefined, temperature?: (number | null) | undefined, max_tokens?: number | undefined, stop_sequences?: (Array<string> | null) | undefined, top_p?: number | undefined, top_k?: number | undefined, frequency_penalty?: number | undefined, presence_penalty?: number | undefined, tools?: (Array<{[key: string]: unknown}> | null) | undefined, tool_choice?: (string | OpenAIToolChoice | null) | undefined, response_format?: ({[key: string]: string} | null) | undefined, known_models?: Array<Model> | undefined};

export type UpdatePlaygroundPromptRequest = {base_prompt_template_version_id?: (unknown | null) | undefined, template?: (string | null) | undefined, settings?: (PromptRunSettingsInput | null) | undefined, raw?: (boolean | null) | undefined};

export type PatchApiProjectsProjectIdPlaygroundsPlaygroundIdPromptsPromptIdArgs = {project_id: unknown, prompt_id: unknown, playground_id: unknown, body: UpdatePlaygroundPromptRequest};

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

export const userAction = z.enum(["update", "delete", "read_api_keys", "change_role_to_admin", "change_role_to_manager", "change_role_to_user", "change_role_to_read_only", "change_role_to_org_annotator", "change_role_to_capability_based"]);

export const groupAction = z.enum(["update", "list_members", "join", "request_to_join"]);

export const groupMemberAction = z.enum(["update_role", "delete"]);

export const projectAction = z.enum(["read_all_logs", "read_filtered_logs", "delete", "rename", "share", "create_run", "delete_run", "rename_run", "move_run", "export_data", "configure_human_feedback", "record_human_feedback", "log_data", "toggle_metric", "edit_alert", "create_stage", "edit_stage", "configure_crown_logic", "configure_rate_limit", "delete_data", "set_metric", "edit_run_tags", "dismiss_alert", "edit_slice", "edit_edit", "update_control_bindings", "use_control_runtime"]);

export const scorerAction = z.enum(["create_shared", "create_global", "update", "delete", "share", "export", "autotune_apply"]);

export const registeredScorerAction = z.enum(["update", "delete"]);

export const apiKeyAction = z.enum(["update", "delete"]);

export const generatedScorerAction = z.enum(["update", "delete"]);

export const fineTunedScorerAction = z.enum(["update", "delete"]);

export const datasetAction = z.enum(["update", "delete", "share", "export", "rename"]);

export const integrationAction = z.enum(["update", "delete", "share", "read_secrets"]);

export const organizationAction = z.enum(["rename", "delete", "delete_log_data", "read_settings", "update_settings", "read_cost_settings", "read_ai_usage", "read_ai_usage_organization", "read_unredacted_data"]);

export const annotationQueueAction = z.enum(["update", "delete", "share", "record_annotation"]);

export const controlResourceAction = z.enum(["create", "read", "update", "delete"]);

export const permission = z.object({action: z.union([userAction, groupAction, groupMemberAction, projectAction, scorerAction, registeredScorerAction, apiKeyAction, generatedScorerAction, fineTunedScorerAction, datasetAction, integrationAction, organizationAction, annotationQueueAction, controlResourceAction]), allowed: z.boolean(), message: z.string().nullable().optional()});

export const openAIFunction = z.object({name: z.string()});

export const openAIToolChoice = z.object({type: z.string().optional(), function: openAIFunction});

export const promptRunSettingsOutput = z.object({logprobs: z.boolean().optional(), top_logprobs: z.number().int().optional(), echo: z.boolean().optional(), n: z.number().int().optional(), reasoning_effort: z.string().optional(), verbosity: z.string().optional(), deployment_name: z.string().nullable().optional(), model_alias: z.string().optional(), temperature: z.number().nullable().optional(), max_tokens: z.number().int().optional(), stop_sequences: z.array(z.string()).nullable().optional(), top_p: z.number().optional(), top_k: z.number().int().optional(), frequency_penalty: z.number().optional(), presence_penalty: z.number().optional(), tools: z.string().nullable().optional(), tool_choice: z.union([z.string(), openAIToolChoice]).nullable().optional(), response_format: z.record(z.string(), z.string()).nullable().optional()});

export const basePrompt = z.object({id: z.string(), permissions: z.array(permission).optional(), version: z.number().int(), version_id: z.string(), name: z.string(), template: z.string(), settings: promptRunSettingsOutput.optional(), raw: z.boolean().optional()});

export const playgroundPromptResponse = z.object({id: z.string(), base_prompt: basePrompt.nullable(), template: z.string().nullable().optional(), settings: promptRunSettingsOutput.optional(), raw: z.boolean(), position: z.number().int(), run_id: z.string().nullable().optional()});

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

/**
 * Update Playground Prompt
 * 
 * PATCH /projects/{project_id}/playgrounds/{playground_id}/prompts/{prompt_id}
 * 
 * Also accepts auth: ClassicAPIKeyHeader, OAuth2PasswordBearer, HTTPBasic
 */
export const patchApiProjectsProjectIdPlaygroundsPlaygroundIdPromptsPromptId = async (args: PatchApiProjectsProjectIdPlaygroundsPlaygroundIdPromptsPromptIdArgs, options?: PatchApiProjectsProjectIdPlaygroundsPlaygroundIdPromptsPromptIdOptions) => {
const {baseUrl = "https://api.galileo.ai", fetch: fetchFn = fetch, APIKeyHeader} = options ?? {}

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

if (APIKeyHeader !== undefined) headers.set("Splunk-AO-API-Key", APIKeyHeader)

const url = `${baseUrl.replace(/\/+$/, '')}/projects/${encodeURIComponent(String(args.project_id))}/playgrounds/${encodeURIComponent(String(args.playground_id))}/prompts/${encodeURIComponent(String(args.prompt_id))}${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "PATCH", 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(playgroundPromptResponse, await res.json())
};