// 音频播放器类
class AudioPlayer {
    private audio: HTMLAudioElement;
    private audioContext: AudioContext;
    private source: MediaElementAudioSourceNode;
    private analyser: AnalyserNode;
    private gainNode: GainNode;
    private equalizer: EqualizerNode;
    
    constructor() {
        this.audio = new Audio();
        this.audioContext = new AudioContext();
        
        // 创建音频源
        this.source = this.audioContext.createMediaElementSource(this.audio);
        
        // 创建分析器
        this.analyser = this.audioContext.createAnalyser();
        this.analyser.fftSize = 2048;
        
        // 创建音量控制
        this.gainNode = this.audioContext.createGain();
        
        // 创建均衡器
        this.equalizer = new EqualizerNode(this.audioContext);
        
        // 连接音频节点
        this.source
            .connect(this.analyser)
            .connect(this.equalizer.input)
            .connect(this.gainNode)
            .connect(this.audioContext.destination);
        
        // 初始化事件监听
        this.initializeEventListeners();
    }
    
    // 加载音频
    loadAudio(url: string): Promise<void> {
        return new Promise((resolve, reject) => {
            this.audio.src = url;
            this.audio.load();
            
            this.audio.oncanplaythrough = () => resolve();
            this.audio.onerror = () => reject(new Error('Failed to load audio'));
        });
    }
    
    // 播放
    play(): Promise<void> {
        return this.audio.play();
    }
    
    // 暂停
    pause(): void {
        this.audio.pause();
    }
    
    // 跳转到指定时间
    seek(time: number): void {
        this.audio.currentTime = time;
    }
    
    // 设置音量
    setVolume(volume: number): void {
        this.gainNode.gain.value = Math.max(0, Math.min(1, volume));
    }
    
    // 设置均衡器
    setEqualizerBand(frequency: number, gain: number): void {
        this.equalizer.setBand(frequency, gain);
    }
    
    // 获取频谱数据
    getSpectrumData(): Uint8Array {
        const dataArray = new Uint8Array(this.analyser.frequencyBinCount);
        this.analyser.getByteFrequencyData(dataArray);
        return dataArray;
    }
    
    // 获取波形数据
    getWaveformData(): Uint8Array {
        const dataArray = new Uint8Array(this.analyser.frequencyBinCount);
        this.analyser.getByteTimeDomainData(dataArray);
        return dataArray;
    }
    
    // 初始化事件监听
    private initializeEventListeners(): void {
        // 播放状态变化
        this.audio.addEventListener('play', () => {
            this.audioContext.resume();
        });
        
        // 音频结束
        this.audio.addEventListener('ended', () => {
            // 处理播放结束
        });
        
        // 音频错误
        this.audio.addEventListener('error', (e) => {
            console.error('Audio error:', e);
        });
    }
}

// 均衡器节点类
class EqualizerNode {
    private context: AudioContext;
    private bands: BiquadFilterNode[];
    private _input: GainNode;
    private _output: GainNode;
    
    constructor(context: AudioContext) {
        this.context = context;
        this.bands = [];
        
        // 创建输入输出节点
        this._input = context.createGain();
        this._output = context.createGain();
        
        // 创建均衡器频段
        this.createBands();
        
        // 连接频段
        this.connectBands();
    }
    
    // 获取输入节点
    get input(): AudioNode {
        return this._input;
    }
    
    // 获取输出节点
    get output(): AudioNode {
        return this._output;
    }
    
    // 设置频段增益
    setBand(frequency: number, gain: number): void {
        const band = this.bands.find(b => 
            Math.abs(b.frequency.value - frequency) < 1
        );
        
        if (band) {
            band.gain.value = gain;
        }
    }
    
    // 创建均衡器频段
    private createBands(): void {
        const frequencies = [60, 170, 310, 600, 1000, 3000, 6000, 12000, 14000, 16000];
        
        frequencies.forEach(freq => {
            const filter = this.context.createBiquadFilter();
            filter.type = 'peaking';
            filter.frequency.value = freq;
            filter.Q.value = 1;
            filter.gain.value = 0;
            
            this.bands.push(filter);
        });
    }
    
    // 连接频段
    private connectBands(): void {
        this.bands.reduce((prev, curr) => {
            prev.connect(curr);
            return curr;
        }, this._input);
        
        this.bands[this.bands.length - 1].connect(this._output);
    }
}

// 使用示例
const player = new AudioPlayer();

