import {z} from 'zod'

export type CloudVendorEnum = 'AWS' | 'SCW' | 'GCP' | 'DO' | 'AZURE' | 'OVH' | 'CIVO' | 'HETZNER' | 'ORACLE' | 'IBM' | 'ON_PREMISE';

export type CloudProviderEnum = 'AWS' | 'SCW' | 'GCP' | 'ON_PREMISE' | 'AZURE';

export type ClusterCloudProviderInfoRequest = {cloud_provider?: CloudProviderEnum | undefined, credentials?: ({id?: string | undefined, name?: string | undefined}) | undefined, region?: string | undefined};

export type KubernetesEnum = 'MANAGED' | 'SELF_MANAGED' | 'PARTIALLY_MANAGED';

export type ClusterFeatureAwsExistingVpc = {aws_vpc_eks_id: string, eks_subnets_zone_a_ids: Array<string>, eks_subnets_zone_b_ids: Array<string>, eks_subnets_zone_c_ids: Array<string>, documentdb_subnets_zone_a_ids?: (Array<string> | null) | undefined, documentdb_subnets_zone_b_ids?: (Array<string> | null) | undefined, documentdb_subnets_zone_c_ids?: (Array<string> | null) | undefined, elasticache_subnets_zone_a_ids?: (Array<string> | null) | undefined, elasticache_subnets_zone_b_ids?: (Array<string> | null) | undefined, elasticache_subnets_zone_c_ids?: (Array<string> | null) | undefined, rds_subnets_zone_a_ids?: (Array<string> | null) | undefined, rds_subnets_zone_b_ids?: (Array<string> | null) | undefined, rds_subnets_zone_c_ids?: (Array<string> | null) | undefined, eks_karpenter_fargate_subnets_zone_a_ids?: (Array<string> | null) | undefined, eks_karpenter_fargate_subnets_zone_b_ids?: (Array<string> | null) | undefined, eks_karpenter_fargate_subnets_zone_c_ids?: (Array<string> | null) | undefined};

export type ClusterFeatureGcpExistingVpc = {vpc_name: string, vpc_project_id?: (string | null) | undefined, subnetwork_name?: (string | null) | undefined, ip_range_services_name?: (string | null) | undefined, ip_range_pods_name?: (string | null) | undefined, additional_ip_range_pods_names?: Array<string> | undefined};

export type CpuArchitectureEnum = 'AMD64' | 'ARM64';

export type KarpenterNodePoolRequirementKey = 'InstanceFamily' | 'InstanceSize' | 'Arch' | 'SkuFamily' | 'SkuVersion';

export type KarpenterNodePoolRequirementOperator = 'In';

export type KarpenterNodePoolRequirement = {key: KarpenterNodePoolRequirementKey, operator: KarpenterNodePoolRequirementOperator, values: Array<string>};

export type WeekdayEnum = 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';

export type KarpenterNodePoolConsolidation = {enabled: boolean, days: Array<WeekdayEnum>, start_time: string, duration: string};

export type KarpenterNodePoolLimits = {enabled: boolean, max_cpu_in_vcpu: number, max_memory_in_gibibytes: number};

export type KarpenterStableNodePoolOverride = {consolidation?: KarpenterNodePoolConsolidation | undefined, limits?: KarpenterNodePoolLimits | undefined};

export type KarpenterDefaultNodePoolOverride = {limits?: KarpenterNodePoolLimits | undefined};

export type KarpenterGpuNodePoolOverride = {consolidation?: KarpenterNodePoolConsolidation | undefined, limits?: KarpenterNodePoolLimits | undefined, requirements?: Array<KarpenterNodePoolRequirement> | undefined};

export type KarpenterNodePool = {requirements: Array<KarpenterNodePoolRequirement>, stable_override?: KarpenterStableNodePoolOverride | undefined, default_override?: KarpenterDefaultNodePoolOverride | undefined, gpu_override?: KarpenterGpuNodePoolOverride | undefined};

export type ClusterFeatureKarpenterParameters = {spot_enabled: boolean, disk_size_in_gib: number, default_service_architecture: CpuArchitectureEnum, qovery_node_pools: KarpenterNodePool};

