import {z} from 'zod'

export type AiGatewayNullableRoutingRuleTierOrdering = 'configured' | 'weighted_affinity' | null;

export type AiGatewayRoutingReasoningLevel = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null;

export type AiGatewayRoutingRuleTargetType = 'model' | 'routing-rule';

export type AiGatewayRoutingRuleTargetRequest = {id?: number | undefined, model?: string | undefined, model_id?: number | undefined, provider?: string | undefined, reasoning_level?: AiGatewayRoutingReasoningLevel | undefined, slug?: string | undefined, type: AiGatewayRoutingRuleTargetType, weight?: (number | null) | undefined};

export type AiGatewayRoutingRuleTierRequest = {ordering?: AiGatewayNullableRoutingRuleTierOrdering | undefined, targets: Array<AiGatewayRoutingRuleTargetRequest>};

export type AiGatewayRoutingRuleCreateAttributes = {slug: string, tiers: Array<AiGatewayRoutingRuleTierRequest>};

export type AiGatewayRoutingRuleType = 'routing-rules';

export type AiGatewayRoutingRuleCreateData = {attributes: AiGatewayRoutingRuleCreateAttributes, type: AiGatewayRoutingRuleType};

export type AiGatewayRoutingRuleCreateRequest = {data: AiGatewayRoutingRuleCreateData};

export type CreateApiApiV2RoutingRulesArgs = {body: AiGatewayRoutingRuleCreateRequest};

export type CreateApiApiV2RoutingRulesOptions = {baseUrl?: string | undefined, apiKeyAuth?: string | undefined, appKeyAuth?: string | undefined, fetch?: typeof fetch | undefined};

export const aiGatewayRoutingRuleTierOrdering = z.enum(["configured", "weighted_affinity"]);

export const aiGatewayRoutingRuleTierOrderingIssue = z.enum(["mixed", "unknown"]);

export const aiGatewayRoutingReasoningLevel = z.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]).nullable();

export const aiGatewayRoutingRuleTargetType = z.enum(["model", "routing-rule"]);

export const aiGatewayRoutingRuleTarget = z.object({id: z.number().int().gte(1).optional(), model: z.string().optional(), model_id: z.number().int().gte(1).optional(), provider: z.string().optional(), reasoning_level: aiGatewayRoutingReasoningLevel.optional(), slug: z.string().optional(), type: aiGatewayRoutingRuleTargetType, weight: z.number().int().gte(1).lte(10000).optional()});

export const aiGatewayRoutingRuleTier = z.object({ordering: aiGatewayRoutingRuleTierOrdering, ordering_issue: aiGatewayRoutingRuleTierOrderingIssue.optional(), targets: z.array(aiGatewayRoutingRuleTarget)});

export const aiGatewayRoutingRuleAttributes = z.object({created_at: z.string(), route_id: z.number().int().optional(), tiers: z.array(aiGatewayRoutingRuleTier), updated_at: z.string()});

export const aiGatewayRoutingRuleType = z.literal("routing-rules");

export const aiGatewayRoutingRuleResource = z.object({attributes: aiGatewayRoutingRuleAttributes, id: z.string(), type: aiGatewayRoutingRuleType});

export const aiGatewayRoutingRuleResponse = z.object({data: aiGatewayRoutingRuleResource});

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

/**
 * Create an AI Gateway routing rule
 * 
 * POST /api/v2/routing-rules
 * 
 * Also accepts auth: AuthZ
 */
export const createApiApiV2RoutingRules = async (args: CreateApiApiV2RoutingRulesArgs, options?: CreateApiApiV2RoutingRulesOptions) => {
const {baseUrl = "https://api.datadoghq.com", fetch: fetchFn = fetch, apiKeyAuth, appKeyAuth} = options ?? {}

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

if (apiKeyAuth !== undefined) headers.set("DD-API-KEY", apiKeyAuth)
if (appKeyAuth !== undefined) headers.set("DD-APPLICATION-KEY", appKeyAuth)

const url = `${baseUrl.replace(/\/+$/, '')}/api/v2/routing-rules${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(aiGatewayRoutingRuleResponse, await res.json())
};