// Email Verification Service - Core Implementation
const express = require('express');
const redis = require('redis');
const amqp = require('amqplib');
const { RateLimiter } = require('limiter');

class EmailVerificationService {
    constructor(config) {
        this.config = config;
        this.redis = redis.createClient(config.redis);
        this.rateLimiter = new RateLimiter(config.rateLimit);
        this.messageQueue = null;
        this.verificationProviders = [];
        this.circuitBreakers = new Map();
        
        this.initializeProviders();
        this.setupMessageQueue();
    }
    
    async initializeProviders() {
        // Initialize multiple verification providers with circuit breakers
        const providers = [
            new PrimaryVerificationProvider(this.config.primary),
            new SecondaryVerificationProvider(this.config.secondary),
            new FallbackVerificationProvider(this.config.fallback)
        ];
        
        for (const provider of providers) {
            const circuitBreaker = new CircuitBreaker(provider.verify.bind(provider), {
                timeout: 5000,
                errorThresholdPercentage: 50,
                resetTimeout: 30000
            });
            
            this.circuitBreakers.set(provider.name, circuitBreaker);
            this.verificationProviders.push({
                provider,
                circuitBreaker,
                priority: provider.priority
            });
        }
        
        // Sort providers by priority
        this.verificationProviders.sort((a, b) => a.priority - b.priority);
    }
    
    async setupMessageQueue() {
        try {
            const connection = await amqp.connect(this.config.messageQueue.url);
            const channel = await connection.createChannel();
            
            await channel.assertQueue('email-verification-requests', {
                durable: true,
                arguments: {
                    'x-dead-letter-exchange': 'email-verification-dlx',
                    'x-dead-letter-routing-key': 'failed'
                }
            });
            
            await channel.assertQueue('email-verification-results', { durable: true });
            await channel.assertExchange('email-verification-dlx', 'direct', { durable: true });
            
            this.messageQueue = channel;
            this.startQueueProcessor();
        } catch (error) {
            console.error('Failed to setup message queue:', error);
            throw error;
        }
    }
    
    async verifyEmail(email, options = {}) {
        const verificationId = this.generateVerificationId();
        const startTime = Date.now();
        
        try {
            // Rate limiting check
            if (!await this.checkRateLimit(options.clientId)) {
                throw new Error('Rate limit exceeded');
            }
            
            // Check cache first
            const cachedResult = await this.getCachedResult(email);
            if (cachedResult && !options.forceRefresh) {
                return {
                    verificationId,
                    email,
                    result: cachedResult,
                    cached: true,
                    duration: Date.now() - startTime
                };
            }
            
            // Attempt verification with providers
            const result = await this.attemptVerificationWithFallback(email, options);
            
            // Cache successful result
            if (result.status !== 'error') {
                await this.cacheResult(email, result);
            }
            
            // Log metrics
            await this.logVerificationMetrics(verificationId, email, result, Date.now() - startTime);
            
            return {
                verificationId,
                email,
                result,
                cached: false,
                duration: Date.now() - startTime
            };
            
        } catch (error) {
            await this.handleVerificationError(verificationId, email, error);
            throw error;
        }
    }
    
    async attemptVerificationWithFallback(email, options) {
        let lastError = null;
        
        for (const { provider, circuitBreaker } of this.verificationProviders) {
            try {
                if (circuitBreaker.state === 'closed' || circuitBreaker.state === 'half-open') {
                    const result = await circuitBreaker.fire(email, options);
                    
                    if (result && result.status !== 'error') {
                        return {
                            ...result,
                            provider: provider.name,
                            timestamp: new Date().toISOString()
                        };
                    }
                }
            } catch (error) {
                lastError = error;
                console.warn(`Provider ${provider.name} failed:`, error.message);
                continue;
            }
        }
        
        // All providers failed
        throw new Error(`All verification providers failed. Last error: ${lastError?.message}`);
    }
    
