import {z} from 'zod'

export type GetApiV1ProjectsProjectsIdLocationsLocationsIdEnvironmentsEnvironmentsIdArgs = {projectsId: string, locationsId: string, environmentsId: string};

export type GetApiV1ProjectsProjectsIdLocationsLocationsIdEnvironmentsEnvironmentsIdOptions = {baseUrl?: string | undefined, Oauth2?: string | undefined, Oauth2c?: string | undefined, fetch?: typeof fetch | undefined};

export const airflowMetadataRetentionPolicyConfig = z.object({retentionDays: z.number().int().optional(), retentionMode: z.enum(["RETENTION_MODE_UNSPECIFIED", "RETENTION_MODE_ENABLED", "RETENTION_MODE_DISABLED"]).optional()});

export const taskLogsRetentionConfig = z.object({storageMode: z.enum(["TASK_LOGS_STORAGE_MODE_UNSPECIFIED", "CLOUD_LOGGING_AND_CLOUD_STORAGE", "CLOUD_LOGGING_ONLY"]).optional()});

export const dataRetentionConfig = z.object({airflowMetadataRetentionConfig: airflowMetadataRetentionPolicyConfig.optional(), taskLogsRetentionConfig: taskLogsRetentionConfig.optional()});

export const databaseConfig = z.object({machineType: z.string().optional(), zone: z.string().optional()});

export const encryptionConfig = z.object({kmsKeyName: z.string().optional()});

export const maintenanceWindow = z.object({endTime: z.string().optional(), recurrence: z.string().optional(), startTime: z.string().optional()});

export const cidrBlock = z.object({cidrBlock: z.string().optional(), displayName: z.string().optional()});

export const masterAuthorizedNetworksConfig = z.object({cidrBlocks: z.array(cidrBlock).optional(), enabled: z.boolean().optional()});

export const iPAllocationPolicy = z.object({clusterIpv4CidrBlock: z.string().optional(), clusterSecondaryRangeName: z.string().optional(), servicesIpv4CidrBlock: z.string().optional(), servicesSecondaryRangeName: z.string().optional(), useIpAliases: z.boolean().optional()});

export const nodeConfig = z.object({composerInternalIpv4CidrBlock: z.string().optional(), composerNetworkAttachment: z.string().optional(), diskSizeGb: z.number().int().optional(), enableIpMasqAgent: z.boolean().optional(), ipAllocationPolicy: iPAllocationPolicy.optional(), location: z.string().optional(), machineType: z.string().optional(), network: z.string().optional(), oauthScopes: z.array(z.string()).optional(), serviceAccount: z.string().optional(), subnetwork: z.string().optional(), tags: z.array(z.string()).optional()});

export const networkingConfig = z.object({connectionType: z.enum(["CONNECTION_TYPE_UNSPECIFIED", "VPC_PEERING", "PRIVATE_SERVICE_CONNECT"]).optional()});

export const privateClusterConfig = z.object({enablePrivateEndpoint: z.boolean().optional(), masterIpv4CidrBlock: z.string().optional(), masterIpv4ReservedRange: z.string().optional()});

export const privateEnvironmentConfig = z.object({cloudComposerConnectionSubnetwork: z.string().optional(), cloudComposerNetworkIpv4CidrBlock: z.string().optional(), cloudComposerNetworkIpv4ReservedRange: z.string().optional(), cloudSqlIpv4CidrBlock: z.string().optional(), enablePrivateBuildsOnly: z.boolean().optional(), enablePrivateEnvironment: z.boolean().optional(), enablePrivatelyUsedPublicIps: z.boolean().optional(), networkingConfig: networkingConfig.optional(), networkingType: z.enum(["NETWORKING_TYPE_UNSPECIFIED", "PRIVATE", "PUBLIC"]).optional(), privateClusterConfig: privateClusterConfig.optional(), webServerIpv4CidrBlock: z.string().optional(), webServerIpv4ReservedRange: z.string().optional()});

export const scheduledSnapshotsConfig = z.object({enabled: z.boolean().optional(), snapshotCreationSchedule: z.string().optional(), snapshotLocation: z.string().optional(), timeZone: z.string().optional()});

export const recoveryConfig = z.object({scheduledSnapshotsConfig: scheduledSnapshotsConfig.optional()});

export const cloudDataLineageIntegration = z.object({enabled: z.boolean().optional()});

export const imageVersionRollbackTarget = z.object({imageVersion: z.string().optional(), lastActiveTime: z.string().optional()});

export const softwareConfig = z.object({airflowConfigOverrides: z.record(z.string(), z.string()).optional(), auditLogsReplicationMode: z.enum(["AUDIT_LOGS_REPLICATION_MODE_UNSPECIFIED", "AUDIT_LOGS_REPLICATION_DISABLED", "AUDIT_LOGS_REPLICATION_ENABLED"]).optional(), cloudDataLineageIntegration: cloudDataLineageIntegration.optional(), envVariables: z.record(z.string(), z.string()).optional(), imageVersion: z.string().optional(), imageVersionRollbackTargets: z.array(imageVersionRollbackTarget).optional(), pypiPackages: z.record(z.string(), z.string()).optional(), pythonVersion: z.string().optional(), schedulerCount: z.number().int().optional(), webServerPluginsMode: z.enum(["WEB_SERVER_PLUGINS_MODE_UNSPECIFIED", "PLUGINS_DISABLED", "PLUGINS_ENABLED"]).optional()});

