import {z} from 'zod'

export type SyncMode = 'initial_only' | 'continuous';

export type S3TagSource = {type?: 'tag' | undefined, key: string};

export type S3MetadataSource = {type?: 'metadata' | undefined, key: string};

export type FilenameRegexSource = {type?: 'filename_regex' | undefined, pattern: string, default?: (string | null) | undefined};

export type ColumnSource = {type?: 'column' | undefined, name: string};

export type DrivePropertySource = {type?: 'drive_property' | undefined, key: string};

export type FolderPathSource = {type?: 'folder_path' | undefined, segment?: (number | null) | undefined, full_path?: boolean | undefined};

export type FileSource = {type?: 'file' | undefined};

export type ConstantSource = {type?: 'constant' | undefined, value: string};

export type RSSFieldSource = {type?: 'rss_field' | undefined, field: string};

export type RTSPFieldSource = {type?: 'rtsp_field' | undefined, field: string};

export type FieldMappingEntry = {target_type?: 'field' | undefined, source: S3TagSource | S3MetadataSource | FilenameRegexSource | ColumnSource | DrivePropertySource | FolderPathSource | FileSource | ConstantSource | RSSFieldSource | RTSPFieldSource, transform?: (string | null) | undefined, required?: boolean | undefined};

export type BlobType = 'auto' | 'image' | 'video' | 'audio' | 'text' | 'pdf' | 'excel';

export type BlobMappingEntry = {target_type?: 'blob' | undefined, source: S3TagSource | S3MetadataSource | FilenameRegexSource | ColumnSource | DrivePropertySource | FolderPathSource | FileSource | ConstantSource | RSSFieldSource | RTSPFieldSource, blob_type?: BlobType | undefined, blob_property?: string | undefined, mime_type_override?: (string | null) | undefined};

export type SchemaMappingInput = {mappings: {[key: string]: FieldMappingEntry | BlobMappingEntry}};

export type IngestFilterAction = 'keep' | 'drop' | 'tag';

export type IngestFilterOnError = 'keep' | 'drop';

export type IngestFilter = {retriever_id: string, retriever_version?: (number | null) | undefined, action?: IngestFilterAction | undefined, on_error?: IngestFilterOnError | undefined, timeout_seconds?: number | undefined};

export type ReconcileSettings = {on_delete?: boolean | undefined, on_update?: boolean | undefined, on_filter_drift?: boolean | undefined, re_extract_on_update?: boolean | undefined, re_extract_fields?: (Array<string> | null) | undefined};

export type SyncCreateRequest = {connection_id: string, source_path?: (string | null) | undefined, sync_mode?: SyncMode | undefined, file_filters?: ({[key: string]: unknown} | null) | undefined, schema_mapping?: (SchemaMappingInput | null) | undefined, polling_interval_seconds?: number | undefined, batch_size?: number | undefined, skip_batch_submission?: boolean | undefined, batch_collection_ids?: (Array<string> | null) | undefined, ingest_filter?: (IngestFilter | null) | undefined, skip_duplicates?: boolean | undefined, reconcile?: (ReconcileSettings | null) | undefined, sync_from?: (string | null) | undefined, provider_filters?: ({[key: string]: unknown} | null) | undefined, description?: (string | null) | undefined, max_objects_per_run?: (number | null) | undefined, sync_concurrency?: (number | null) | undefined, metadata?: ({[key: string]: unknown} | null) | undefined};

export type CreateApiV1BucketsBucketIdSyncsArgs = {bucket_id: string, body: SyncCreateRequest};

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

export const metadataFilter = z.object({field: z.string(), operator: z.enum(["equals", "not_equals", "contains", "not_contains", "gt", "lt", "gte", "lte", "exists"]).optional(), value: z.union([z.string(), z.number().int(), z.number(), z.boolean()]).nullable().optional()});

export const fileFilters = z.object({include_patterns: z.array(z.string()).nullable().optional(), exclude_patterns: z.array(z.string()).nullable().optional(), min_size_bytes: z.number().int().gte(0).nullable().optional(), max_size_bytes: z.number().int().gte(0).nullable().optional(), modified_after: z.string().nullable().optional(), modified_before: z.string().nullable().optional(), mime_types: z.array(z.string()).nullable().optional(), metadata_filters: z.array(metadataFilter).nullable().optional()});