    async getCachedResult(email) {
        try {
            const cacheKey = `email_verification:${this.hashEmail(email)}`;
            const cachedData = await this.redis.get(cacheKey);
            
            if (cachedData) {
                const result = JSON.parse(cachedData);
                
                // Check if cache entry is still valid
                if (result.expiresAt > Date.now()) {
                    return result.data;
                }
                
                // Clean up expired entry
                await this.redis.del(cacheKey);
            }
            
            return null;
        } catch (error) {
            console.warn('Cache retrieval error:', error);
            return null;
        }
    }
    
    async cacheResult(email, result) {
        try {
            const cacheKey = `email_verification:${this.hashEmail(email)}`;
            const ttl = this.calculateCacheTTL(result);
            
            const cacheEntry = {
                data: result,
                cachedAt: Date.now(),
                expiresAt: Date.now() + ttl
            };
            
            await this.redis.setex(cacheKey, Math.floor(ttl / 1000), JSON.stringify(cacheEntry));
        } catch (error) {
            console.warn('Cache storage error:', error);
        }
    }
    
    calculateCacheTTL(result) {
        // Cache TTL based on result confidence and type
        const baseTTL = 24 * 60 * 60 * 1000; // 24 hours
        
        if (result.status === 'valid') {
            return baseTTL * 7; // 7 days for valid emails
        } else if (result.status === 'invalid') {
            return baseTTL * 30; // 30 days for permanently invalid emails
        } else if (result.status === 'risky') {
            return baseTTL; // 1 day for risky emails
        } else {
            return baseTTL / 24; // 1 hour for unknown/temporary results
        }
    }
    
    async startQueueProcessor() {
        await this.messageQueue.consume('email-verification-requests', async (msg) => {
            if (msg) {
                try {
                    const request = JSON.parse(msg.content.toString());
                    const result = await this.verifyEmail(request.email, request.options);
                    
                    // Send result back
                    await this.messageQueue.sendToQueue(
                        'email-verification-results',
                        Buffer.from(JSON.stringify({
                            requestId: request.id,
                            result
                        })),
                        { persistent: true }
                    );
                    
                    this.messageQueue.ack(msg);
                } catch (error) {
                    console.error('Queue processing error:', error);
                    this.messageQueue.nack(msg, false, false); // Send to DLQ
                }
            }
        });
    }
    
