import {z} from 'zod'

export type GetApiOrganizationOrganizationIdClusterArgs = {organizationId: string};

export type GetApiOrganizationOrganizationIdClusterOptions = {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 clusterResponseList = z.object({results: z.array(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
};

/**
 * List organization clusters
 * 
 * GET /organization/{organizationId}/cluster
 * 
 * Also accepts auth: bearerAuth
 */
export const getApiOrganizationOrganizationIdCluster = async (args: GetApiOrganizationOrganizationIdClusterArgs, options?: GetApiOrganizationOrganizationIdClusterOptions) => {
const {baseUrl = "https://api.qovery.com", fetch: fetchFn = fetch, ApiKeyAuth} = options ?? {}

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

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

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