export type MetricsParameters = {enabled?: boolean | undefined, configuration?: ({kind?: 'MANAGED_BY_QOVERY' | undefined}) | undefined};

export type ClusterInfrastructureNginxChartParameters = {replica_count?: number | undefined, default_ssl_certificate?: string | undefined, publish_status_address?: string | undefined, annotation_metal_lb_load_balancer_ips?: string | undefined, annotation_external_dns_kubernetes_target?: string | undefined};

export type ClusterInfrastructureCertManagerChartParameters = {kubernetes_namespace?: string | undefined};

export type ClusterInfrastructureMetalLbChartParameters = {ip_address_pools?: Array<string> | undefined};

export type ClusterInfrastructureChartsParameters = {nginx_parameters?: ClusterInfrastructureNginxChartParameters | undefined, cert_manager_parameters?: ClusterInfrastructureCertManagerChartParameters | undefined, metal_lb_parameters?: ClusterInfrastructureMetalLbChartParameters | undefined};

export type ClusterRequest = {name: string, description?: string | undefined, region: string, cloud_provider: CloudVendorEnum, cloud_provider_credentials?: ClusterCloudProviderInfoRequest | undefined, min_running_nodes?: number | undefined, max_running_nodes?: number | undefined, disk_size?: number | undefined, instance_type?: string | undefined, kubernetes?: KubernetesEnum | undefined, production?: boolean | undefined, ssh_keys?: Array<string> | undefined, features?: (Array<{id?: string | undefined, value?: (string | boolean | ClusterFeatureAwsExistingVpc | ClusterFeatureGcpExistingVpc | ClusterFeatureKarpenterParameters | null) | undefined}>) | undefined, metrics_parameters?: MetricsParameters | undefined, infrastructure_charts_parameters?: ClusterInfrastructureChartsParameters | undefined};

export type UpdateApiOrganizationOrganizationIdClusterClusterIdArgs = {organizationId: string, clusterId: string, body: ClusterRequest};

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

export const referenceObject = z.object({id: z.string()});

export const cloudVendorEnum = z.enum(["AWS", "SCW", "GCP", "DO", "AZURE", "OVH", "CIVO", "HETZNER", "ORACLE", "IBM", "ON_PREMISE"]);

export const kubernetesEnum = z.enum(["MANAGED", "SELF_MANAGED", "PARTIALLY_MANAGED"]);

export const clusterStateEnum = z.enum(["BUILDING", "BUILD_ERROR", "CANCELED", "CANCELING", "DELETED", "DELETE_ERROR", "DELETE_QUEUED", "DELETING", "DEPLOYED", "DEPLOYING", "DEPLOYMENT_ERROR", "DEPLOYMENT_QUEUED", "DRY_RUN", "QUEUED", "READY", "STOPPED", "STOPPING", "STOP_ERROR", "STOP_QUEUED", "RESTART_QUEUED", "RESTARTING", "RESTARTED", "RESTART_ERROR", "INVALID_CREDENTIALS"]);

export const clusterFeatureResponseTypeEnum = z.enum(["STRING", "BOOLEAN", "AWS_USER_PROVIDED_NETWORK", "GCP_USER_PROVIDED_NETWORK", "KARPENTER"]);

export const clusterFeatureStringResponse = z.object({type: clusterFeatureResponseTypeEnum, value: z.string()});

export const clusterFeatureBooleanResponse = z.object({type: clusterFeatureResponseTypeEnum, value: z.boolean()});

