// AIfeng/2025-07-08 15:59:04
// 服务端录音前端模块 - WebSocket通信和UI控制
// 核心功能：服务端录音控制、识别结果接收、状态同步

class ServerRecordingClient {
    constructor(options = {}) {
        this.options = {
            wsUrl: options.wsUrl || `ws://${window.location.host}/ws/server-recording`,
            sessionId: options.sessionId || `session_${Date.now()}`,
            autoReconnect: options.autoReconnect !== false,
            reconnectInterval: options.reconnectInterval || 3000,
            maxReconnectAttempts: options.maxReconnectAttempts || 5,
            ...options
        };
        
        this.ws = null;
        this.isConnected = false;
        this.isRecording = false;
        this.reconnectAttempts = 0;
        this.reconnectTimer = null;
        
        // 事件回调
        this.onConnected = null;
        this.onDisconnected = null;
        this.onRecordingStarted = null;
        this.onRecordingStopped = null;
        this.onPartialResult = null;
        this.onFinalResult = null;
        this.onSessionComplete = null;
        this.onStatusUpdate = null;
        this.onError = null;
        
        console.log('ServerRecordingClient初始化完成', this.options);
    }
    
    /**
     * 连接到服务端录音WebSocket
     */
    async connect() {
        try {
            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
                console.log('WebSocket已连接，跳过重复连接');
                return true;
            }
            
            console.log('正在连接服务端录音WebSocket:', this.options.wsUrl);
            
            this.ws = new WebSocket(this.options.wsUrl);
            
            return new Promise((resolve, reject) => {
                const timeout = setTimeout(() => {
                    reject(new Error('连接超时'));
                }, 10000);
                
                this.ws.onopen = () => {
                    clearTimeout(timeout);
                    console.log('WebSocket连接已建立');
                    this.isConnected = true;
                    this.reconnectAttempts = 0;
                    
                    // 发送连接请求
                    this.sendMessage({
                        type: 'connect',
                        session_id: this.options.sessionId
                    });
                    
                    resolve(true);
                };
                
                this.ws.onmessage = (event) => {
                    this.handleMessage(event.data);
                };
                
                this.ws.onclose = (event) => {
                    clearTimeout(timeout);
                    console.log('WebSocket连接关闭:', event.code, event.reason);
                    this.isConnected = false;
                    this.isRecording = false;
                    
                    if (this.onDisconnected) {
                        this.onDisconnected(event);
                    }
                    
                    // 自动重连
                    if (this.options.autoReconnect && this.reconnectAttempts < this.options.maxReconnectAttempts) {
                        this.scheduleReconnect();
                    }
                };
                
                this.ws.onerror = (error) => {
                    clearTimeout(timeout);
                    console.error('WebSocket错误:', error);
                    
                    if (this.onError) {
                        this.onError(error);
                    }
                    
                    reject(error);
                };
            });
            
        } catch (error) {
            console.error('连接失败:', error);
            if (this.onError) {
                this.onError(error);
            }
            throw error;
        }
    }
    
    /**
     * 断开连接
     */
    disconnect() {
        if (this.reconnectTimer) {
            clearTimeout(this.reconnectTimer);
            this.reconnectTimer = null;
        }
        
        if (this.ws) {
            this.ws.close();
            this.ws = null;
        }
        
        this.isConnected = false;
        this.isRecording = false;
        console.log('WebSocket连接已断开');
    }
    
    /**
     * 开始服务端录音
     */
    async startRecording(config = {}) {
        try {
            if (!this.isConnected) {
                throw new Error('WebSocket未连接');
            }
            
            if (this.isRecording) {
                console.log('录音已在进行中');
                return false;
            }
            
            console.log('开始服务端录音', config);
            
            this.sendMessage({
                type: 'start_recording',
                session_id: this.options.sessionId,
                config: config
            });
            
            return true;
            
        } catch (error) {
            console.error('开始录音失败:', error);
            if (this.onError) {
                this.onError(error);
            }
            throw error;
        }
    }
    
    /**
     * 停止服务端录音
     */
    async stopRecording() {
        try {
            if (!this.isConnected) {
                throw new Error('WebSocket未连接');
            }
            
            if (!this.isRecording) {
                console.log('没有正在进行的录音');
                return false;
            }
            
            console.log('停止服务端录音');
            
            this.sendMessage({
                type: 'stop_recording',
                session_id: this.options.sessionId
            });
            
            return true;
            
        } catch (error) {
            console.error('停止录音失败:', error);
            if (this.onError) {
                this.onError(error);
            }
            throw error;
        }
    }
    
    /**
     * 获取录音状态
     */
    async getStatus() {
        try {
            if (!this.isConnected) {
                throw new Error('WebSocket未连接');
            }
            
            this.sendMessage({
                type: 'get_status',
                session_id: this.options.sessionId
            });
            
        } catch (error) {
            console.error('获取状态失败:', error);
            if (this.onError) {
                this.onError(error);
            }
            throw error;
        }
    }
    
    /**
     * 发送消息到服务端
     */
    sendMessage(message) {
        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
            this.ws.send(JSON.stringify(message));
        } else {
            console.error('WebSocket未连接，无法发送消息:', message);
        }
    }
    
    /**
     * 处理服务端消息
     */
    handleMessage(data) {
        try {
            const message = JSON.parse(data);
            console.log('收到服务端消息:', message);
            
            switch (message.type) {
                case 'connected':
                    this.handleConnected(message);
                    break;
                    
                case 'recording_started':
                    this.handleRecordingStarted(message);
                    break;
                    
                case 'recording_stopped':
                    this.handleRecordingStopped(message);
                    break;
                    
                case 'asr_partial_result':
                    this.handlePartialResult(message);
                    break;
                    
                case 'asr_final_result':
                    this.handleFinalResult(message);
                    break;
                    
                case 'asr_session_complete':
                    this.handleSessionComplete(message);
                    break;
                    
                case 'status_update':
                    this.handleStatusUpdate(message);
                    break;
                    
                case 'status':
                    this.handleStatus(message);
                    break;
                    
                case 'error':
                    this.handleError(message);
                    break;
                    
                case 'warning':
                    this.handleWarning(message);
                    break;
                    
                case 'pong':
                    // 心跳响应
                    break;
                    
                default:
                    console.log('未知消息类型:', message.type);
            }
            
        } catch (error) {
            console.error('处理消息失败:', error, data);
        }
    }
    
    /**
     * 处理连接成功
     */
    handleConnected(message) {
        console.log('服务端录音连接成功:', message);
        if (this.onConnected) {
            this.onConnected(message);
        }
    }
    
    /**
     * 处理录音开始
     */
    handleRecordingStarted(message) {
        console.log('服务端录音已开始:', message);
        this.isRecording = true;
        if (this.onRecordingStarted) {
            this.onRecordingStarted(message);
        }
    }
    
    /**
     * 处理录音停止
     */
    handleRecordingStopped(message) {
        console.log('服务端录音已停止:', message);
        this.isRecording = false;
        if (this.onRecordingStopped) {
            this.onRecordingStopped(message);
        }
    }
    
    /**
     * 处理部分识别结果
     */
    handlePartialResult(message) {
        console.log('部分识别结果:', message.data);
        if (this.onPartialResult) {
            this.onPartialResult(message.data, message);
        }
    }
    
    /**
     * 处理最终识别结果
     */
    handleFinalResult(message) {
        console.log('最终识别结果:', message.data);
        if (this.onFinalResult) {
            this.onFinalResult(message.data, message);
        }
    }
    
    /**
     * 处理会话完成
     */
    handleSessionComplete(message) {
        console.log('识别会话完成:', message.data);
        if (this.onSessionComplete) {
            this.onSessionComplete(message.data, message);
        }
    }
    
    /**
     * 处理状态更新
     */
    handleStatusUpdate(message) {
        console.log('状态更新:', message.data);
        if (this.onStatusUpdate) {
            this.onStatusUpdate(message.data, message);
        }
    }
    
    /**
     * 处理状态查询结果
     */
    handleStatus(message) {
        console.log('当前状态:', message.data);
        this.isRecording = message.data.recording || false;
        if (this.onStatusUpdate) {
            this.onStatusUpdate(message.data, message);
        }
    }
    
    /**
     * 处理错误
     */
    handleError(message) {
        console.error('服务端错误:', message.message);
        if (this.onError) {
            this.onError(new Error(message.message), message);
        }
    }
    
    /**
     * 处理警告
     */
    handleWarning(message) {
        console.warn('服务端警告:', message.message);
    }
    
    /**
     * 安排重连
     */
    scheduleReconnect() {
        if (this.reconnectTimer) {
            clearTimeout(this.reconnectTimer);
        }
        
        this.reconnectAttempts++;
        console.log(`安排重连 (${this.reconnectAttempts}/${this.options.maxReconnectAttempts})`);
        
        this.reconnectTimer = setTimeout(() => {
            this.connect().catch(error => {
                console.error('重连失败:', error);
            });
        }, this.options.reconnectInterval);
    }
    
    /**
     * 发送心跳
     */
    ping() {
        this.sendMessage({ type: 'ping' });
    }
    
    /**
     * 获取连接状态
     */
    getConnectionState() {
        return {
            isConnected: this.isConnected,
            isRecording: this.isRecording,
            sessionId: this.options.sessionId,
            reconnectAttempts: this.reconnectAttempts
        };
    }
}

// 导出类
if (typeof module !== 'undefined' && module.exports) {
    module.exports = ServerRecordingClient;
} else if (typeof window !== 'undefined') {
    window.ServerRecordingClient = ServerRecordingClient;
}