export const s3TagSource = z.object({type: z.literal("tag").optional(), key: z.string().min(1).max(128)});

export const s3MetadataSource = z.object({type: z.literal("metadata").optional(), key: z.string().min(1).max(1024)});

export const filenameRegexSource = z.object({type: z.literal("filename_regex").optional(), pattern: z.string().min(1), default: z.string().nullable().optional()});

export const columnSource = z.object({type: z.literal("column").optional(), name: z.string().min(1)});

export const drivePropertySource = z.object({type: z.literal("drive_property").optional(), key: z.string().min(1)});

export const folderPathSource = z.object({type: z.literal("folder_path").optional(), segment: z.number().int().nullable().optional(), full_path: z.boolean().optional()});

export const fileSource = z.object({type: z.literal("file").optional()});

export const constantSource = z.object({type: z.literal("constant").optional(), value: z.string()});

export const rSSFieldSource = z.object({type: z.literal("rss_field").optional(), field: z.string()});

export const rTSPFieldSource = z.object({type: z.literal("rtsp_field").optional(), field: z.string()});

export const fieldMappingEntry = z.object({target_type: z.literal("field").optional(), source: z.discriminatedUnion("type", [s3TagSource, s3MetadataSource, filenameRegexSource, columnSource, drivePropertySource, folderPathSource, fileSource, constantSource, rSSFieldSource, rTSPFieldSource]), transform: z.string().nullable().optional(), required: z.boolean().optional()});

export const blobType = z.enum(["auto", "image", "video", "audio", "text", "pdf", "excel"]);

export const blobMappingEntry = z.object({target_type: z.literal("blob").optional(), source: z.discriminatedUnion("type", [s3TagSource, s3MetadataSource, filenameRegexSource, columnSource, drivePropertySource, folderPathSource, fileSource, constantSource, rSSFieldSource, rTSPFieldSource]), blob_type: blobType.optional(), blob_property: z.string().min(1).optional(), mime_type_override: z.string().nullable().optional()});

export const schemaMappingOutput = z.object({mappings: z.record(z.string(), z.discriminatedUnion("target_type", [fieldMappingEntry, blobMappingEntry]))});

export const syncMode = z.enum(["initial_only", "continuous"]);

export const ingestFilterAction = z.enum(["keep", "drop", "tag"]);

export const ingestFilterOnError = z.enum(["keep", "drop"]);

export const ingestFilter = z.object({retriever_id: z.string().min(1), retriever_version: z.number().int().gte(1).nullable().optional(), action: ingestFilterAction.optional(), on_error: ingestFilterOnError.optional(), timeout_seconds: z.number().int().gte(1).lte(300).optional()});