export const clusterFeatureAwsExistingVpc = z.object({aws_vpc_eks_id: z.string(), eks_subnets_zone_a_ids: z.array(z.string()), eks_subnets_zone_b_ids: z.array(z.string()), eks_subnets_zone_c_ids: z.array(z.string()), documentdb_subnets_zone_a_ids: z.array(z.string()).nullable().optional(), documentdb_subnets_zone_b_ids: z.array(z.string()).nullable().optional(), documentdb_subnets_zone_c_ids: z.array(z.string()).nullable().optional(), elasticache_subnets_zone_a_ids: z.array(z.string()).nullable().optional(), elasticache_subnets_zone_b_ids: z.array(z.string()).nullable().optional(), elasticache_subnets_zone_c_ids: z.array(z.string()).nullable().optional(), rds_subnets_zone_a_ids: z.array(z.string()).nullable().optional(), rds_subnets_zone_b_ids: z.array(z.string()).nullable().optional(), rds_subnets_zone_c_ids: z.array(z.string()).nullable().optional(), eks_karpenter_fargate_subnets_zone_a_ids: z.array(z.string()).nullable().optional(), eks_karpenter_fargate_subnets_zone_b_ids: z.array(z.string()).nullable().optional(), eks_karpenter_fargate_subnets_zone_c_ids: z.array(z.string()).nullable().optional()});

export const clusterFeatureAwsExistingVpcResponse = z.object({type: clusterFeatureResponseTypeEnum, value: clusterFeatureAwsExistingVpc});

export const clusterFeatureGcpExistingVpc = z.object({vpc_name: z.string(), vpc_project_id: z.string().nullable().optional(), subnetwork_name: z.string().nullable().optional(), ip_range_services_name: z.string().nullable().optional(), ip_range_pods_name: z.string().nullable().optional(), additional_ip_range_pods_names: z.array(z.string()).optional()});

export const clusterFeatureGcpExistingVpcResponse = z.object({type: clusterFeatureResponseTypeEnum, value: clusterFeatureGcpExistingVpc});

export const cpuArchitectureEnum = z.enum(["AMD64", "ARM64"]);

export const karpenterNodePoolRequirementKey = z.enum(["InstanceFamily", "InstanceSize", "Arch", "SkuFamily", "SkuVersion"]);

export const karpenterNodePoolRequirementOperator = z.literal("In");

export const karpenterNodePoolRequirement = z.object({key: karpenterNodePoolRequirementKey, operator: karpenterNodePoolRequirementOperator, values: z.array(z.string())});

export const weekdayEnum = z.enum(["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY"]);

export const karpenterNodePoolConsolidation = z.object({enabled: z.boolean(), days: z.array(weekdayEnum), start_time: z.string(), duration: z.string()});

export const karpenterNodePoolLimits = z.object({enabled: z.boolean(), max_cpu_in_vcpu: z.number().int(), max_memory_in_gibibytes: z.number().int()});

export const karpenterStableNodePoolOverride = z.object({consolidation: karpenterNodePoolConsolidation.optional(), limits: karpenterNodePoolLimits.optional()});

export const karpenterDefaultNodePoolOverride = z.object({limits: karpenterNodePoolLimits.optional()});

export const karpenterGpuNodePoolOverride = z.object({consolidation: karpenterNodePoolConsolidation.optional(), limits: karpenterNodePoolLimits.optional(), requirements: z.array(karpenterNodePoolRequirement).optional()});

export const karpenterNodePool = z.object({requirements: z.array(karpenterNodePoolRequirement), stable_override: karpenterStableNodePoolOverride.optional(), default_override: karpenterDefaultNodePoolOverride.optional(), gpu_override: karpenterGpuNodePoolOverride.optional()});

export const clusterFeatureKarpenterParameters = z.object({spot_enabled: z.boolean(), disk_size_in_gib: z.number().int(), default_service_architecture: cpuArchitectureEnum, qovery_node_pools: karpenterNodePool});

export const clusterFeatureKarpenterParametersResponse = z.object({type: clusterFeatureResponseTypeEnum, value: clusterFeatureKarpenterParameters});

export const clusterFeatureResponse = z.object({id: z.string().optional(), title: z.string().optional(), description: z.string().nullable().optional(), cost_per_month_in_cents: z.number().int().nullable().optional(), cost_per_month: z.number().nullable().optional(), currency_code: z.string().nullable().optional(), is_cloud_provider_paying_feature: z.boolean().optional(), cloud_provider_feature_documentation: z.string().nullable().optional(), is_qovery_paying_feature: z.boolean().optional(), qovery_feature_documentation: z.string().nullable().optional(), value_type: z.literal("BOOLEAN").optional(), value_object: z.discriminatedUnion("type", [clusterFeatureStringResponse, clusterFeatureBooleanResponse, clusterFeatureAwsExistingVpcResponse, clusterFeatureGcpExistingVpcResponse, clusterFeatureKarpenterParametersResponse]).nullable().optional(), is_value_updatable: z.boolean().optional(), accepted_values: z.array(z.union([z.string(), z.boolean()])).optional()});