// 加载并播放音频
async function playAudio(url: string) {
    try {
        await player.loadAudio(url);
        await player.play();
        
        // 设置音量
        player.setVolume(0.8);
        
        // 设置均衡器
        player.setEqualizerBand(60, 3); // 增强低频
        player.setEqualizerBand(12000, 2); // 增强高频
        
        // 实时更新频谱显示
        function updateSpectrum() {
            const spectrumData = player.getSpectrumData();
            // 使用频谱数据绘制可视化效果
            requestAnimationFrame(updateSpectrum);
        }
        
        updateSpectrum();
        
    } catch (error) {
        console.error('Failed to play audio:', error);
    }
}

// 音频录制器类
class AudioRecorder {
    private stream: MediaStream | null;
    private mediaRecorder: MediaRecorder | null;
    private audioChunks: Blob[];
    private isRecording: boolean;
    
    constructor() {
        this.stream = null;
        this.mediaRecorder = null;
        this.audioChunks = [];
        this.isRecording = false;
    }
    
    // 请求麦克风权限
    async requestPermission(): Promise<void> {
        try {
            this.stream = await navigator.mediaDevices.getUserMedia({
                audio: true
            });
        } catch (error) {
            throw new Error('Failed to get microphone permission');
        }
    }
    
    // 开始录制
    startRecording(): void {
        if (!this.stream) {
            throw new Error('No audio stream available');
        }
        
        this.audioChunks = [];
        this.mediaRecorder = new MediaRecorder(this.stream);
        
        this.mediaRecorder.addEventListener('dataavailable', (event) => {
            if (event.data.size > 0) {
                this.audioChunks.push(event.data);
            }
        });
        
        this.mediaRecorder.start();
        this.isRecording = true;
    }
    
    // 停止录制
    stopRecording(): Promise<Blob> {
        return new Promise((resolve, reject) => {
            if (!this.mediaRecorder || !this.isRecording) {
                reject(new Error('Not recording'));
                return;
            }
            
            this.mediaRecorder.addEventListener('stop', () => {
                const audioBlob = new Blob(this.audioChunks, {
                    type: 'audio/webm'
                });
                resolve(audioBlob);
            });
            
            this.mediaRecorder.stop();
            this.isRecording = false;
        });
    }
    
    // 暂停录制
    pauseRecording(): void {
        if (this.mediaRecorder && this.isRecording) {
            this.mediaRecorder.pause();
        }
    }
    
    // 恢复录制
    resumeRecording(): void {
        if (this.mediaRecorder && this.isRecording) {
            this.mediaRecorder.resume();
        }
    }
    
    // 释放资源
    dispose(): void {
        if (this.stream) {
            this.stream.getTracks().forEach(track => track.stop());
            this.stream = null;
        }
        
        this.mediaRecorder = null;
        this.audioChunks = [];
        this.isRecording = false;
    }
}

// 使用示例
const recorder = new AudioRecorder();

async function startRecording() {
    try {
        // 请求麦克风权限
        await recorder.requestPermission();
        
        // 开始录制
        recorder.startRecording();
        
        // 5秒后停止录制
        setTimeout(async () => {
            const audioBlob = await recorder.stopRecording();
            
            // 创建音频URL
            const audioUrl = URL.createObjectURL(audioBlob);
            
            // 创建音频元素播放录音
            const audio = new Audio(audioUrl);
            audio.play();
            
            // 清理资源
            recorder.dispose();
            
        }, 5000);
        
    } catch (error) {
        console.error('Recording failed:', error);
    }
}

// 视频播放器类
class VideoPlayer {
    private video: HTMLVideoElement;
    private canvas: HTMLCanvasElement;
    private ctx: CanvasRenderingContext2D;
    private isPlaying: boolean;
    
    constructor(
        videoElement: HTMLVideoElement,
        canvas: HTMLCanvasElement
    ) {
        this.video = videoElement;
        this.canvas = canvas;
        this.ctx = canvas.getContext('2d')!;
        this.isPlaying = false;
        
        this.initializePlayer();
    }
    
    // 初始化播放器
    private initializePlayer(): void {
        // 设置画布尺寸
        this.canvas.width = this.video.clientWidth;
        this.canvas.height = this.video.clientHeight;
        
        // 监听视频事件
        this.video.addEventListener('play', () => {
            this.isPlaying = true;
            this.render();
        });
        
        this.video.addEventListener('pause', () => {
            this.isPlaying = false;
        });
        
        this.video.addEventListener('ended', () => {
            this.isPlaying = false;
        });
    }
    
    // 加载视频
    loadVideo(url: string): Promise<void> {
        return new Promise((resolve, reject) => {
            this.video.src = url;
            this.video.load();
            
            this.video.oncanplaythrough = () => resolve();
            this.video.onerror = () => reject(new Error('Failed to load video'));
        });
    }
    
