/**
 * Electric SQL client setup for ElectricSQL 1.x with PGlite
 * 
 * This uses the new ElectricSQL 1.x architecture:
 * - PGlite: In-browser PostgreSQL database (local storage)
 * - @electric-sql/pglite-sync: Sync plugin to sync Electric shapes into PGlite
 * - @electric-sql/client: HTTP client for subscribing to shapes
 */

import { PGlite } from '@electric-sql/pglite'
import { electricSync } from '@electric-sql/pglite-sync'
import { live } from '@electric-sql/pglite/live'

// Types
export interface ElectricClient {
	db: PGlite
	syncShape: (options: SyncShapeOptions) => Promise<SyncHandle>
}

export interface SyncShapeOptions {
	table: string
	where?: string
	columns?: string[]
	primaryKey?: string[]
}

export interface SyncHandle {
	unsubscribe: () => void
	readonly isUpToDate: boolean
	// The stream property contains the ShapeStreamInterface from pglite-sync
	stream?: unknown
	// Promise that resolves when initial sync is complete
	initialSyncPromise?: Promise<void>
}

// Singleton instance
let electricClient: ElectricClient | null = null
let isInitializing = false
let initPromise: Promise<ElectricClient> | null = null

// Version for sync state - increment this to force fresh sync when Electric config changes
// Incremented to v4 to fix sync completion issues
const SYNC_VERSION = 4

// Get Electric URL from environment
function getElectricUrl(): string {
	if (typeof window !== 'undefined') {
		return process.env.NEXT_PUBLIC_ELECTRIC_URL || 'http://localhost:5133'
	}
	return 'http://localhost:5133'
}

/**
 * Initialize the Electric SQL client with PGlite and sync plugin
 */
