import {z} from 'zod'

export type GetApiSitesSiteIdConnectionsArgs = {cursor?: string | undefined, limit?: number | undefined};

export type GetApiSitesSiteIdConnectionsOptions = {baseUrl: string, basicAuth?: {username: string, password: string} | undefined, fetch?: typeof fetch | undefined};

export const vaultKeys = z.discriminatedUnion("type", [z.object({type: z.string(), secretName: z.string().max(100), field: z.string().max(128).optional()}), z.object({type: z.string(), secretName: z.string().max(256), vaultName: z.string().max(128)}), z.object({type: z.string(), query: z.string().max(100)}), z.object({type: z.string(), secretName: z.string().max(256)}), z.object({type: z.string(), enginePath: z.string().max(100), role: z.string().max(100), field: z.string()}), z.object({type: z.string(), enginePath: z.string().max(100), secretPath: z.string().max(100), field: z.string().max(128)})]);

export const parameterString = z.discriminatedUnion("type", [z.object({type: z.string(), value: z.string().min(1).max(4000)}), z.object({type: z.string(), key: vaultKeys})]);

export const parameterSecretString = z.discriminatedUnion("type", [z.object({type: z.string()}), z.object({type: z.string(), value: z.string().min(1).max(4000)}), z.object({type: z.string(), key: vaultKeys})]);

export const authAws = z.discriminatedUnion("type", [z.object({type: z.string()}), z.object({type: z.string(), awsAccessKeyId: parameterString, awsSecretKey: parameterSecretString})]);

export const parameterGeneric = z.discriminatedUnion("type", [z.object({type: z.string(), edgeArtifactId: z.string()}), z.object({type: z.string()}), z.object({type: z.string(), secretEdgeArtifactId: z.string().max(512)}), z.object({type: z.string(), value: z.string().min(1).max(4000)}), z.object({type: z.string(), key: vaultKeys}), z.object({type: z.string(), key: vaultKeys})]);

export const parameterGenericMap = z.record(z.string(), parameterGeneric);

export const connectionAws = z.object({type: z.string(), auth: authAws, parameters: parameterGenericMap.optional()});

export const authAzure = z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString, tenantId: parameterString});

export const connectionAzure = z.object({type: z.string(), usGovernmentCloudHost: z.boolean().optional(), auth: authAzure});

export const authDatabricks = z.discriminatedUnion("type", [z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString}), z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString, tenantId: parameterString}), z.object({type: z.string(), token: parameterSecretString})]);

export const connectionDatabricks = z.object({type: z.string(), workspaceUrl: parameterString, auth: authDatabricks});

export const authDbt = z.object({type: z.string(), tokenName: parameterString, tokenValue: parameterSecretString});

export const connectionDbt = z.object({type: z.string(), adminUrl: parameterString.optional(), metadataUrl: parameterString.optional(), auth: authDbt});

export const authGcp = z.discriminatedUnion("type", [z.object({type: z.string(), credentialsJson: parameterSecretString}), z.object({type: z.string(), tokenOrTokenUrl: parameterSecretString}), z.object({type: z.string()})]);

export const connectionGcp = z.object({type: z.string(), auth: authGcp, parameters: parameterGenericMap.optional()});

export const authGit = z.object({type: z.string(), username: parameterString.optional(), accessToken: parameterSecretString});

export const connectionGit = z.object({type: z.string(), repositoryUrl: parameterString, subfolder: parameterString.optional(), auth: authGit});

export const authHttp = z.discriminatedUnion("type", [z.object({type: z.string(), username: parameterString, password: parameterSecretString}), z.object({type: z.string()}), z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString, accessTokenUri: parameterString, scopes: parameterString.optional()})]);

export const connectionHttp = z.object({type: z.string(), host: parameterString, auth: authHttp.optional(), testConnectionPath: parameterString.optional()});

export const authIics = z.object({type: z.string(), username: parameterString, password: parameterSecretString});

export const connectionIics = z.object({type: z.string(), url: parameterString, auth: authIics});

export const jdbcDriver = z.object({type: z.string(), className: z.string().max(100), jar: z.string(), additionalClasspathFiles: z.array(z.string()).optional()});

export const authJdbc = z.discriminatedUnion("type", [z.object({type: z.string(), username: parameterString, password: parameterSecretString}), z.object({type: z.string()})]);

export const connectionJdbc = z.object({type: z.string(), driver: jdbcDriver, connectionString: parameterString, auth: authJdbc.optional(), parameters: parameterGenericMap.optional()});

export const connectionLocalStorage = z.object({type: z.string(), folder: z.string()});

export const authLooker = z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString});

export const connectionLooker = z.object({type: z.string(), url: parameterString, auth: authLooker});

export const authMatillion = z.discriminatedUnion("type", [z.object({type: z.string(), username: parameterString, password: parameterSecretString}), z.object({type: z.string(), token: parameterSecretString})]);

export const parameterEdgeArtifact = z.discriminatedUnion("type", [z.object({type: z.string(), edgeArtifactId: z.string()}), z.object({type: z.string(), key: vaultKeys})]);

export const connectionMatillion = z.object({type: z.string(), url: parameterString, auth: authMatillion, certFile: parameterEdgeArtifact.optional()});

