class StreamResourceManager {
    private activeStreams = new Map<string, Stream>();
    
    startStream(streamId: string) {
        // Check device resources before starting
        if (this.checkResourceAvailability()) {
            this.activeStreams.set(streamId, stream);
            return this.initializeStream(streamId);
        } else {
            throw new Error('Insufficient resources for streaming');
        }
    }
    
    stopStream(streamId: string) {
        // Clean up resources properly
        const stream = this.activeStreams.get(streamId);
        if (stream) {
            stream.cleanup();
            this.activeStreams.delete(streamId);
        }
    }
    
    private checkResourceAvailability() {
        return {
            memory: this.getAvailableMemory() > 100, // MB
            cpu: this.getCpuUsage() < 80, // percent
            network: this.getNetworkSpeed() > 1, // Mbps
            battery: this.getBatteryLevel() > 20 // percent
        };
    }
}

class StreamErrorHandler {
    handleStreamError(error: StreamError) {
        switch (error.code) {
            case 'NETWORK_ERROR':
                return this.handleNetworkError(error);
            case 'PERMISSION_DENIED':
                return this.handlePermissionError(error);
            case 'RESOURCE_EXHAUSTED':
                return this.handleResourceError(error);
            case 'INVALID_CONFIGURATION':
                return this.handleConfigError(error);
            default:
                return this.handleUnknownError(error);
        }
    }
    
    private async handleNetworkError(error: StreamError) {
        // Implement retry logic with exponential backoff
        const retryDelays = [1000, 2000, 4000, 8000]; // ms
        
        for (const delay of retryDelays) {
            await this.wait(delay);
            try {
                return await this.retryOperation();
            } catch (retryError) {
                console.log(`Retry failed, waiting ${delay}ms...`);
            }
        }
        
        throw new Error('Network error: Unable to establish connection after retries');
    }
}

class StreamPerformanceMonitor {
    private metrics = {
        frameRate: 0,
        bitrate: 0,
        latency: 0,
        droppedFrames: 0,
        bufferHealth: 0
    };
    
    startMonitoring(streamId: string) {
        setInterval(() => {
            this.collectMetrics(streamId);
            this.analyzePerformance();
        }, 5000); // Monitor every 5 seconds
    }
    
    private analyzePerformance() {
        if (this.metrics.frameRate < 15) {
            console.warn('Low frame rate detected');
            this.suggestOptimizations('reduce_quality');
        }
        
        if (this.metrics.latency > 10000) {
            console.warn('High latency detected');
            this.suggestOptimizations('optimize_network');
        }
    }
}

// Redux-style state management for streams
interface StreamState {
    activeStreams: Record<string, Stream>;
    viewingStream: string | null;
    broadcastingStream: string | null;
    loading: boolean;
    error: string | null;
}

const streamReducer = (state: StreamState, action: StreamAction) => {
    switch (action.type) {
        case 'START_STREAM':
            return {
                ...state,
                broadcastingStream: action.streamId,
                loading: false
            };
        case 'JOIN_STREAM':
            return {
                ...state,
                viewingStream: action.streamId,
                loading: false
            };
        case 'STREAM_ERROR':
            return {
                ...state,
                error: action.error,
                loading: false
            };
        default:
            return state;
    }
};

class StreamEventEmitter {
    private listeners = new Map<string, Function[]>();
    
    on(event: string, callback: Function) {
        if (!this.listeners.has(event)) {
            this.listeners.set(event, []);
        }
        this.listeners.get(event)!.push(callback);
    }
    
    emit(event: string, data: any) {
        const callbacks = this.listeners.get(event) || [];
        callbacks.forEach(callback => callback(data));
    }
    
    off(event: string, callback: Function) {
        const callbacks = this.listeners.get(event) || [];
        const index = callbacks.indexOf(callback);
        if (index > -1) {
            callbacks.splice(index, 1);
        }
    }
}

// Usage
const streamEvents = new StreamEventEmitter();
streamEvents.on('stream:started', (stream) => {
    console.log('Stream started:', stream.title);
});