export async function initElectric(): Promise<ElectricClient> {
	if (electricClient) {
		return electricClient
	}

	if (isInitializing && initPromise) {
		return initPromise
	}

	isInitializing = true
	initPromise = (async () => {
		try {
			// Create PGlite instance with Electric sync plugin and live queries
			// Include version in database name to force fresh sync when Electric config changes
			const db = await PGlite.create({
				dataDir: `idb://surfsense-notifications-v${SYNC_VERSION}`,
				relaxedDurability: true,
				extensions: {
					// Enable debug mode in electricSync to see detailed sync logs
					electric: electricSync({ debug: true }),
					live, // Enable live queries for real-time updates
				},
			})

			// Create the notifications table schema in PGlite
			// This matches the backend schema
			await db.exec(`
				CREATE TABLE IF NOT EXISTS notifications (
					id INTEGER PRIMARY KEY,
					user_id TEXT NOT NULL,
					search_space_id INTEGER,
					type TEXT NOT NULL,
					title TEXT NOT NULL,
					message TEXT NOT NULL,
					read BOOLEAN NOT NULL DEFAULT FALSE,
					metadata JSONB DEFAULT '{}',
					created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
					updated_at TIMESTAMPTZ
				);
				
				CREATE INDEX IF NOT EXISTS idx_notifications_user_id ON notifications(user_id);
				CREATE INDEX IF NOT EXISTS idx_notifications_read ON notifications(read);
			`)

			// Create the search_source_connectors table schema in PGlite
			// This matches the backend schema
			await db.exec(`
				CREATE TABLE IF NOT EXISTS search_source_connectors (
					id INTEGER PRIMARY KEY,
					search_space_id INTEGER NOT NULL,
					user_id TEXT NOT NULL,
					connector_type TEXT NOT NULL,
					name TEXT NOT NULL,
					is_indexable BOOLEAN NOT NULL DEFAULT FALSE,
					last_indexed_at TIMESTAMPTZ,
					config JSONB DEFAULT '{}',
					periodic_indexing_enabled BOOLEAN NOT NULL DEFAULT FALSE,
					indexing_frequency_minutes INTEGER,
					next_scheduled_at TIMESTAMPTZ,
					created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
				);
				
				CREATE INDEX IF NOT EXISTS idx_connectors_search_space_id ON search_source_connectors(search_space_id);
				CREATE INDEX IF NOT EXISTS idx_connectors_type ON search_source_connectors(connector_type);
				CREATE INDEX IF NOT EXISTS idx_connectors_user_id ON search_source_connectors(user_id);
			`)

			// Create the documents table schema in PGlite
			// Only sync minimal fields needed for type counts: id, document_type, search_space_id
			await db.exec(`
				CREATE TABLE IF NOT EXISTS documents (
					id INTEGER PRIMARY KEY,
					search_space_id INTEGER NOT NULL,
					document_type TEXT NOT NULL,
					created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
				);
				
				CREATE INDEX IF NOT EXISTS idx_documents_search_space_id ON documents(search_space_id);
				CREATE INDEX IF NOT EXISTS idx_documents_type ON documents(document_type);
				CREATE INDEX IF NOT EXISTS idx_documents_search_space_type ON documents(search_space_id, document_type);
			`)

			const electricUrl = getElectricUrl()

			// Create the client wrapper
			electricClient = {
				db,
				syncShape: async (options: SyncShapeOptions): Promise<SyncHandle> => {
					const { table, where, columns, primaryKey = ['id'] } = options

				// Build params for the shape request
				// Electric SQL expects params as URL query parameters
				const params: Record<string, string> = { table }
				
				// Validate and fix WHERE clause to ensure string literals are properly quoted
				let validatedWhere = where
				if (where) {
					// Check if where uses positional parameters
					if (where.includes('$1')) {
						// Extract the value from the where clause if it's embedded
						// For now, we'll use the where clause as-is and let Electric handle it
						params.where = where
						validatedWhere = where
					} else {
						// Validate that string literals are properly quoted
						// Count single quotes - should be even (pairs) for properly quoted strings
						const singleQuoteCount = (where.match(/'/g) || []).length
						
						if (singleQuoteCount % 2 !== 0) {
							// Odd number of quotes means unterminated string literal
							console.warn('Where clause has unmatched quotes, fixing:', where)
							// Add closing quote at the end
							validatedWhere = `${where}'`
							params.where = validatedWhere
						} else {
							// Use the where clause directly (already formatted)
							params.where = where
							validatedWhere = where
						}
					}
				}
				
				if (columns) params.columns = columns.join(',')

					console.log('Syncing shape with params:', params)
					console.log('Electric URL:', `${electricUrl}/v1/shape`)
					console.log('Where clause:', where, 'Validated:', validatedWhere)

					try {
						// Debug: Test Electric SQL connection directly first
						// Use validatedWhere to ensure proper URL encoding
						const testUrl = `${electricUrl}/v1/shape?table=${table}&offset=-1${validatedWhere ? `&where=${encodeURIComponent(validatedWhere)}` : ''}`
						console.log('Testing Electric SQL directly:', testUrl)
						try {
							const testResponse = await fetch(testUrl)
							const testHeaders = {
								handle: testResponse.headers.get('electric-handle'),
								offset: testResponse.headers.get('electric-offset'),
								upToDate: testResponse.headers.get('electric-up-to-date'),
							}
							console.log('Direct Electric SQL response headers:', testHeaders)
							const testData = await testResponse.json()
							console.log('Direct Electric SQL data count:', Array.isArray(testData) ? testData.length : 'not array', testData)
						} catch (testErr) {
							console.error('Direct Electric SQL test failed:', testErr)
						}

						// Use PGlite's electric sync plugin to sync the shape
					// According to Electric SQL docs, the shape config uses params for table, where, columns
					// Note: mapColumns is OPTIONAL per pglite-sync types.ts
					
					// Create a promise that resolves when initial sync is complete
					// Using recommended approach: check isUpToDate immediately, watch stream, shorter timeout
					// IMPORTANT: We don't unsubscribe from the stream - it must stay active for real-time updates
					let resolveInitialSync: () => void
					let rejectInitialSync: (error: Error) => void
					let syncResolved = false
					
					const initialSyncPromise = new Promise<void>((resolve, reject) => {
						resolveInitialSync = () => {
							if (!syncResolved) {
								syncResolved = true
								// DON'T unsubscribe from stream - it needs to stay active for real-time updates
								resolve()
							}
						}
						rejectInitialSync = (error: Error) => {
							if (!syncResolved) {
								syncResolved = true
								// DON'T unsubscribe from stream even on error - let Electric handle it
								reject(error)
							}
						}
						
						// Shorter timeout (5 seconds) as fallback
						const timeoutId = setTimeout(() => {
							if (!syncResolved) {
								console.warn(`⚠️ Sync timeout for ${table} - checking isUpToDate one more time...`)
								// Check isUpToDate one more time before resolving
								// This will be checked after shape is created
								setTimeout(() => {
									if (!syncResolved) {
										console.warn(`⚠️ Sync timeout for ${table} - resolving anyway after 5s`)
										resolveInitialSync()
									}
								}, 100)
							}
						}, 5000)
						
						// Store timeout ID for cleanup if needed
						// Note: timeout will be cleared if sync completes early
					})
					
					const shapeConfig = {
						shape: {
							url: `${electricUrl}/v1/shape`,
							params: {
								table,
								...(validatedWhere ? { where: validatedWhere } : {}),
								...(columns ? { columns: columns.join(',') } : {}),
							},
						},
						table,
						primaryKey,
						shapeKey: `v${SYNC_VERSION}_${table}_${where?.replace(/[^a-zA-Z0-9]/g, '_') || 'all'}`, // Versioned key to force fresh sync when needed
						onInitialSync: () => {
							console.log(`✅ Initial sync complete for ${table} - data should now be in PGlite`)
							resolveInitialSync()
						},
						onError: (error: Error) => {
							console.error(`❌ Shape sync error for ${table}:`, error)
							console.error('Error details:', JSON.stringify(error, Object.getOwnPropertyNames(error)))
							rejectInitialSync(error)
						},
					}
					
					console.log('syncShapeToTable config:', JSON.stringify(shapeConfig, null, 2))
					
					// Type assertion to PGlite with electric extension
					const pgWithElectric = db as PGlite & { electric: { syncShapeToTable: (config: typeof shapeConfig) => Promise<{ unsubscribe: () => void; isUpToDate: boolean; stream: unknown }> } }
					const shape = await pgWithElectric.electric.syncShapeToTable(shapeConfig)

					if (!shape) {
						throw new Error('syncShapeToTable returned undefined')
					}

					// Log the actual shape result structure
					console.log('Shape sync result (initial):', {
						hasUnsubscribe: typeof shape?.unsubscribe === 'function',
						isUpToDate: shape?.isUpToDate,
						hasStream: !!shape?.stream,
						streamType: typeof shape?.stream,
					})
					
					// Recommended Approach Step 1: Check isUpToDate immediately
					if (shape.isUpToDate) {
						console.log(`✅ Sync already up-to-date for ${table} (resuming from previous state)`)
						resolveInitialSync()
					} else {
						// Recommended Approach Step 2: Subscribe to stream and watch for "up-to-date" message
						if (shape?.stream) {
							const stream = shape.stream as any
							console.log('Shape stream details:', {
								shapeHandle: stream?.shapeHandle,
								lastOffset: stream?.lastOffset,
								isUpToDate: stream?.isUpToDate,
								error: stream?.error,
								hasSubscribe: typeof stream?.subscribe === 'function',
								hasUnsubscribe: typeof stream?.unsubscribe === 'function',
							})
							
							// Subscribe to the stream to watch for "up-to-date" control message
							// NOTE: We keep this subscription active - don't unsubscribe!
							// The stream is what Electric SQL uses for real-time updates
							if (typeof stream?.subscribe === 'function') {
								console.log('Subscribing to shape stream to watch for up-to-date message...')
								// Subscribe but don't store unsubscribe - we want it to stay active
								stream.subscribe((messages: unknown[]) => {
									// Continue receiving updates even after sync is resolved
									if (!syncResolved) {
										console.log('🔵 Shape stream received messages:', messages?.length || 0)
									}
									
									// Check if any message indicates sync is complete
									if (messages && messages.length > 0) {
										for (const message of messages) {
											const msg = message as any
											// Check for "up-to-date" control message
											if (msg?.headers?.control === 'up-to-date' || 
											    msg?.headers?.electric_up_to_date === 'true' ||
											    (typeof msg === 'object' && 'up-to-date' in msg)) {
												if (!syncResolved) {
													console.log(`✅ Received up-to-date message for ${table}`)
													resolveInitialSync()
												}
												// Continue listening for real-time updates - don't return!
											}
										}
										if (!syncResolved && messages.length > 0) {
											console.log('First message:', JSON.stringify(messages[0], null, 2))
										}
									}
									
									// Also check stream's isUpToDate property after receiving messages
									if (!syncResolved && stream?.isUpToDate) {
										console.log(`✅ Stream isUpToDate is true for ${table}`)
										resolveInitialSync()
									}
								})
								
								// Also check stream's isUpToDate property immediately
								if (stream?.isUpToDate) {
									console.log(`✅ Stream isUpToDate is true immediately for ${table}`)
									resolveInitialSync()
								}
							}
							
							// Also poll isUpToDate periodically as a backup (every 200ms)
							const pollInterval = setInterval(() => {
								if (syncResolved) {
									clearInterval(pollInterval)
									return
								}
								
								if (shape.isUpToDate || stream?.isUpToDate) {
									console.log(`✅ Sync completed (detected via polling) for ${table}`)
									clearInterval(pollInterval)
									resolveInitialSync()
								}
							}, 200)
							
							// Clean up polling when promise resolves
							initialSyncPromise.finally(() => {
								clearInterval(pollInterval)
							})
						} else {
							console.warn(`⚠️ No stream available for ${table}, relying on callback and timeout`)
						}
					}

					// Return the shape handle - isUpToDate is a getter that reflects current state
					return {
						unsubscribe: () => {
							console.log('unsubscribing')
							if (shape && typeof shape.unsubscribe === 'function') {
								shape.unsubscribe()
							}
						},
						// Use getter to always return current state
						get isUpToDate() {
							return shape?.isUpToDate ?? false
						},
						stream: shape?.stream,
						initialSyncPromise, // Expose promise so callers can wait for sync
					}
					} catch (error) {
						console.error('Failed to sync shape:', error)
						// Check if Electric SQL server is reachable
						try {
							const response = await fetch(`${electricUrl}/v1/shape?table=${table}&offset=-1`, {
								method: 'GET',
							})
							console.log('Electric SQL server response:', response.status, response.statusText)
							if (!response.ok) {
								console.error('Electric SQL server error:', await response.text())
							}
						} catch (fetchError) {
							console.error('Cannot reach Electric SQL server:', fetchError)
							console.error('Make sure Electric SQL is running at:', electricUrl)
						}
						throw error
					}
				},
			}

			console.log('Electric SQL initialized successfully with PGlite')
			return electricClient
		} catch (error) {
			console.error('Failed to initialize Electric SQL:', error)
			throw error
		} finally {
			isInitializing = false
		}
	})()

	return initPromise
}

/**
 * Get the Electric client (throws if not initialized)
 */
export function getElectric(): ElectricClient {
	if (!electricClient) {
		throw new Error('Electric not initialized. Call initElectric() first.')
	}
	return electricClient
}

/**
 * Check if Electric is initialized
 */
export function isElectricInitialized(): boolean {
	return electricClient !== null
}

/**
 * Get the PGlite database instance
 */
export function getDb(): PGlite | null {
	return electricClient?.db ?? null
}