import {z} from 'zod'

export type ScorerAction = 'create_shared' | 'create_global' | 'update' | 'delete' | 'share' | 'export' | 'autotune_apply';

export type GetApiPublicV2ScorersScorerIdArgs = {scorer_id: unknown, actions?: Array<ScorerAction> | undefined};

export type GetApiPublicV2ScorersScorerIdOptions = {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 scorerTypes = z.enum(["llm", "code", "luna", "decision", "preset"]);

export const nodeNameFilter = z.object({name: z.literal("node_name").optional(), operator: z.enum(["eq", "ne", "contains", "one_of", "not_in"]), value: z.union([z.string(), z.array(z.string())]), case_sensitive: z.boolean().optional()});

export const metadataFilter = z.object({name: z.literal("metadata").optional(), operator: z.enum(["one_of", "not_in", "eq", "ne"]), key: z.string(), value: z.union([z.string(), z.array(z.string())])});

export const modalityFilter = z.object({name: z.literal("modality").optional(), operator: z.enum(["eq", "ne", "one_of", "not_in"]), value: z.union([z.string(), z.array(z.string())])});

export const outputTypeEnum = z.enum(["boolean", "categorical", "count", "discrete", "freeform", "percentage", "multilabel", "retrieved_chunk_list_boolean", "boolean_multilabel", "boolean_probability"]);

export const inputTypeEnum = z.enum(["basic", "llm_spans", "retriever_spans", "sessions_normalized", "sessions_trace_io_only", "tool_spans", "trace_input_only", "trace_io_only", "trace_normalized", "trace_output_only", "agent_spans", "workflow_spans", "trace_selected_spans"]);

export const scorerInvocationPayloadFormat = z.enum(["query", "response", "pairwise", "node_input_output"]);

export const scorerInvocationConfig = z.object({required_inputs: z.array(z.enum(["query", "response"])).optional(), payload_format: scorerInvocationPayloadFormat});

export const scorerDefaults = z.object({model_name: z.string().nullable().optional(), num_judges: z.number().int().nullable().optional(), filters: z.array(z.discriminatedUnion("name", [nodeNameFilter, metadataFilter, modalityFilter])).nullable().optional(), scoreable_node_types: z.array(z.string()).nullable().optional(), cot_enabled: z.boolean().nullable().optional(), output_type: outputTypeEnum.nullable().optional(), input_type: inputTypeEnum.nullable().optional(), invocation: scorerInvocationConfig.nullable().optional()});

export const fewShotExample = z.object({generation_prompt_and_response: z.string(), evaluating_response: z.string()});

export const chainPollTemplate = z.object({metric_system_prompt: z.string().nullable().optional(), metric_description: z.string().nullable().optional(), value_field_name: z.string().optional(), explanation_field_name: z.string().optional(), template: z.string(), metric_few_shot_examples: z.array(fewShotExample).optional(), response_schema: z.record(z.string(), z.unknown()).nullable().optional()});

export const baseGeneratedScorerDB = z.object({id: z.string(), name: z.string(), instructions: z.string().nullable().optional(), chain_poll_template: chainPollTemplate, user_prompt: z.string().nullable().optional()});

export const baseRegisteredScorerDB = z.object({id: z.string(), name: z.string(), score_type: z.string().nullable().optional()});

export const lunaInputTypeEnum = z.enum(["span", "trace_object", "trace_input_output_only"]);

export const lunaOutputTypeEnum = z.enum(["float", "string", "string_list", "bool_list"]);

export const scorerName = z.enum(["action_completion_luna", "action_advancement_luna", "agentic_session_success", "agentic_session_success", "action_completion_vision", "action_completion_audio", "agentic_workflow_success", "agentic_workflow_success", "agent_efficiency", "agent_flow", "agent_flow_vision", "agent_flow_audio", "chunk_attribution_utilization_luna", "chunk_attribution_utilization", "chunk_relevance", "chunk_relevance_luna", "context_precision", "precision_at_k", "completeness_luna", "completeness", "context_adherence", "context_adherence_luna", "context_adherence_vision_luna", "context_adherence_vision", "context_adherence_audio", "context_relevance", "context_relevance_luna", "conversation_quality", "conversation_quality_vision", "conversation_quality_audio", "unsafe_output", "correctness", "correctness_vision", "correctness_audio", "ground_truth_adherence", "ground_truth_adherence_vision", "ground_truth_adherence_audio", "visual_fidelity", "visual_quality", "input_pii", "input_pii_vision_luna", "input_pii_gpt", "input_pii_vision", "input_pii_audio", "input_sexist", "input_sexist", "input_sexist_vision", "input_sexist_audio", "input_sexist_luna", "input_sexist_luna", "input_sexist_vision_luna", "input_tone", "input_tone_gpt", "input_toxicity", "input_toxicity_luna", "input_toxicity_vision_luna", "input_toxicity_vision", "input_toxicity_audio", "instruction_adherence", "instruction_adherence_vision", "instruction_adherence_audio", "output_pii", "output_pii_vision_luna", "output_pii_gpt", "output_pii_vision", "output_pii_audio", "output_sexist", "output_sexist", "output_sexist_vision", "output_sexist_audio", "output_sexist_luna", "output_sexist_luna", "output_sexist_vision_luna", "output_tone", "output_tone_gpt", "output_toxicity", "output_toxicity_luna", "output_toxicity_vision_luna", "output_toxicity_vision", "output_toxicity_audio", "prompt_injection", "prompt_injection_vision", "prompt_injection_audio", "prompt_injection_luna", "prompt_injection_vision_luna", "reasoning_coherence", "reasoning_coherence_vision", "reasoning_coherence_audio", "sql_efficiency", "sql_adherence", "sql_injection", "sql_correctness", "tool_error_rate", "tool_error_rate_luna", "tool_selection_quality", "tool_selection_quality_vision", "tool_selection_quality_audio", "tool_selection_quality_luna", "user_intent_change", "user_intent_change_vision", "user_intent_change_audio", "interruption_detection"]);

export const baseFinetunedScorerDB = z.object({id: z.string(), name: z.string(), lora_task_id: z.number().int(), lora_weights_path: z.string().nullable().optional(), prompt: z.string(), luna_input_type: lunaInputTypeEnum.nullable().optional(), luna_output_type: lunaOutputTypeEnum.nullable().optional(), class_name_to_vocab_ix: z.union([z.record(z.string(), z.array(z.number().int())), z.record(z.string(), z.number().int())]).nullable().optional(), executor: scorerName.nullable().optional()});

export const baseLuna3ScorerDB = z.object({instruction: z.string().min(1).max(10000), adapter_path: z.string().min(1).max(1024), class_name_to_vocab_ix: z.record(z.string(), z.array(z.number().int())), threshold: z.number().nullable().optional(), id: z.string()});

export const decisionChoice = z.object({label: z.string(), description: z.string().nullable().optional()});

export const decisionLevel = z.object({level: z.number().int().gte(0).lte(9), label: z.string(), description: z.string().nullable().optional()});

export const decisionBooleanCriteria = z.object({true: z.string(), false: z.string()});

export const decisionScorerDB = z.object({id: z.string(), organization_id: z.string(), created_by: z.string().nullable().optional(), question: z.string(), answer_options: z.union([z.array(z.string()), z.array(decisionChoice), z.array(decisionLevel), decisionBooleanCriteria]).nullable().optional(), created_at: z.string()});

export const baseScorerVersionDB = z.object({id: z.string(), version: z.number().int(), scorer_id: z.string(), generated_scorer: baseGeneratedScorerDB.nullable().optional(), registered_scorer: baseRegisteredScorerDB.nullable().optional(), finetuned_scorer: baseFinetunedScorerDB.nullable().optional(), luna3_scorer: baseLuna3ScorerDB.nullable().optional(), decision_scorer: decisionScorerDB.nullable().optional(), model_name: z.string().nullable().optional(), num_judges: z.number().int().nullable().optional(), cot_enabled: z.boolean().nullable().optional(), runtime: z.string().nullable().optional(), code_sha256: z.string().nullable().optional()});

export const modelType = z.enum(["slm", "llm", "code", "decision"]);

export const multimodalCapability = z.enum(["vision", "audio"]);

export const rollUpMethodDisplayOptions = z.enum(["average", "sum", "max", "min", "category_count", "percentage_true", "percentage_false"]);

export const numericRollUpMethod = z.enum(["average", "sum", "max", "min"]);

export const categoricalRollUpMethod = z.literal("category_count");

export const baseMetricRollUpConfigDB = z.object({roll_up_methods: z.union([z.array(numericRollUpMethod), z.array(categoricalRollUpMethod)])});

export const metricColor = z.enum(["red", "yellow", "green"]);

export const numericColorConstraintOutput = z.object({color: metricColor, operator: z.enum(["eq", "gt", "gte", "lt", "lte", "between"]), value: z.union([z.number(), z.array(z.number())])});

export const metricColorPickerNumeric = z.object({type: z.literal("numeric").optional(), constraints: z.array(numericColorConstraintOutput)});

export const booleanColorConstraintOutput = z.object({color: metricColor, operator: z.literal("eq"), value: z.boolean()});

export const metricColorPickerBoolean = z.object({type: z.literal("boolean").optional(), constraints: z.array(booleanColorConstraintOutput)});

export const categoricalColorConstraintOutput = z.object({color: metricColor, operator: z.enum(["eq", "one_of"]), value: z.union([z.string(), z.array(z.string())])});

export const metricColorPickerCategorical = z.object({type: z.literal("categorical").optional(), constraints: z.array(categoricalColorConstraintOutput)});

export const metricColorPickerMultiLabel = z.object({type: z.literal("multi_label").optional(), constraints: z.array(categoricalColorConstraintOutput)});

export const scorerScopeProjectRef = z.object({id: z.string(), name: z.string()});

export const scorerResponse = z.object({id: z.string(), permissions: z.array(permission).optional(), name: z.string(), label: z.string().nullable().optional(), scorer_type: scorerTypes, defaults: scorerDefaults.nullable().optional(), invocation: scorerInvocationConfig.nullable().optional(), latest_version: baseScorerVersionDB.nullable().optional(), model_type: modelType.nullable().optional(), ground_truth: z.boolean().nullable().optional(), default_version_id: z.string().nullable().optional(), default_version: baseScorerVersionDB.nullable().optional(), user_prompt: z.string().nullable().optional(), scoreable_node_types: z.array(z.string()).nullable().optional(), output_type: outputTypeEnum.nullable().optional(), input_type: inputTypeEnum.nullable().optional(), multimodal_capabilities: z.array(multimodalCapability).nullable().optional(), required_scorers: z.array(z.string()).nullable().optional(), required_metric_ids: z.array(z.string()).nullable().optional(), deprecated: z.boolean().nullable().optional(), roll_up_method: rollUpMethodDisplayOptions.nullable().optional(), roll_up_config: baseMetricRollUpConfigDB.nullable().optional(), tags: z.array(z.string()), included_fields: z.array(z.string()).optional(), description: z.string().nullable().optional(), created_by: z.string().nullable().optional(), created_at: z.string().nullable().optional(), updated_at: z.string().nullable().optional(), metric_color_picker_config: z.union([metricColorPickerNumeric, metricColorPickerBoolean, metricColorPickerCategorical, metricColorPickerMultiLabel]).nullable().optional(), color_threshold_config: metricColorPickerNumeric.nullable().optional(), metric_name: z.string().nullable().optional(), is_global: z.boolean().optional(), scope_projects: z.array(scorerScopeProjectRef).optional(), projects_used: z.array(scorerScopeProjectRef).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
};

/**
 * Get Scorer
 * 
 * GET /public/v2/scorers/{scorer_id}
 * 
 * Also accepts auth: ClassicAPIKeyHeader, OAuth2PasswordBearer, HTTPBasic
 */
export const getApiPublicV2ScorersScorerId = async (args: GetApiPublicV2ScorersScorerIdArgs, options?: GetApiPublicV2ScorersScorerIdOptions) => {
const {baseUrl = "https://api.galileo.ai", fetch: fetchFn = fetch, APIKeyHeader} = options ?? {}

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

for (const item of args.actions ?? []) query.append("actions", String(item))
if (APIKeyHeader !== undefined) headers.set("Splunk-AO-API-Key", APIKeyHeader)

const url = `${baseUrl.replace(/\/+$/, '')}/public/v2/scorers/${encodeURIComponent(String(args.scorer_id))}${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(scorerResponse, await res.json())
};