import {z} from 'zod'

export type StorageProvider = 'google_drive' | 's3' | 'snowflake' | 'sharepoint' | 'tigris' | 'postgresql' | 'instagram' | 'tiktok' | 'rss' | 'http_api' | 'box' | 'brightdata' | 'backblaze' | 'mux' | 'email' | 'supabase' | 'iconik' | 'gcs' | 'azure_blob' | 'rtsp';

export type StorageConnectionCreateRequest = {name: string, provider_type: StorageProvider, provider_config: {[key: string]: unknown}, description?: (string | null) | undefined, metadata?: ({[key: string]: unknown} | null) | undefined, write_enabled?: boolean | undefined, test_before_save?: boolean | undefined};

export type CreateApiV1OrganizationsConnectionsArgs = {body: StorageConnectionCreateRequest};

export type CreateApiV1OrganizationsConnectionsOptions = {baseUrl?: string | undefined, BearerAuth?: string | undefined, fetch?: typeof fetch | undefined};

export const storageProvider = z.enum(["google_drive", "s3", "snowflake", "sharepoint", "tigris", "postgresql", "instagram", "tiktok", "rss", "http_api", "box", "brightdata", "backblaze", "mux", "email", "supabase", "iconik", "gcs", "azure_blob", "rtsp"]);

export const googleDriveServiceAccountCredentials = z.object({type: z.literal("service_account").optional(), project_id: z.string(), private_key_id: z.string(), private_key: z.string(), client_email: z.string(), client_id: z.string()});

export const googleDriveOAuthCredentials = z.object({type: z.literal("oauth").optional(), client_id: z.string(), client_secret: z.string(), refresh_token: z.string()});

export const googleDriveConfig = z.object({provider_type: z.literal("google_drive").optional(), credentials: z.discriminatedUnion("type", [googleDriveServiceAccountCredentials, googleDriveOAuthCredentials]), shared_drive_id: z.string().nullable().optional(), impersonate_user: z.string().nullable().optional()});

export const s3AccessKeyCredentials = z.object({type: z.literal("access_key").optional(), access_key_id: z.string().min(1).max(128), secret_access_key: z.string().min(1), session_token: z.string().nullable().optional()});

export const s3RoleCredentials = z.object({type: z.literal("iam_role").optional(), role_arn: z.string(), external_id: z.string().min(8).max(128)});

export const s3Config = z.object({provider_type: z.literal("s3").optional(), credentials: z.discriminatedUnion("type", [s3AccessKeyCredentials, s3RoleCredentials]), region: z.string().optional(), endpoint_url: z.string().nullable().optional(), use_ssl: z.boolean().optional(), verify_ssl: z.boolean().optional()});

export const snowflakeKeyPairCredentials = z.object({type: z.literal("key_pair").optional(), username: z.string(), private_key: z.string(), private_key_passphrase: z.string().nullable().optional()});

export const snowflakeUsernamePasswordCredentials = z.object({type: z.literal("username_password").optional(), username: z.string(), password: z.string()});

export const snowflakeConfig = z.object({provider_type: z.literal("snowflake").optional(), credentials: z.discriminatedUnion("type", [snowflakeKeyPairCredentials, snowflakeUsernamePasswordCredentials]), account: z.string(), warehouse: z.string(), database: z.string().nullable().optional(), schema: z.string().nullable().optional(), role: z.string().nullable().optional(), incremental_column: z.string().nullable().optional(), primary_key_columns: z.array(z.string()).nullable().optional(), query_timeout_seconds: z.number().int().gte(30).lte(3600).optional(), fetch_size: z.number().int().gte(100).lte(10000).optional()});

export const sharePointClientCredentials = z.object({type: z.literal("client_credentials").optional(), tenant_id: z.string(), client_id: z.string(), client_secret: z.string()});

export const sharePointDelegatedCredentials = z.object({type: z.literal("delegated").optional(), tenant_id: z.string(), client_id: z.string(), client_secret: z.string(), refresh_token: z.string()});

export const sharePointConfig = z.object({provider_type: z.literal("sharepoint").optional(), credentials: z.discriminatedUnion("type", [sharePointClientCredentials, sharePointDelegatedCredentials]), site_id: z.string().nullable().optional(), drive_id: z.string().nullable().optional(), folder_path: z.string().nullable().optional()});

export const tigrisAccessKeyCredentials = z.object({type: z.literal("access_key").optional(), access_key_id: z.string().min(1), secret_access_key: z.string().min(1)});

export const tigrisConfig = z.object({provider_type: z.literal("tigris").optional(), credentials: tigrisAccessKeyCredentials, region: z.string().optional(), endpoint_url: z.string().optional()});

export const postgreSQLCredentials = z.object({type: z.literal("username_password").optional(), username: z.string(), password: z.string()});