    // 播放
    play(): Promise<void> {
        return this.video.play();
    }
    
    // 暂停
    pause(): void {
        this.video.pause();
    }
    
    // 跳转到指定时间
    seek(time: number): void {
        this.video.currentTime = time;
    }
    
    // 设置播放速度
    setPlaybackRate(rate: number): void {
        this.video.playbackRate = rate;
    }
    
    // 应用滤镜效果
    applyFilter(filter: VideoFilter): void {
        this.ctx.filter = filter.toString();
    }
    
    // 渲染视频帧
    private render(): void {
        if (!this.isPlaying) return;
        
        // 绘制视频帧
        this.ctx.drawImage(
            this.video,
            0,
            0,
            this.canvas.width,
            this.canvas.height
        );
        
        // 继续渲染下一帧
        requestAnimationFrame(() => this.render());
    }
    
    // 截取当前帧
    captureFrame(): string {
        return this.canvas.toDataURL('image/png');
    }
    
    // 导出视频片段
    async exportClip(
        startTime: number,
        endTime: number
    ): Promise<Blob> {
        const stream = this.canvas.captureStream();
        const recorder = new MediaRecorder(stream);
        const chunks: Blob[] = [];
        
        recorder.ondataavailable = (e) => {
            if (e.data.size > 0) {
                chunks.push(e.data);
            }
        };
        
        return new Promise((resolve, reject) => {
            recorder.onstop = () => {
                const blob = new Blob(chunks, { type: 'video/webm' });
                resolve(blob);
            };
            
            // 开始录制
            this.video.currentTime = startTime;
            recorder.start();
            
            // 到达结束时间后停止
            const checkTime = () => {
                if (this.video.currentTime >= endTime) {
                    recorder.stop();
                    this.pause();
                } else {
                    requestAnimationFrame(checkTime);
                }
            };
            
            this.play().then(checkTime);
        });
    }
}

// 视频滤镜类
class VideoFilter {
    private filters: Map<string, number>;
    
    constructor() {
        this.filters = new Map();
    }
    
    // 设置亮度
    setBrightness(value: number): void {
        this.filters.set('brightness', value);
    }
    
    // 设置对比度
    setContrast(value: number): void {
        this.filters.set('contrast', value);
    }
    
    // 设置饱和度
    setSaturation(value: number): void {
        this.filters.set('saturate', value);
    }
    
    // 设置色相
    setHue(value: number): void {
        this.filters.set('hue-rotate', value);
    }
    
    // 设置模糊
    setBlur(value: number): void {
        this.filters.set('blur', value);
    }
    
    // 转换为CSS滤镜字符串
    toString(): string {
        return Array.from(this.filters.entries())
            .map(([key, value]) => `${key}(${value}${this.getUnit(key)})`)
            .join(' ');
    }
    
    // 获取滤镜单位
    private getUnit(filter: string): string {
        switch (filter) {
            case 'blur':
                return 'px';
            case 'hue-rotate':
                return 'deg';
            default:
                return '%';
        }
    }
}

// 使用示例
const video = document.getElementById('video') as HTMLVideoElement;
const canvas = document.getElementById('canvas') as HTMLCanvasElement;
const player = new VideoPlayer(video, canvas);

// 加载并播放视频
async function playVideo(url: string) {
    try {
        await player.loadVideo(url);
        await player.play();
        
        // 应用滤镜效果
        const filter = new VideoFilter();
        filter.setBrightness(110);
        filter.setContrast(120);
        filter.setSaturation(130);
        
        player.applyFilter(filter);
        
        // 截取当前帧
        setTimeout(() => {
            const frameData = player.captureFrame();
            const img = new Image();
            img.src = frameData;
            document.body.appendChild(img);
        }, 3000);
        
        // 导出视频片段
        setTimeout(async () => {
            const clip = await player.exportClip(5, 10);
            const url = URL.createObjectURL(clip);
            const a = document.createElement('a');
            a.href = url;
            a.download = 'clip.webm';
            a.click();
        }, 5000);
        
    } catch (error) {
        console.error('Failed to play video:', error);
    }
}

// WebRTC连接管理器
class WebRTCManager {
    private peerConnection: RTCPeerConnection;
    private localStream: MediaStream | null;
    private remoteStream: MediaStream | null;
    private dataChannel: RTCDataChannel | null;
    
    constructor() {
        this.peerConnection = new RTCPeerConnection({
            iceServers: [
                { urls: 'stun:stun.l.google.com:19302' }
            ]
        });
        
        this.localStream = null;
        this.remoteStream = null;
        this.dataChannel = null;
        
        this.initializeConnection();
    }
    