    generateVerificationId() {
        return `ev_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    }
    
    hashEmail(email) {
        const crypto = require('crypto');
        return crypto.createHash('sha256').update(email.toLowerCase().trim()).digest('hex');
    }
}

// Circuit Breaker Implementation
class CircuitBreaker {
    constructor(service, options = {}) {
        this.service = service;
        this.options = {
            timeout: options.timeout || 5000,
            errorThreshold: options.errorThresholdPercentage || 50,
            resetTimeout: options.resetTimeout || 30000,
            monitoringPeriod: options.monitoringPeriod || 60000
        };
        
        this.state = 'closed'; // closed, open, half-open
        this.failures = 0;
        this.requests = 0;
        this.lastFailureTime = null;
        this.resetTimeoutId = null;
    }
    
    async fire(...args) {
        if (this.state === 'open') {
            if (Date.now() - this.lastFailureTime >= this.options.resetTimeout) {
                this.state = 'half-open';
            } else {
                throw new Error('Circuit breaker is OPEN');
            }
        }
        
        try {
            const result = await this.executeWithTimeout(this.service(...args));
            this.onSuccess();
            return result;
        } catch (error) {
            this.onFailure();
            throw error;
        }
    }
    
    async executeWithTimeout(promise) {
        return Promise.race([
            promise,
            new Promise((_, reject) => {
                setTimeout(() => reject(new Error('Timeout')), this.options.timeout);
            })
        ]);
    }
    
    onSuccess() {
        this.failures = 0;
        if (this.state === 'half-open') {
            this.state = 'closed';
        }
    }
    
    onFailure() {
        this.failures++;
        this.requests++;
        this.lastFailureTime = Date.now();
        
        const failureRate = (this.failures / this.requests) * 100;
        if (failureRate >= this.options.errorThreshold) {
            this.state = 'open';
        }
    }
}

module.exports = EmailVerificationService;

// Event-Driven Email Verification
class EventDrivenVerificationService {
    constructor(eventBus, config) {
        this.eventBus = eventBus;
        this.config = config;
        this.batchProcessor = new BatchProcessor(config.batch);
        
        this.setupEventHandlers();
    }
    
    setupEventHandlers() {
        // Handle verification requests
        this.eventBus.on('user.registered', this.handleUserRegistration.bind(this));
        this.eventBus.on('email.update.requested', this.handleEmailUpdate.bind(this));
        this.eventBus.on('bulk.verification.requested', this.handleBulkVerification.bind(this));
        
        // Handle verification results
        this.eventBus.on('email.verification.completed', this.handleVerificationResult.bind(this));
        this.eventBus.on('email.verification.failed', this.handleVerificationFailure.bind(this));
    }
    
    async handleUserRegistration(event) {
        const { userId, email, priority = 'normal' } = event;
        
        // Queue email verification with appropriate priority
        await this.queueVerification({
            id: `user_reg_${userId}`,
            email,
            priority,
            context: {
                type: 'user_registration',
                userId,
                timestamp: Date.now()
            }
        });
    }
    
    async queueVerification(request) {
        // Add to batch processor for efficient processing
        await this.batchProcessor.add(request);
        
        // Emit queued event for tracking
        this.eventBus.emit('email.verification.queued', {
            requestId: request.id,
            email: request.email,
            queuedAt: Date.now()
        });
    }
    
    async handleVerificationResult(event) {
        const { requestId, email, result, context } = event;
        
        // Update user record based on context
        if (context.type === 'user_registration') {
            await this.updateUserVerificationStatus(context.userId, result);
        }
        
        // Store verification history
        await this.storeVerificationHistory(email, result);
        
        // Emit domain-specific events
        this.eventBus.emit('user.email.verified', {
            userId: context.userId,
            email,
            result,
            verifiedAt: Date.now()
        });
    }
}

// Batch Processing for High Throughput
class BatchProcessor {
    constructor(config) {
        this.config = config;
        this.queue = [];
        this.processing = false;
        this.batchSize = config.batchSize || 100;
        this.batchTimeout = config.batchTimeout || 5000;
        
        this.startBatchProcessing();
    }
    
    async add(item) {
        this.queue.push({
            ...item,
            addedAt: Date.now()
        });
        
        // Trigger immediate processing if queue is full
        if (this.queue.length >= this.batchSize) {
            this.processBatch();
        }
    }
    
    startBatchProcessing() {
        setInterval(() => {
            if (this.queue.length > 0 && !this.processing) {
                this.processBatch();
            }
        }, this.batchTimeout);
    }
    
    async processBatch() {
        if (this.processing || this.queue.length === 0) return;
        
        this.processing = true;
        const batch = this.queue.splice(0, this.batchSize);
        
        try {
            await this.processBatchItems(batch);
        } catch (error) {
            console.error('Batch processing error:', error);
            
            // Requeue failed items
            this.queue.unshift(...batch);
        } finally {
            this.processing = false;
        }
    }
    
    async processBatchItems(batch) {
        const results = await Promise.allSettled(
            batch.map(item => this.processVerification(item))
        );
        
        // Handle results and failures
        results.forEach((result, index) => {
            const item = batch[index];
            
            if (result.status === 'fulfilled') {
                this.eventBus.emit('email.verification.completed', {
                    requestId: item.id,
                    email: item.email,
                    result: result.value,
                    context: item.context
                });
            } else {
                this.eventBus.emit('email.verification.failed', {
                    requestId: item.id,
                    email: item.email,
                    error: result.reason,
                    context: item.context
                });
            }
        });
    }
}

// Distributed State Manager
class VerificationStateManager {
    constructor(eventStore, snapshotStore) {
        this.eventStore = eventStore;
        this.snapshotStore = snapshotStore;
        this.stateCache = new Map();
    }
    
    async getEmailVerificationState(email) {
        const emailHash = this.hashEmail(email);
        
        // Check cache first
        if (this.stateCache.has(emailHash)) {
            const cached = this.stateCache.get(emailHash);
            if (Date.now() - cached.timestamp < 300000) { // 5 minutes
                return cached.state;
            }
        }
        
        // Load from snapshot store
        let state = await this.snapshotStore.get(emailHash);
        
        if (!state) {
            state = {
                email,
                verificationHistory: [],
                currentStatus: 'unknown',
                lastVerified: null,
                confidence: 0,
                metadata: {}
            };
        }
        
        // Apply events since snapshot
        const events = await this.eventStore.getEventsSince(
            emailHash, 
            state.lastEventId || 0
        );
        
        state = events.reduce((currentState, event) => {
            return this.applyEvent(currentState, event);
        }, state);
        
        // Update cache
        this.stateCache.set(emailHash, {
            state,
            timestamp: Date.now()
        });
        
        return state;
    }
    
    async recordVerificationEvent(email, verificationResult) {
        const emailHash = this.hashEmail(email);
        const event = {
            id: this.generateEventId(),
            type: 'email_verified',
            email,
            timestamp: Date.now(),
            data: verificationResult
        };
        
        // Store event
        await this.eventStore.append(emailHash, event);
        
        // Update cached state
        if (this.stateCache.has(emailHash)) {
            const cached = this.stateCache.get(emailHash);
            cached.state = this.applyEvent(cached.state, event);
            cached.timestamp = Date.now();
        }
        
        // Create snapshot if needed
        const eventCount = await this.eventStore.getEventCount(emailHash);
        if (eventCount % 100 === 0) { // Snapshot every 100 events
            const currentState = await this.getEmailVerificationState(email);
            await this.snapshotStore.save(emailHash, {
                ...currentState,
                lastEventId: event.id
            });
        }
        
        return event;
    }
    
    applyEvent(state, event) {
        switch (event.type) {
            case 'email_verified':
                return {
                    ...state,
                    verificationHistory: [
                        ...state.verificationHistory.slice(-9), // Keep last 10
                        {
                            timestamp: event.timestamp,
                            result: event.data,
                            provider: event.data.provider
                        }
                    ],
                    currentStatus: event.data.status,
                    lastVerified: event.timestamp,
                    confidence: event.data.confidence || state.confidence,
                    metadata: {
                        ...state.metadata,
                        lastProvider: event.data.provider,
                        verificationCount: (state.metadata.verificationCount || 0) + 1
                    }
                };
            
            default:
                return state;
        }
    }
}

// Multi-Layer Cache Strategy
class MultiLayerCache {
    constructor(config) {
        this.l1Cache = new Map(); // Memory cache
        this.l2Cache = redis.createClient(config.redis); // Redis cache
        this.l3Cache = config.database; // Database cache
        
        this.cacheHitRates = {
            l1: 0,
            l2: 0,
            l3: 0,
            miss: 0
        };
        
        this.startMetricsCollection();
    }
    
    async get(key) {
        const startTime = Date.now();
        
        // L1 Cache (Memory)
        if (this.l1Cache.has(key)) {
            this.recordCacheHit('l1', Date.now() - startTime);
            return this.l1Cache.get(key);
        }
        
        // L2 Cache (Redis)
        try {
            const l2Result = await this.l2Cache.get(key);
            if (l2Result) {
                const data = JSON.parse(l2Result);
                
                // Promote to L1
                this.l1Cache.set(key, data);
                this.scheduleL1Eviction(key, 300000); // 5 minutes
                
                this.recordCacheHit('l2', Date.now() - startTime);
                return data;
            }
        } catch (error) {
            console.warn('L2 cache error:', error);
        }
        
        // L3 Cache (Database)
        try {
            const l3Result = await this.l3Cache.getVerificationCache(key);
            if (l3Result && !this.isExpired(l3Result)) {
                
                // Promote to L2 and L1
                await this.l2Cache.setex(key, 3600, JSON.stringify(l3Result));
                this.l1Cache.set(key, l3Result);
                this.scheduleL1Eviction(key, 300000);
                
                this.recordCacheHit('l3', Date.now() - startTime);
                return l3Result;
            }
        } catch (error) {
            console.warn('L3 cache error:', error);
        }
        
        this.recordCacheHit('miss', Date.now() - startTime);
        return null;
    }
    
    async set(key, value, ttl = 3600) {
        try {
            // Set in all cache layers
            this.l1Cache.set(key, value);
            this.scheduleL1Eviction(key, Math.min(ttl * 1000, 300000));
            
            await this.l2Cache.setex(key, ttl, JSON.stringify(value));
            await this.l3Cache.setVerificationCache(key, value, ttl);
            
        } catch (error) {
            console.error('Cache set error:', error);
        }
    }
    
    scheduleL1Eviction(key, timeout) {
        setTimeout(() => {
            this.l1Cache.delete(key);
        }, timeout);
    }
    
    recordCacheHit(layer, duration) {
        this.cacheHitRates[layer]++;
        
        // Emit metrics
        this.emit('cache.hit', {
            layer,
            duration,
            timestamp: Date.now()
        });
    }
    
    getCacheStats() {
        const total = Object.values(this.cacheHitRates).reduce((a, b) => a + b, 0);
        
        return Object.entries(this.cacheHitRates).reduce((stats, [layer, hits]) => {
            stats[layer] = {
                hits,
                hitRate: total > 0 ? (hits / total * 100).toFixed(2) + '%' : '0%'
            };
            return stats;
        }, {});
    }
}

// OpenTelemetry Integration
const { trace, SpanStatusCode } = require('@opentelemetry/api');
const tracer = trace.getTracer('email-verification-service');

class TracedEmailVerificationService extends EmailVerificationService {
    async verifyEmail(email, options = {}) {
        const span = tracer.startSpan('email.verification', {
            attributes: {
                'email.domain': email.split('@')[1],
                'verification.provider': 'multi',
                'request.priority': options.priority || 'normal'
            }
        });
        
        try {
            span.setAttributes({
                'verification.cache_check': true
            });
            
            const result = await super.verifyEmail(email, options);
            
            span.setAttributes({
                'verification.cached': result.cached,
                'verification.status': result.result.status,
                'verification.provider_used': result.result.provider,
                'verification.duration_ms': result.duration,
                'verification.confidence': result.result.confidence || 0
            });
            
            span.setStatus({ code: SpanStatusCode.OK });
            return result;
            
        } catch (error) {
            span.setAttributes({
                'error.message': error.message,
                'error.type': error.constructor.name
            });
            
            span.setStatus({
                code: SpanStatusCode.ERROR,
                message: error.message
            });
            
            throw error;
        } finally {
            span.end();
        }
    }
}

// Custom Metrics Collection
class VerificationMetrics {
    constructor(metricsCollector) {
        this.metrics = metricsCollector;
        
        // Define custom metrics
        this.verificationCounter = this.metrics.createCounter({
            name: 'email_verifications_total',
            help: 'Total number of email verifications performed',
            labelNames: ['status', 'provider', 'cached']
        });
        
        this.verificationDuration = this.metrics.createHistogram({
            name: 'email_verification_duration_seconds',
            help: 'Duration of email verification requests',
            labelNames: ['provider', 'status'],
            buckets: [0.1, 0.5, 1, 2, 5, 10]
        });
        
        this.cacheHitRate = this.metrics.createGauge({
            name: 'email_verification_cache_hit_rate',
            help: 'Cache hit rate for email verifications',
            labelNames: ['cache_layer']
        });
    }
    
    recordVerification(result, duration, cached = false) {
        this.verificationCounter
            .labels(result.status, result.provider, cached.toString())
            .inc();
        
        this.verificationDuration
            .labels(result.provider, result.status)
            .observe(duration / 1000);
    }
    
    updateCacheHitRate(layer, hitRate) {
        this.cacheHitRate
            .labels(layer)
            .set(hitRate);
    }
}