export const webServerConfig = z.object({machineType: z.string().optional()});

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

export const webServerNetworkAccessControl = z.object({allowedIpRanges: z.array(allowedIpRange).optional()});

export const dagProcessorResource = z.object({count: z.number().int().optional(), cpu: z.number().optional(), memoryGb: z.number().optional(), storageGb: z.number().optional()});

export const schedulerResource = z.object({count: z.number().int().optional(), cpu: z.number().optional(), memoryGb: z.number().optional(), storageGb: z.number().optional()});

export const triggererResource = z.object({count: z.number().int().optional(), cpu: z.number().optional(), memoryGb: z.number().optional()});

export const webServerResource = z.object({cpu: z.number().optional(), memoryGb: z.number().optional(), storageGb: z.number().optional()});

export const workerResource = z.object({cpu: z.number().optional(), maxCount: z.number().int().optional(), memoryGb: z.number().optional(), minCount: z.number().int().optional(), storageGb: z.number().optional()});

export const workloadsConfig = z.object({dagProcessor: dagProcessorResource.optional(), scheduler: schedulerResource.optional(), triggerer: triggererResource.optional(), webServer: webServerResource.optional(), worker: workerResource.optional()});

export const environmentConfig = z.object({airflowByoidUri: z.string().optional(), airflowUri: z.string().optional(), dagGcsPrefix: z.string().optional(), dataRetentionConfig: dataRetentionConfig.optional(), databaseConfig: databaseConfig.optional(), encryptionConfig: encryptionConfig.optional(), environmentSize: z.enum(["ENVIRONMENT_SIZE_UNSPECIFIED", "ENVIRONMENT_SIZE_SMALL", "ENVIRONMENT_SIZE_MEDIUM", "ENVIRONMENT_SIZE_LARGE", "ENVIRONMENT_SIZE_EXTRA_LARGE", "ENVIRONMENT_SIZE_X_EXTRA_LARGE"]).optional(), gkeCluster: z.string().optional(), maintenanceWindow: maintenanceWindow.optional(), masterAuthorizedNetworksConfig: masterAuthorizedNetworksConfig.optional(), nodeConfig: nodeConfig.optional(), nodeCount: z.number().int().optional(), privateEnvironmentConfig: privateEnvironmentConfig.optional(), recoveryConfig: recoveryConfig.optional(), resilienceMode: z.enum(["RESILIENCE_MODE_UNSPECIFIED", "HIGH_RESILIENCE"]).optional(), softwareConfig: softwareConfig.optional(), webServerConfig: webServerConfig.optional(), webServerNetworkAccessControl: webServerNetworkAccessControl.optional(), workloadsConfig: workloadsConfig.optional()});

export const storageConfig = z.object({bucket: z.string().optional()});

export const environment = z.object({config: environmentConfig.optional(), createTime: z.string().optional(), labels: z.record(z.string(), z.string()).optional(), mode: z.enum(["MODE_UNSPECIFIED", "DEVELOPMENT"]).optional(), name: z.string().optional(), satisfiesPzi: z.boolean().optional(), satisfiesPzs: z.boolean().optional(), state: z.enum(["STATE_UNSPECIFIED", "CREATING", "RUNNING", "UPDATING", "HIBERNATED", "DELETING", "ERROR"]).optional(), storageConfig: storageConfig.optional(), updateTime: z.string().optional(), uuid: z.string().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 an existing environment.
 * 
 * GET /v1/projects/{projectsId}/locations/{locationsId}/environments/{environmentsId}
 * 
 * Also accepts auth: Oauth2 + Oauth2c, Oauth2 + Oauth2c
 */
export const getApiV1ProjectsProjectsIdLocationsLocationsIdEnvironmentsEnvironmentsId = async (args: GetApiV1ProjectsProjectsIdLocationsLocationsIdEnvironmentsEnvironmentsIdArgs, options?: GetApiV1ProjectsProjectsIdLocationsLocationsIdEnvironmentsEnvironmentsIdOptions) => {
const {baseUrl = "https://composer.googleapis.com", fetch: fetchFn = fetch, Oauth2, Oauth2c} = options ?? {}

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

if (Oauth2 !== undefined) headers.set('authorization', `Bearer ${Oauth2}`)
if (Oauth2c !== undefined) headers.set('authorization', `Bearer ${Oauth2c}`)

const url = `${baseUrl.replace(/\/+$/, '')}/v1/projects/${encodeURIComponent(String(args.projectsId))}/locations/${encodeURIComponent(String(args.locationsId))}/environments/${encodeURIComponent(String(args.environmentsId))}${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(environment, await res.json())
};