interface QualitySelectionCriteria {
    networkSpeed: number;        // Mbps
    deviceCapabilities: DeviceInfo;
    batteryLevel: number;        // percentage
    userPreference: QualityLevel;
    connectionType: 'wifi' | 'cellular' | 'unknown';
}

class QualityManager {
    selectOptimalQuality(criteria: QualitySelectionCriteria): QualityLevel {
        // Network-based selection
        if (criteria.networkSpeed < 2) return 'SD';
        if (criteria.networkSpeed < 4) return 'HD';
        
        // Device capability check
        if (!criteria.deviceCapabilities.supportsHardwareEncoding) {
            return 'HD'; // Fallback for software encoding
        }
        
        // Battery consideration
        if (criteria.batteryLevel < 20) {
            return 'SD'; // Preserve battery
        }
        
        // Connection type consideration
        if (criteria.connectionType === 'cellular') {
            return criteria.networkSpeed > 5 ? 'HD' : 'SD';
        }
        
        return 'FHD'; // Default for WiFi with good conditions
    }
}

class AdaptiveBitrateManager {
    private qualityLevels = [
        { name: 'SD', bitrate: 1216000, resolution: { width: 480, height: 854 } },
        { name: 'HD', bitrate: 2496000, resolution: { width: 720, height: 1280 } },
        { name: 'FHD', bitrate: 4992000, resolution: { width: 1080, height: 1920 } }
    ];
    
    private currentQuality = 1; // Start with HD
    private networkMonitor: NetworkMonitor;
    
    enableAdaptiveBitrate() {
        this.networkMonitor.onBandwidthChange((bandwidth) => {
            const optimalQuality = this.selectQualityForBandwidth(bandwidth);
            if (optimalQuality !== this.currentQuality) {
                this.switchQuality(optimalQuality);
            }
        });
    }
    
    private selectQualityForBandwidth(bandwidth: number): number {
        // Select quality with 1.5x bandwidth buffer
        const requiredBandwidth = bandwidth * 0.67; // Use 67% of available bandwidth
        
        for (let i = this.qualityLevels.length - 1; i >= 0; i--) {
            if (this.qualityLevels[i].bitrate <= requiredBandwidth * 1000) {
                return i;
            }
        }
        return 0; // Fallback to lowest quality
    }
    
    private switchQuality(newQualityIndex: number) {
        const quality = this.qualityLevels[newQualityIndex];
        console.log(`Switching to ${quality.name} quality`);
        
        // Apply new settings
        this.updateEncoderSettings({
            bitrate: quality.bitrate,
            resolution: quality.resolution
        });
        
        this.currentQuality = newQualityIndex;
    }
}

class VideoMemoryManager {
    private readonly MAX_MEMORY_USAGE = 150; // MB
    private currentUsage = 0;
    
    optimizeMemoryUsage() {
        // Monitor memory usage
        this.monitorMemory();
        
        // Implement memory cleanup strategies
        this.setupMemoryCleanup();
    }
    
    private monitorMemory() {
        setInterval(() => {
            this.currentUsage = this.getCurrentMemoryUsage();
            
            if (this.currentUsage > this.MAX_MEMORY_USAGE * 0.8) {
                console.warn('High memory usage detected');
                this.triggerMemoryCleanup();
            }
        }, 5000);
    }
    
    private triggerMemoryCleanup() {
        // Reduce video buffer size
        this.reduceBufferSize();
        
        // Lower video quality temporarily
        this.temporarilyReduceQuality();
        
        // Clear unnecessary resources
        this.clearUnusedResources();
    }
    
    private reduceBufferSize() {
        // Reduce video buffer to minimum
        const minBufferConfig = {
            videoBufferSize: 1000, // 1 second
            audioBufferSize: 500   // 0.5 seconds
        };
        
        this.applyBufferConfig(minBufferConfig);
    }
}

class ConnectionRecoveryManager {
    private reconnectAttempts = 0;
    private readonly MAX_RECONNECT_ATTEMPTS = 5;
    private isRecovering = false;
    