    // 初始化连接
    private initializeConnection(): void {
        // 监听ICE候选
        this.peerConnection.onicecandidate = (event) => {
            if (event.candidate) {
                // 发送ICE候选到远端
                this.sendSignalingMessage({
                    type: 'candidate',
                    candidate: event.candidate
                });
            }
        };
        
        // 监听远端流
        this.peerConnection.ontrack = (event) => {
            this.remoteStream = event.streams[0];
            // 触发远端流更新事件
            this.onRemoteStreamUpdate(this.remoteStream);
        };
        
        // 创建数据通道
        this.dataChannel = this.peerConnection.createDataChannel('messageChannel');
        
        // 监听数据通道事件
        this.dataChannel.onmessage = (event) => {
            this.onDataChannelMessage(event.data);
        };
    }
    
    // 获取本地媒体流
    async getLocalStream(
        constraints: MediaStreamConstraints
    ): Promise<MediaStream> {
        try {
            this.localStream = await navigator.mediaDevices.getUserMedia(constraints);
            
            // 添加本地流到连接
            this.localStream.getTracks().forEach(track => {
                if (this.localStream) {
                    this.peerConnection.addTrack(track, this.localStream);
                }
            });
            
            return this.localStream;
            
        } catch (error) {
            throw new Error('Failed to get local stream');
        }
    }
    
    // 创建连接请求
    async createOffer(): Promise<RTCSessionDescriptionInit> {
        try {
            const offer = await this.peerConnection.createOffer();
            await this.peerConnection.setLocalDescription(offer);
            return offer;
            
        } catch (error) {
            throw new Error('Failed to create offer');
        }
    }
    
    // 创建连接应答
    async createAnswer(): Promise<RTCSessionDescriptionInit> {
        try {
            const answer = await this.peerConnection.createAnswer();
            await this.peerConnection.setLocalDescription(answer);
            return answer;
            
        } catch (error) {
            throw new Error('Failed to create answer');
        }
    }
    
    // 处理远端描述
    async handleRemoteDescription(
        description: RTCSessionDescriptionInit
    ): Promise<void> {
        try {
            await this.peerConnection.setRemoteDescription(
                new RTCSessionDescription(description)
            );
            
            if (description.type === 'offer') {
                const answer = await this.createAnswer();
                // 发送应答到远端
                this.sendSignalingMessage({
                    type: 'answer',
                    answer
                });
            }
            
        } catch (error) {
            throw new Error('Failed to handle remote description');
        }
    }
    
    // 处理ICE候选
    async handleCandidate(candidate: RTCIceCandidate): Promise<void> {
        try {
            await this.peerConnection.addIceCandidate(candidate);
        } catch (error) {
            throw new Error('Failed to handle ICE candidate');
        }
    }
    
    // 发送消息
    sendMessage(message: string): void {
        if (this.dataChannel && this.dataChannel.readyState === 'open') {
            this.dataChannel.send(message);
        }
    }
    
    // 关闭连接
    close(): void {
        if (this.localStream) {
            this.localStream.getTracks().forEach(track => track.stop());
        }
        
        if (this.dataChannel) {
            this.dataChannel.close();
        }
        
        this.peerConnection.close();
    }
    
    // 发送信令消息（需要实现）
    private sendSignalingMessage(message: any): void {
        // 通过信令服务器发送消息
    }
    
    // 远端流更新回调（需要实现）
    private onRemoteStreamUpdate(stream: MediaStream): void {
        // 处理远端流更新
    }
    
    // 数据通道消息回调（需要实现）
    private onDataChannelMessage(message: string): void {
        // 处理数据通道消息
    }
}

// 使用示例
const rtcManager = new WebRTCManager();

// 开始视频通话
async function startVideoCall() {
    try {
        // 获取本地媒体流
        const localStream = await rtcManager.getLocalStream({
            video: true,
            audio: true
        });
        
        // 显示本地视频
        const localVideo = document.getElementById('localVideo') as HTMLVideoElement;
        localVideo.srcObject = localStream;
        
        // 创建连接请求
        const offer = await rtcManager.createOffer();
        
        // 发送offer到远端（通过信令服务器）
        // ...
        
    } catch (error) {
        console.error('Video call failed:', error);
    }
}

// 处理远端消息
function handleRemoteMessage(message: any) {
    switch (message.type) {
        case 'offer':
            rtcManager.handleRemoteDescription(message.offer);
            break;
            
        case 'answer':
            rtcManager.handleRemoteDescription(message.answer);
            break;
            
        case 'candidate':
            rtcManager.handleCandidate(message.candidate);
            break;
    }
}