export const reconcileSettings = z.object({on_delete: z.boolean().optional(), on_update: z.boolean().optional(), on_filter_drift: z.boolean().optional(), re_extract_on_update: z.boolean().optional(), re_extract_fields: z.array(z.string()).nullable().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 syncStatsModel = z.object({total_objects_synced: z.number().int().gte(0).optional(), total_objects_verified: z.number().int().gte(0).optional(), total_objects_failed: z.number().int().gte(0).optional(), total_objects_discovered: z.number().int().gte(0).optional(), total_objects_skipped: z.number().int().gte(0).optional(), total_bytes_synced: z.number().int().gte(0).optional(), total_duration_seconds: z.number().gte(0).optional(), total_runs_completed: z.number().int().gte(0).optional(), total_runs_failed: z.number().int().gte(0).optional(), peak_objects_per_min: z.number().gte(0).optional(), last_run_objects_synced: z.number().int().gte(0).optional(), last_run_objects_verified: z.number().int().gte(0).optional(), last_run_objects_failed: z.number().int().gte(0).optional(), last_run_objects_discovered: z.number().int().gte(0).optional(), last_run_objects_skipped: z.number().int().gte(0).optional(), last_run_bytes_synced: z.number().int().gte(0).optional(), last_run_duration_seconds: z.number().gte(0).optional(), last_run_throughput_objects_per_min: z.number().gte(0).optional(), last_run_throughput_mbps: z.number().gte(0).optional(), last_run_avg_object_size_bytes: z.number().int().gte(0).optional(), last_run_at: z.string().nullable().optional(), updated_at: z.string().nullable().optional()});

export const syncConfigurationModel = z.object({sync_config_id: z.string().optional(), bucket_id: z.string(), connection_id: z.string(), internal_id: z.string(), namespace_id: z.string(), source_path: z.string(), file_filters: fileFilters.nullable().optional(), schema_mapping: schemaMappingOutput.nullable().optional(), sync_mode: syncMode.optional(), polling_interval_seconds: z.number().int().gte(30).lte(86400).optional(), batch_size: z.number().int().gte(1).lte(100).optional(), create_object_on_confirm: z.boolean().optional(), skip_duplicates: z.boolean().optional(), skip_batch_submission: z.boolean().optional(), batch_collection_ids: z.array(z.string()).nullable().optional(), ingest_filter: ingestFilter.nullable().optional(), reconcile: reconcileSettings.optional(), status: taskStatusEnum.optional(), is_active: z.boolean().optional(), total_files_discovered: z.number().int().gte(0).optional(), total_files_synced: z.number().int().gte(0).optional(), total_files_failed: z.number().int().gte(0).optional(), total_bytes_synced: z.number().int().gte(0).optional(), stats: syncStatsModel.nullable().optional(), created_at: z.string().optional(), updated_at: z.string().optional(), last_sync_at: z.string().nullable().optional(), per_shard_last_sync_at: z.record(z.string(), z.string()).optional(), next_sync_at: z.string().nullable().optional(), created_by_user_id: z.string(), last_error: z.string().max(1000).nullable().optional(), consecutive_failures: z.number().int().gte(0).optional(), provider_filters: z.record(z.string(), z.unknown()).optional(), source_type: z.string().nullable().optional(), metadata: z.record(z.string(), z.unknown()).optional(), locked_by_worker_id: z.string().nullable().optional(), locked_at: z.string().nullable().optional(), lock_expires_at: z.string().nullable().optional(), pending_incremental_sync: z.boolean().optional(), pending_full_sync: z.boolean().optional(), paused: z.boolean().optional(), pause_reason: z.string().nullable().optional(), paused_at: z.string().nullable().optional(), paused_by_user_id: z.string().nullable().optional(), description: z.string().nullable().optional(), max_objects_per_run: z.number().int().gte(1).optional(), max_batch_chunk_size: z.number().int().gte(1).lte(1000).optional(), batch_chunk_size: z.number().int().gte(1).lte(1000).optional(), sync_concurrency: z.number().int().gte(1).lte(100).nullable().optional(), current_sync_run_id: z.string().nullable().optional(), sync_run_counter: z.number().int().gte(0).optional(), batch_ids: z.array(z.string()).optional(), task_ids: z.array(z.string()).optional(), batches_created: z.number().int().gte(0).optional(), resume_enabled: z.boolean().optional(), resume_cursor: z.string().nullable().optional(), resume_last_primary_key: z.string().nullable().optional(), resume_objects_processed: z.number().int().gte(0).optional(), resume_checkpoint_frequency: z.number().int().gte(100).lte(10000).optional(), current_cursor: z.string().nullable().optional(), sync_checkpoints: z.record(z.string(), z.record(z.string(), z.unknown())).optional(), schedule: z.record(z.string(), z.unknown()).nullable().optional(), sync_progress: z.record(z.string(), z.unknown()).optional(), locked: z.boolean()});

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 Sync Configuration
 * 
 * POST /v1/buckets/{bucket_id}/syncs
 */
export const createApiV1BucketsBucketIdSyncs = async (args: CreateApiV1BucketsBucketIdSyncsArgs, options?: CreateApiV1BucketsBucketIdSyncsOptions) => {
const {baseUrl = "https://api.mixpeek.com", fetch: fetchFn = fetch, BearerAuth, NamespaceHeader} = 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}`)
if (NamespaceHeader !== undefined) headers.set("X-Namespace", NamespaceHeader)

const url = `${baseUrl.replace(/\/+$/, '')}/v1/buckets/${encodeURIComponent(String(args.bucket_id))}/syncs${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(syncConfigurationModel, await res.json())
};