export const postgreSQLConfig = z.object({provider_type: z.literal("postgresql").optional(), credentials: postgreSQLCredentials, host: z.string(), port: z.number().int().gte(1).lte(65535).optional(), database: z.string(), schema: z.string().nullable().optional(), ssl_mode: z.string().optional(), incremental_column: z.string().nullable().optional(), primary_key_columns: z.array(z.string()).nullable().optional(), query_timeout_seconds: z.number().int().gte(1).lte(3600).optional(), fetch_size: z.number().int().gte(100).lte(10000).optional()});

export const instagramOAuthCredentials = z.object({type: z.literal("oauth").optional(), client_id: z.string(), client_secret: z.string().nullable().optional(), access_token: z.string(), token_expires_at: z.string().nullable().optional(), instagram_user_id: z.string(), instagram_username: z.string().nullable().optional()});

export const instagramConfig = z.object({provider_type: z.literal("instagram").optional(), credentials: instagramOAuthCredentials, scopes: z.array(z.string()).optional(), business_account_id: z.string().nullable().optional()});

export const tikTokOAuthCredentials = z.object({type: z.literal("oauth").optional(), client_key: z.string(), client_secret: z.string(), access_token: z.string(), refresh_token: z.string().nullable().optional(), token_expires_at: z.string().nullable().optional(), open_id: z.string()});

export const tikTokConfig = z.object({provider_type: z.literal("tiktok").optional(), credentials: tikTokOAuthCredentials, scopes: z.array(z.string()).optional()});

export const rSSHttpHeaderCredentials = z.object({type: z.literal("http_headers").optional(), headers: z.record(z.string(), z.string()).optional()});

export const rSSConfig = z.object({provider_type: z.literal("rss").optional(), credentials: rSSHttpHeaderCredentials.nullable().optional(), user_agent: z.string().optional(), request_timeout: z.number().int().gte(5).lte(120).optional()});

export const hTTPAPIHeaderCredentials = z.object({type: z.literal("http_headers").optional(), headers: z.record(z.string(), z.string()).optional()});

export const hTTPAPIConfig = z.object({provider_type: z.literal("http_api").optional(), credentials: hTTPAPIHeaderCredentials.nullable().optional(), http_method: z.enum(["GET", "POST"]).optional(), request_body: z.record(z.string(), z.unknown()).nullable().optional(), items_path: z.string().optional(), item_id_field: z.string().optional(), item_modified_field: z.string().nullable().optional(), response_content_type: z.enum(["json", "jsonl"]).optional(), user_agent: z.string().optional(), request_timeout: z.number().int().gte(5).lte(120).optional()});

export const boxOAuthCredentials = z.object({type: z.literal("oauth").optional(), client_id: z.string(), client_secret: z.string(), access_token: z.string(), refresh_token: z.string().nullable().optional()});

export const boxCCGCredentials = z.object({type: z.literal("ccg").optional(), client_id: z.string(), client_secret: z.string(), enterprise_id: z.string().nullable().optional(), user_id: z.string().nullable().optional()});

export const boxJWTCredentials = z.object({type: z.literal("jwt").optional(), client_id: z.string(), client_secret: z.string(), enterprise_id: z.string(), jwt_key_id: z.string(), private_key: z.string(), private_key_passphrase: z.string().nullable().optional()});

export const boxConfig = z.object({provider_type: z.literal("box").optional(), credentials: z.discriminatedUnion("type", [boxOAuthCredentials, boxCCGCredentials, boxJWTCredentials]), folder_id: z.string().optional()});

export const brightDataCredentials = z.object({type: z.literal("api_token").optional(), api_token: z.string()});

export const brightDataConfig = z.object({provider_type: z.literal("brightdata").optional(), credentials: brightDataCredentials, customer_id: z.string().nullable().optional(), default_output_format: z.enum(["jsonl", "json", "csv", "ndjson"]).optional(), country: z.string().nullable().optional(), inputs: z.array(z.record(z.string(), z.unknown())).nullable().optional()});

export const backblazeCredentials = z.object({type: z.literal("application_key").optional(), key_id: z.string(), application_key: z.string()});

export const backblazeConfig = z.object({provider_type: z.literal("backblaze").optional(), credentials: backblazeCredentials});

export const muxCredentials = z.object({type: z.literal("access_token").optional(), access_token_id: z.string(), access_token_secret: z.string(), webhook_secret: z.string().nullable().optional()});

export const muxConfig = z.object({provider_type: z.literal("mux").optional(), credentials: muxCredentials});

export const iconikCredentials = z.object({type: z.literal("app_token").optional(), app_id: z.string(), auth_token: z.string(), webhook_secret: z.string().nullable().optional()});

export const iconikConfig = z.object({provider_type: z.literal("iconik").optional(), credentials: iconikCredentials, base_url: z.string().nullable().optional(), metadata_view_id: z.string().nullable().optional(), rate_limit_rps: z.number().nullable().optional(), rate_limit_redis_url: z.string().nullable().optional()});