export const clusterDeploymentStatusEnum = z.enum(["NEVER_DEPLOYED", "OUT_OF_DATE", "UP_TO_DATE"]);

export const metricsParameters = z.object({enabled: z.boolean().optional(), configuration: z.object({kind: z.literal("MANAGED_BY_QOVERY").optional()}).optional()});

export const infrastructureOutputs = z.discriminatedUnion("kind", [z.object({kind: z.literal("AKS"), cluster_name: z.string(), cluster_oidc_issuer: z.string()}), z.object({kind: z.literal("EKS"), cluster_name: z.string(), cluster_arn: z.string(), cluster_oidc_issuer: z.string(), vpc_id: z.string()}), z.object({kind: z.literal("GKE"), cluster_name: z.string(), cluster_self_link: z.string()}), z.object({kind: z.literal("SCW_KAPSULE"), cluster_name: z.string()})]);

export const clusterInfrastructureNginxChartParameters = z.object({replica_count: z.number().int().gte(0).optional(), default_ssl_certificate: z.string().optional(), publish_status_address: z.string().optional(), annotation_metal_lb_load_balancer_ips: z.string().optional(), annotation_external_dns_kubernetes_target: z.string().optional()});

export const clusterInfrastructureCertManagerChartParameters = z.object({kubernetes_namespace: z.string().optional()});

export const clusterInfrastructureMetalLbChartParameters = z.object({ip_address_pools: z.array(z.string()).optional()});

export const clusterInfrastructureChartsParameters = z.object({nginx_parameters: clusterInfrastructureNginxChartParameters.optional(), cert_manager_parameters: clusterInfrastructureCertManagerChartParameters.optional(), metal_lb_parameters: clusterInfrastructureMetalLbChartParameters.optional()});

export const cluster = z.object({id: z.string(), created_at: z.string(), updated_at: z.string().optional(), organization: referenceObject, name: z.string(), description: z.string().optional(), region: z.string(), cloud_provider: cloudVendorEnum, min_running_nodes: z.number().int().optional(), max_running_nodes: z.number().int().optional(), disk_size: z.number().int().optional(), instance_type: z.string().optional(), kubernetes: kubernetesEnum.optional(), cpu: z.number().int().optional(), memory: z.number().int().optional(), estimated_cloud_provider_cost: z.number().int().optional(), status: clusterStateEnum.optional(), has_access: z.boolean().optional(), version: z.string().optional(), is_default: z.boolean().optional(), is_demo: z.boolean().optional(), production: z.boolean().optional(), ssh_keys: z.array(z.string()).optional(), features: z.array(clusterFeatureResponse).optional(), deployment_status: clusterDeploymentStatusEnum.optional(), metrics_parameters: metricsParameters.optional(), infrastructure_outputs: infrastructureOutputs.optional(), infrastructure_charts_parameters: clusterInfrastructureChartsParameters.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
};

/**
 * Edit a cluster
 * 
 * PUT /organization/{organizationId}/cluster/{clusterId}
 * 
 * Also accepts auth: bearerAuth
 */
export const updateApiOrganizationOrganizationIdClusterClusterId = async (args: UpdateApiOrganizationOrganizationIdClusterClusterIdArgs, options?: UpdateApiOrganizationOrganizationIdClusterClusterIdOptions) => {
const {baseUrl = "https://api.qovery.com", fetch: fetchFn = fetch, ApiKeyAuth} = 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("Authorization", ApiKeyAuth)

const url = `${baseUrl.replace(/\/+$/, '')}/organization/${encodeURIComponent(String(args.organizationId))}/cluster/${encodeURIComponent(String(args.clusterId))}${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(cluster, await res.json())
};