    handleConnectionLoss() {
        if (this.isRecovering) return;
        
        this.isRecovering = true;
        this.attemptReconnection();
    }
    
    private async attemptReconnection() {
        const delays = [1000, 2000, 4000, 8000, 16000]; // Exponential backoff
        
        for (let i = 0; i < this.MAX_RECONNECT_ATTEMPTS; i++) {
            try {
                await this.wait(delays[i] || 16000);
                await this.testConnection();
                
                // Connection successful
                console.log('Connection recovered');
                this.onConnectionRecovered();
                this.isRecovering = false;
                return;
                
            } catch (error) {
                console.log(`Reconnection attempt ${i + 1} failed`);
                this.reconnectAttempts++;
            }
        }
        
        // All attempts failed
        this.onConnectionFailed();
        this.isRecovering = false;
    }
    
    private onConnectionRecovered() {
        // Resume streaming with potentially lower quality
        const recoveryConfig = {
            bitrate: Math.max(1000000, this.previousBitrate * 0.7), // 70% of previous
            enableQuickReconnect: true
        };
        
        this.resumeStreaming(recoveryConfig);
    }
}

class QualityAnalytics {
    private sessionData: QualitySession[] = [];
    
    recordSession(streamId: string, duration: number, metrics: QualityMetrics[]) {
        const session: QualitySession = {
            streamId,
            duration,
            startTime: Date.now(),
            averageMetrics: this.calculateAverages(metrics),
            qualityScore: this.calculateQualityScore(metrics),
            issuesDetected: this.identifyIssues(metrics)
        };
        
        this.sessionData.push(session);
        this.sendAnalytics(session);
    }
    
    private calculateQualityScore(metrics: QualityMetrics[]): number {
        let score = 100;
        
        metrics.forEach(metric => {
            // Penalize dropped frames
            if (metric.droppedFrames > 0) {
                score -= metric.droppedFrames * 0.5;
            }
            
            // Penalize low frame rate
            if (metric.frameRate < 24) {
                score -= (24 - metric.frameRate) * 2;
            }
            
            // Penalize high latency
            if (metric.latency > 5000) {
                score -= (metric.latency - 5000) / 100;
            }
        });
        
        return Math.max(0, Math.min(100, score));
    }
    
    generateQualityReport(): QualityReport {
        return {
            totalSessions: this.sessionData.length,
            averageQualityScore: this.getAverageQualityScore(),
            commonIssues: this.getCommonIssues(),
            recommendations: this.generateRecommendations()
        };
    }
}

class NetworkAwareQualityManager {
    configureForConnection(connectionType: string, speed: number) {
        const configs = {
            'wifi': {
                maxBitrate: 5000000,
                targetResolution: { width: 1080, height: 1920 },
                bufferSize: 5000,
                enableHighQuality: true
            },
            
            '4g': {
                maxBitrate: 3000000,
                targetResolution: { width: 720, height: 1280 },
                bufferSize: 3000,
                enableAdaptive: true
            },
            
            '3g': {
                maxBitrate: 1500000,
                targetResolution: { width: 480, height: 854 },
                bufferSize: 2000,
                enableDataSaver: true
            },
            
            'slow': {
                maxBitrate: 800000,
                targetResolution: { width: 480, height: 854 },
                bufferSize: 1000,
                enableUltraDataSaver: true
            }
        };
        
        return configs[connectionType] || configs['3g'];
    }
}

class QualityTroubleshooter {
    improvePoorQuality(networkSpeed: number, deviceCapabilities: DeviceCapabilities) {
        const recommendations = [];
        
        // Network-based improvements
        if (networkSpeed < 2) {
            recommendations.push({
                type: 'network',
                action: 'Improve network connection',
                details: 'Switch to WiFi or better cellular coverage'
            });
        }
        
        // Device-based improvements
        if (!deviceCapabilities.supportsHardwareEncoding) {
            recommendations.push({
                type: 'device',
                action: 'Enable software optimizations',
                details: 'Use lower resolution with higher bitrate'
            });
        }
        
        return recommendations;
    }
}