import {z} from 'zod'

export type Metadatum = {key?: string | undefined, value?: string | undefined};

export type Metadata = Array<Metadatum>;

export type Instance = {host?: string | undefined, port?: number | undefined, metadata?: Metadata | undefined};

export type Instances = Array<Instance>;

export type CircuitBreakers = {max_connections?: number | undefined, max_pending_requests?: number | undefined, max_retries?: number | undefined, max_requests?: number | undefined};

export type OutlierDetection = {interval_msec?: number | undefined, base_ejection_time_msec?: number | undefined, max_ejection_percent?: number | undefined, consecutive_5xx?: number | undefined, enforcing_consecutive_5xx?: number | undefined, enforcing_success_rate?: number | undefined, success_rate_minimum_hosts?: number | undefined, success_rate_request_volume?: number | undefined, success_rate_stdev_factor?: number | undefined, consecutive_gateway_failure?: number | undefined, enforcing_consecutive_gateway_failure?: number | undefined};

export type HTTPHealthCheck = {host?: string | undefined, path?: string | undefined, service_name?: string | undefined, request_headers_to_add?: Metadata | undefined};

export type TCPHealthCheck = {send?: string | undefined, receive?: Array<string> | undefined};

export type HealthCheck = {timeout_msec: number, interval_msec: number, interval_jitter_msec?: number | undefined, unhealthy_threshold: number, healthy_threshold: number, reuse_connection?: boolean | undefined, no_traffic_interval_msec?: number | undefined, unhealthy_interval_msec?: number | undefined, unhealthy_edge_interval_msec?: number | undefined, healthy_edge_interval_msec?: number | undefined, health_checker: {http_health_check?: HTTPHealthCheck | undefined, tcp_health_check?: TCPHealthCheck | undefined}};

export type HealthChecks = Array<HealthCheck>;

export type Cluster = {zone_key: string, name: string, require_tls?: boolean | undefined, instances?: Instances | undefined, circuit_breakers?: CircuitBreakers | undefined, outlier_detection?: OutlierDetection | undefined, health_checks?: HealthChecks | undefined, cluster_key: string, checksum: string};

export type UpdateApiClusterClusterKeyArgs = {clusterKey: string, body: Cluster};

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

export const metadatum = z.object({key: z.string().optional(), value: z.string().optional()});

export const metadata = z.array(metadatum);

export const instance = z.object({host: z.string().optional(), port: z.number().int().optional(), metadata: metadata.optional()});

export const instances = z.array(instance);

export const circuitBreakers = z.object({max_connections: z.number().int().optional(), max_pending_requests: z.number().int().optional(), max_retries: z.number().int().optional(), max_requests: z.number().int().optional()});

export const outlierDetection = z.object({interval_msec: z.number().int().optional(), base_ejection_time_msec: z.number().int().optional(), max_ejection_percent: z.number().int().optional(), consecutive_5xx: z.number().int().optional(), enforcing_consecutive_5xx: z.number().int().optional(), enforcing_success_rate: z.number().int().optional(), success_rate_minimum_hosts: z.number().int().optional(), success_rate_request_volume: z.number().int().optional(), success_rate_stdev_factor: z.number().int().optional(), consecutive_gateway_failure: z.number().int().optional(), enforcing_consecutive_gateway_failure: z.number().int().optional()});

export const hTTPHealthCheck = z.object({host: z.string().optional(), path: z.string().optional(), service_name: z.string().optional(), request_headers_to_add: metadata.optional()});

export const tCPHealthCheck = z.object({send: z.string().optional(), receive: z.array(z.string()).optional()});

export const healthCheck = z.object({timeout_msec: z.number().int(), interval_msec: z.number().int(), interval_jitter_msec: z.number().int().optional(), unhealthy_threshold: z.number().int(), healthy_threshold: z.number().int(), reuse_connection: z.boolean().optional(), no_traffic_interval_msec: z.number().int().optional(), unhealthy_interval_msec: z.number().int().optional(), unhealthy_edge_interval_msec: z.number().int().optional(), healthy_edge_interval_msec: z.number().int().optional(), health_checker: z.object({http_health_check: hTTPHealthCheck.optional(), tcp_health_check: tCPHealthCheck.optional()})});

export const healthChecks = z.array(healthCheck);

export const cluster = z.object({zone_key: z.string(), name: z.string(), require_tls: z.boolean().optional(), instances: instances.optional(), circuit_breakers: circuitBreakers.optional(), outlier_detection: outlierDetection.optional(), health_checks: healthChecks.optional(), cluster_key: z.string(), checksum: z.string()});

export const clusterResult = z.object({result: cluster.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
};

/**
 * modify cluster
 * 
 * PUT /cluster/{clusterKey}
 */
export const updateApiClusterClusterKey = async (args: UpdateApiClusterClusterKeyArgs, options?: UpdateApiClusterClusterKeyOptions) => {
const {baseUrl = "https://api.turbinelabs.io/v1.0", fetch: fetchFn = fetch, apiKey} = options ?? {}

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

if (apiKey !== undefined) headers.set("Authorization", apiKey)

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

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