export const emailCredentials = z.object({type: z.literal("webhook_secret").optional(), webhook_secret: z.string().optional()});

export const sharedOrganizationsConnectionsProviderConfigsEmailConfig = z.object({provider_type: z.literal("email").optional(), credentials: emailCredentials.optional(), inbound_address: z.string().nullable().optional(), allowed_senders: z.array(z.string()).optional(), store_raw_eml: z.boolean().optional()});

export const gCSServiceAccountKeyCredentials = z.object({type: z.literal("service_account").optional(), service_account_json: z.record(z.string(), z.unknown())});

export const gCSConfig = z.object({provider_type: z.literal("gcs").optional(), credentials: gCSServiceAccountKeyCredentials, bucket: z.string(), prefix: z.string().nullable().optional()});

export const azureStorageAccountKeyCredentials = z.object({type: z.literal("account_key").optional(), account_name: z.string().min(1), account_key: z.string().min(1)});

export const azureManagedIdentityCredentials = z.object({type: z.literal("managed_identity").optional(), client_id: z.string().nullable().optional()});

export const azureBlobConfig = z.object({provider_type: z.literal("azure_blob").optional(), credentials: z.discriminatedUnion("type", [azureStorageAccountKeyCredentials, azureManagedIdentityCredentials]), account_name: z.string().nullable().optional(), container: z.string(), prefix: z.string().nullable().optional()});

export const rTSPBasicCredentials = z.object({type: z.literal("basic").optional(), username: z.string().min(1), password: z.string().min(1)});

export const rTSPConfig = z.object({provider_type: z.literal("rtsp").optional(), url: z.string(), credentials: rTSPBasicCredentials.nullable().optional(), transport: z.enum(["tcp", "udp"]).optional(), segment_seconds: z.number().int().gte(5).lte(300).optional(), segments_per_run: z.number().int().gte(1).lte(20).optional(), connect_timeout_seconds: z.number().int().gte(5).lte(120).optional(), scene_change_threshold: z.number().int().gte(0).lte(64).nullable().optional(), gate_inference_name: z.string().nullable().optional(), gate_retriever_id: z.string().nullable().optional(), gate_retriever_min_score: z.number().gte(0).lte(1).nullable().optional(), gate_output_stage: z.string().nullable().optional(), gate_output_field: z.string().nullable().optional(), gate_output_op: z.enum(["gte", "lte", "gt", "lt", "eq"]).optional(), gate_output_threshold: z.number().nullable().optional(), gate_on_error: z.enum(["publish", "drop"]).optional(), gate_timeout_seconds: z.number().int().gte(1).lte(300).optional()});

export const taskStatusEnum = z.enum(["PENDING", "QUEUED", "IN_PROGRESS", "PROCESSING", "COMPLETED", "COMPLETED_WITH_ERRORS", "FAILED", "CANCELED", "INTERRUPTED", "UNKNOWN", "SKIPPED", "DRAFT", "ACTIVE", "ARCHIVED", "SUSPENDED", "DEACTIVATED"]);

export const storageConnectionModel = z.object({connection_id: z.string().optional(), internal_id: z.string(), provider_type: storageProvider, provider_config: z.union([googleDriveConfig, s3Config, snowflakeConfig, sharePointConfig, tigrisConfig, postgreSQLConfig, instagramConfig, tikTokConfig, rSSConfig, hTTPAPIConfig, boxConfig, brightDataConfig, backblazeConfig, muxConfig, iconikConfig, sharedOrganizationsConnectionsProviderConfigsEmailConfig, gCSConfig, azureBlobConfig, rTSPConfig, z.record(z.string(), z.unknown())]), write_enabled: z.boolean().optional(), name: z.string().min(1).max(100), description: z.string().max(500).nullable().optional(), status: taskStatusEnum.optional(), is_active: z.boolean().optional(), last_used_at: z.string().nullable().optional(), last_error: z.string().max(1000).nullable().optional(), consecutive_failures: z.number().int().gte(0).optional(), created_at: z.string().optional(), updated_at: z.string().optional(), created_by_user_id: z.string(), metadata: z.record(z.string(), z.unknown()).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
};

/**
 * Create Storage Connection
 * 
 * POST /v1/organizations/connections
 */
export const createApiV1OrganizationsConnections = async (args: CreateApiV1OrganizationsConnectionsArgs, options?: CreateApiV1OrganizationsConnectionsOptions) => {
const {baseUrl = "https://api.mixpeek.com", fetch: fetchFn = fetch, BearerAuth} = options ?? {}

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

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

const url = `${baseUrl.replace(/\/+$/, '')}/v1/organizations/connections${query.size > 0 ? `?${query}` : ''}`

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