export const authMicroStrategy = z.discriminatedUnion("type", [z.object({type: z.string(), username: parameterString, password: parameterSecretString}), z.object({type: z.string(), token: parameterSecretString})]);

export const connectionMicroStrategy = z.object({type: z.string(), url: parameterString, auth: authMicroStrategy});

export const authMlflow = z.discriminatedUnion("type", [z.object({type: z.string(), username: parameterString, password: parameterSecretString}), z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString, tokenUrl: parameterString})]);

export const connectionMlflow = z.object({type: z.string(), url: parameterString, auth: authMlflow});

export const authPowerBI = z.discriminatedUnion("type", [z.object({type: z.string(), applicationId: parameterString, username: parameterString, passwordSecretKey: parameterSecretString}), z.object({type: z.string(), applicationId: parameterString, clientSecret: parameterSecretString})]);

export const connectionPowerBI = z.object({type: z.string(), tenantDomain: parameterString, auth: authPowerBI, certFile: parameterEdgeArtifact.optional()});

export const authS3Compatible = z.object({type: z.string(), accessKeyId: parameterString, secretAccessKey: parameterSecretString});

export const connectionS3Compatible = z.object({type: z.string(), endpoint: parameterString, region: parameterString.optional(), auth: authS3Compatible});

export const authSapAICore = z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString, tokenUrl: parameterString});

export const connectionSapAICore = z.object({type: z.string(), url: parameterString, auth: authSapAICore});

export const authSapDatasphereCatalog = z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString, tokenUrl: parameterString});

export const authClientCredentials = z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString});

export const connectionSapDatasphereCatalog = z.object({type: z.string(), url: parameterString, datasphereCatalogAuth: authSapDatasphereCatalog, dataProductsAuth: authClientCredentials.optional()});

export const authSigma = z.object({type: z.string(), clientId: parameterString, clientSecret: parameterSecretString});

export const connectionSigma = z.object({type: z.string(), url: parameterString, tenantUrl: parameterString, auth: authSigma});

export const parameterSecretEdgeArtifact = z.discriminatedUnion("type", [z.object({type: z.string(), secretEdgeArtifactId: z.string().max(512)}), z.object({type: z.string(), key: vaultKeys})]);

export const authSnowflake = z.discriminatedUnion("type", [z.object({type: z.string(), username: parameterString, password: parameterSecretString}), z.object({type: z.string(), username: parameterString, privateKeyEdgeArtifact: parameterSecretEdgeArtifact, privateKeyPwd: parameterSecretString.optional()}), z.object({type: z.string(), programmaticAccessToken: parameterSecretString})]);

export const connectionSnowflake = z.object({type: z.string(), account: parameterString, auth: authSnowflake, role: parameterString.optional(), warehouse: parameterString.optional()});

export const authSsrs = z.object({type: z.string(), username: parameterString, password: parameterSecretString});

export const connectionSsrs = z.object({type: z.string(), url: parameterString, auth: authSsrs});

export const authTableau = z.discriminatedUnion("type", [z.object({type: z.string(), username: parameterString, password: parameterSecretString}), z.object({type: z.string(), tokenName: parameterString, tokenSecret: parameterSecretString})]);

export const connectionTableau = z.object({type: z.string(), url: parameterString, auth: authTableau, certFile: parameterEdgeArtifact.optional()});

export const authThoughtSpot = z.object({type: z.string(), username: parameterString, password: parameterSecretString});

export const connectionThoughtSpot = z.object({type: z.string(), url: parameterString, auth: authThoughtSpot});

export const connectionProperties = z.discriminatedUnion("type", [connectionAws, connectionAzure, connectionDatabricks, connectionDbt, connectionGcp, connectionGit, connectionHttp, connectionIics, connectionJdbc, connectionLocalStorage, connectionLooker, connectionMatillion, connectionMicroStrategy, connectionMlflow, connectionPowerBI, connectionS3Compatible, connectionSapAICore, connectionSapDatasphereCatalog, connectionSigma, connectionSnowflake, connectionSsrs, connectionTableau, connectionThoughtSpot]);

export const connectionResponse = z.object({id: z.string(), name: z.string(), description: z.string().optional(), edgeSiteId: z.string(), vaultId: z.string().optional(), createdOn: z.string(), lastModifiedOn: z.string(), testConnectionSupported: z.boolean(), properties: connectionProperties});

export const connectionListResponse = z.object({nextCursor: z.string().optional(), results: z.array(connectionResponse)});

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 site connections
 * 
 * GET /sites/{siteId}/connections
 * 
 * Also accepts auth: jwtAuth, oauth2, oauth2
 */
export const getApiSitesSiteIdConnections = async (args: GetApiSitesSiteIdConnectionsArgs, options: GetApiSitesSiteIdConnectionsOptions) => {
const {baseUrl, fetch: fetchFn = fetch, basicAuth} = options ?? {}

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

if (args.cursor != null) query.append("cursor", String(args.cursor))
if (args.limit != null) query.append("limit", String(args.limit))
if (basicAuth !== undefined) headers.set('authorization', `Basic ${btoa(`${basicAuth.username}:${basicAuth.password}`)}`)

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