deepvoice_client/lib/modules/chat/controllers/chat_controller.dart

import 'dart:async';
import 'package:get/get.dart';
import 'package:flutter/widgets.dart';
import 'package:get_storage/get_storage.dart';
import '../../../data/services/speech_impl/voice_clone_tts_service.dart';
import '../models/message_model.dart';
import '../../../core/utils/logger.dart';
import '../../../data/services/volcano_ai_service.dart';
import '../../../data/services/tts_service.dart';
import '../../../data/providers/agent_provider.dart';
import '../../../data/models/agent.dart';
import '../../../data/services/asr_service.dart';
import '../../../data/services/chat_history_service.dart';
import '../../../data/models/events/voice_interaction_event.dart';
import '../../../data/services/voice_interaction_service.dart';

class ChatController extends GetxController {
  // 服务
  final VolcanoAIService _aiService = Get.find<VolcanoAIService>();
  late TtsService _ttsService;
  final AsrService _asrService = Get.find<AsrService>();
  final ChatHistoryService _historyService = Get.find<ChatHistoryService>();
  final VoiceInteractionService _voiceInteractionService =
      Get.find<VoiceInteractionService>();

  // 添加ScrollController用于控制列表滚动
  final ScrollController scrollController = ScrollController();

  // Agent 信息
  late final Agent agent;

  // 消息列表
  final RxList<Message> messages = <Message>[].obs;

  // 输入控制
  final RxString inputText = ''.obs;

  // 状态控制
  final RxBool isLoading = false.obs;
  final RxBool isSending = false.obs;
  final RxBool isTtsEnabled = true.obs;
  final RxBool isVoiceRecognitionActive = false.obs;

  // 语音交互模式
  bool _isVoiceInteractionMode = false;

  // 语音识别状态
  final RxString recognizedText = ''.obs;
  final RxBool isListening = false.obs;
  final RxBool isSpeechDetected = false.obs;

  // 临时消息索引，用于更新临时消息
  int _tempMessageIndex = -1;

  // 防抖计时器
  Timer? _scrollDebounceTimer;

  // 流式响应控制
  StreamSubscription? _aiResponseSubscription;
  StreamSubscription? _recognitionSubscription;
  StreamSubscription? _voiceInteractionSubscription;

  // 取消标志
  bool _shouldCancelAiResponse = false;

  // 自动停止语音识别计时器
  Timer? _autoStopTimer;

  // 记录最后一次活动时间
  DateTime _lastActivityTime = DateTime.now();

  @override
  Future<void> onInit() async {
    super.onInit();
    Logger.info('ChatController onInit');

    // 从路由参数获取Agent信息
    final Map<String, dynamic> args = Get.arguments ?? {};
    final String agentId =
        args['agent'] ?? args['agentId'] ?? 'personal_assistant';

    // 获取Agent
    final Agent? foundAgent = AgentProvider.getAgentById(agentId);
    if (foundAgent == null) {
      Logger.error('无法找到Agent: $agentId');
      Get.back();
      return;
    }

    agent = foundAgent;

    final GetStorage storage = GetStorage();
    String timbre = storage.read('timbre') ?? '1';

    if (timbre == '1') {
      _ttsService = Get.find<TtsService>();
    } else {
      Get.put(VoiceCloneTtsService());
      _ttsService = Get.find<VoiceCloneTtsService>();
    }

    _ttsService.initialize();
    _asrService.initialize();

    // 设置语音交互模式
    _isVoiceInteractionMode = args['isVoiceInteraction'] == true;

    // 设置TTS服务
    await _ttsService.setVoice(agent.voice);

    // 加载聊天历史
    _loadChatHistory();

    // 如果没有历史记录，添加欢迎消息
    if (messages.isEmpty && agent.welcomeMessage.isNotEmpty) {
      messages.add(Message(
        role: 'assistant',
        content: agent.welcomeMessage,
        timestamp: DateTime.now(),
      ));
      // 如果启用了TTS，播放欢迎消息
      // if (isTtsEnabled.value) {
      //   _ttsService.speak(agent.welcomeMessage);
      // }
    }

    // 如果isVoiceInteraction为true，自动激活语音识别
    if (args['isVoiceInteraction'] == true) {
      _ttsService.speakOnce(agent.voiceWelcomeMessage ?? agent.welcomeMessage);
      startVoiceRecognition();
      // 自动停止计时器会在startVoiceRecognition中启动
    }

    // 订阅VoiceInteractionService事件
    _subscribeToVoiceInteractionEvents();

    // 使用微任务在布局完成后自动滚动到底部
    WidgetsBinding.instance.addPostFrameCallback((_) {
      _scrollToBottom();
    });
  }

  /// 订阅VoiceInteractionService事件
  void _subscribeToVoiceInteractionEvents() {
    if (_voiceInteractionService.eventStream != null) {
      _voiceInteractionSubscription =
          _voiceInteractionService.eventStream.listen((event) {
        if (event is RecognitionStartedEvent) {
          // 收到recognitionStarted事件时，停止当前的AI交互、录音和TTS
          _stopCurrentInteraction();
        } else if (event is ChatHistoryEvent) {
          // 收到聊天历史事件，添加到聊天记录
          _processChatHistoryEvent(event);
        }
      });
    }
  }

  /// 处理聊天历史事件
  void _processChatHistoryEvent(ChatHistoryEvent event) {
    Logger.info('收到后台聊天历史事件: agentId=${event.agentId}');

    // 如果消息不是空的且不是当前Agent的，不处理
    if (event.userMessage.isEmpty || event.agentId != agent.id) {
      return;
    }

    // 添加用户消息
    final userMsg = Message(
      role: 'user',
      content: event.userMessage,
      timestamp: DateTime.fromMillisecondsSinceEpoch(event.timestamp),
    );

    // 添加助手消息
    final assistantMsg = Message(
      role: 'assistant',
      content: event.assistantMessage,
      timestamp:
          DateTime.fromMillisecondsSinceEpoch(event.timestamp + 1), // 助手消息稍后一毫秒
    );

    // 防止消息重复
    if (!_isDuplicateMessage(userMsg) && !_isDuplicateMessage(assistantMsg)) {
      messages.add(userMsg);
      messages.add(assistantMsg);
    }
    _scrollToBottom();
  }

  /// 停止当前交互
  void _stopCurrentInteraction() {
    Logger.info('收到后台语音识别开始事件，停止当前AI交互');

    // 停止当前AI交互
    if (isSending.value || _aiResponseSubscription != null) {
      _interruptCurrentResponse("收到后台语音识别开始事件，中断当前响应");
    }

    // 停止TTS
    _ttsService.stop();

    // 停止语音识别
    if (isVoiceRecognitionActive.value) {
      stopVoiceRecognition();
    }
  }

  @override
  void onClose() {
    Logger.info('ChatController onClose');

    // 清理资源
    scrollController.dispose();
    _aiResponseSubscription?.cancel();
    _recognitionSubscription?.cancel();
    _voiceInteractionSubscription?.cancel();
    _autoStopTimer?.cancel();
    _scrollDebounceTimer?.cancel(); // 清理防抖计时器

    // 停止TTS
    _ttsService.stop();

    if (isVoiceRecognitionActive.value) {
      _asrService.stopContinuousRecognition();
    }

    // 保存当前聊天记录
    if (agent.id != null) {
      _historyService.saveHistory(agent.id!, messages.toList());
    }

    super.onClose();
  }

  /// 滚动到列表底部方法，添加防抖功能
  void _scrollToBottom() {
    if (scrollController.hasClients && messages.isNotEmpty) {
      try {
        scrollController.animateTo(
          scrollController.position.maxScrollExtent,
          duration: Duration(milliseconds: 300),
          curve: Curves.easeOut,
        );
      } catch (e) {
        Logger.error('滚动到底部失败', e);
      }
    }
  }

  /// 中断当前响应
  void _interruptCurrentResponse(String reason) {
    Logger.info('${reason}');

    // 停止TTS
    _ttsService.stop();

    // 取消AI响应流订阅
    if (_aiResponseSubscription != null) {
      _shouldCancelAiResponse = true;
      _aiResponseSubscription!.cancel();
      _aiResponseSubscription = null;

      // 将加载中的消息转换为正常消息，保留已输出的内容
      final index = messages.indexWhere((m) => m.isLoading);
      if (index != -1) {
        messages[index] = messages[index].copyWith(
          isLoading: false,
        );
        messages.refresh();
      }

      // 重置发送状态
      isSending.value = false;
    }
  }

  // 发送消息
  Future<void> sendMessage(String text) async {
    if (text.trim().isEmpty) return;

    _voiceInteractionService.pauseVoiceInteraction();

    // 中断当前响应
    _interruptCurrentResponse("发送新消息，中断当前响应");

    // 添加用户消息
    final userMessage = Message(
      role: 'user',
      content: text,
      timestamp: DateTime.now(),
    );
    messages.add(userMessage);

    // 清空输入框
    inputText.value = '';

    // 添加加载中的消息
    final loadingMessage = Message.loading();
    messages.add(loadingMessage);

    WidgetsBinding.instance.addPostFrameCallback((_) {
      _scrollToBottom();
    });

    isSending.value = true;

    try {
      // 构建消息历史
      final List<Map<String, String>> messageHistory = _buildMessageHistory();

      // 重置取消标志
      _shouldCancelAiResponse = false;

      String fullResponse = '';

      // 获取AI响应流
      final responseStream = _aiService.sendMessageStream(
        messages: messageHistory,
        systemPrompt: agent.systemPrompt,
      );

      // 订阅响应流
      _aiResponseSubscription = responseStream.listen(
        (chunk) {
          if (_shouldCancelAiResponse) return;

          fullResponse += chunk;

          // 更新加载中的消息内容
          _updateLoadingMessage(fullResponse);

          // 如果TTS启用，使用流式处理发送到TTS
          if (isTtsEnabled.value) {
            _ttsService.speakStream(chunk);
          }
        },
        onDone: () {
          if (_shouldCancelAiResponse) return;

          // 完成响应，将isLoading设为false
          _finalizeResponse(fullResponse);

          // 如果TTS启用，处理缓冲区中的剩余文本
          if (isTtsEnabled.value) {
            _ttsService.flushStream();
          }

          // 保存聊天历史
          _saveChatHistory();
        },
        onError: (error) {
          Logger.error('AI响应错误', error);

          // 更新加载中的消息为错误消息
          _handleResponseError();
        },
      );
    } catch (e) {
      Logger.error('发送消息失败', e);

      _handleResponseError();
    }
  }

  // 构建消息历史
  List<Map<String, String>> _buildMessageHistory() {
    final List<Map<String, String>> messageHistory = [];

    // 只取最近的10条消息作为上下文
    final recentMessages = messages.where((m) => !m.isLoading).toList();
    final startIndex =
        recentMessages.length > 10 ? recentMessages.length - 10 : 0;

    for (int i = startIndex; i < recentMessages.length; i++) {
      final m = recentMessages[i];
      messageHistory.add({
        'role': m.role,
        'content': m.content,
      });
    }

    return messageHistory;
  }

  // 更新加载中的消息
  void _updateLoadingMessage(String content) {
    final index = messages.indexWhere((m) => m.isLoading);
    if (index != -1) {
      messages[index] = messages[index].copyWith(
        content: content,
        isLoading: true,
      );
      messages.refresh();
      _scrollToBottom();
    }
  }

  // 完成响应
  void _finalizeResponse(String content) {
    final index = messages.indexWhere((m) => m.isLoading);
    if (index != -1) {
      messages[index] = messages[index].copyWith(
        content: content,
        isLoading: false,
      );
      messages.refresh();
      _scrollToBottom();
    }

    isSending.value = false;
    _aiResponseSubscription = null;
  }

  // 处理响应错误
  void _handleResponseError() {
    final index = messages.indexWhere((m) => m.isLoading);
    if (index != -1) {
      messages[index] = messages[index].copyWith(
        content: '抱歉，我遇到了一些问题，无法回应您的请求。',
        isLoading: false,
      );
      messages.refresh();
    }

    isSending.value = false;
    _aiResponseSubscription = null;
  }

  // 切换TTS状态
  void toggleTts() {
    isTtsEnabled.toggle();

    // 如果关闭TTS，停止当前播放
    if (!isTtsEnabled.value) {
      _ttsService.stop();
    }
  }

  // 开始语音识别
  Future<void> startVoiceRecognition() async {
    if (isVoiceRecognitionActive.value) return;

    _voiceInteractionService.pauseVoiceInteraction();
    try {
      // 启动连续语音识别
      // 注意：在UI更新后，使用模拟波形动画替代实际麦克风输入的波形数据
      final recognitionStream = await _asrService.startContinuousRecognition();

      isVoiceRecognitionActive.value = true;
      isListening.value = true;
      recognizedText.value = '';

      // 重置临时消息索引
      _tempMessageIndex = -1;

      // 启动自动停止计时器
      _startAutoStopTimer();

      // 监听识别事件
      _recognitionSubscription = recognitionStream.listen(
        _handleRecognitionEvent,
        onError: _handleRecognitionError,
      );
    } catch (e) {
      Logger.error('启动语音识别失败', e);
      isVoiceRecognitionActive.value = false;
      isListening.value = false;
    }
  }

  // 处理语音识别事件
  void _handleRecognitionEvent(RecognitionEvent event) {
    // 更新活动时间
    _updateActivityTime();

    switch (event.type) {
      case RecognitionEventType.intermediateResult:
        _handleRecognizing(event.text);
        break;
      case RecognitionEventType.finalResult:
        _handleFinalResult(event.text);
        break;
      case RecognitionEventType.error:
        _handleRecognitionEventError(event.error);
        break;
      default:
        // 不做任何处理
        break;
    }
  }

  // 更新最后活动时间
  void _updateActivityTime() {
    _lastActivityTime = DateTime.now();
  }

  // 启动自动停止计时器
  void _startAutoStopTimer() {
    // 取消现有计时器
    _autoStopTimer?.cancel();

    // 初始化最后活动时间
    _updateActivityTime();

    // 根据模式设置超时时间
    final int timeoutSeconds = _isVoiceInteractionMode ? 8 : 15;

    // 创建新的计时器，每秒检查一次
    _autoStopTimer = Timer.periodic(Duration(seconds: 1), (timer) {
      // 检查是否有活动
      bool isActive = _ttsService.isSpeaking || isSpeechDetected.value;

      // 如果有活动，更新时间并继续等待
      if (isActive) {
        _updateActivityTime();
        return;
      }

      // 检查空闲时间
      int idleSeconds = DateTime.now().difference(_lastActivityTime).inSeconds;
      if (idleSeconds >= timeoutSeconds) {
        timer.cancel();
        _stopVoiceRecognitionAutomatically();
      }
    });
  }

  // 处理语音识别中的状态
  void _handleRecognizing(String text) {
    if (text.isEmpty) return;

    recognizedText.value = text;

    // 设置语音检测状态为true，用于控制波形动画
    if (!isSpeechDetected.value) {
      isSpeechDetected.value = true;
    }

    // 更新活动时间
    _updateActivityTime();

    // 用户开始讲话时，立即停止当前TTS和中断AI响应
    if (isSending.value || _aiResponseSubscription != null) {
      _interruptCurrentResponse("检测到用户开始讲话，中断当前响应");
    }

    // 更新或创建临时消息
    if (_tempMessageIndex >= 0 && _tempMessageIndex < messages.length) {
      // 更新已有的临时消息
      messages[_tempMessageIndex] = messages[_tempMessageIndex].copyWith(
        content: text,
      );
      messages.refresh();
    } else {
      // 添加新的临时消息
      final tempMessage = Message(
        role: 'user',
        content: text,
        timestamp: DateTime.now(),
      );
      messages.add(tempMessage);
      _tempMessageIndex = messages.length - 1;
      messages.refresh();
    }
    WidgetsBinding.instance.addPostFrameCallback((_) {
      _scrollToBottom();
    });
  }

  // 处理语音识别最终结果
  void _handleFinalResult(String text) {
    if (text.isEmpty) return;

    Logger.info('处理语音识别最终结果: $text');
    recognizedText.value = text;

    // 更新活动时间
    _updateActivityTime();

    // 查找并移除临时消息
    if (_tempMessageIndex >= 0 && _tempMessageIndex < messages.length) {
      messages.removeAt(_tempMessageIndex);
    }

    // 重置临时消息索引
    _tempMessageIndex = -1;

    // 发送识别到的文本
    sendMessage(text);

    // 重置识别文本，但不关闭语音识别框
    recognizedText.value = '';

    // 重置语音检测状态
    isSpeechDetected.value = false;
  }

  // 处理语音识别事件错误
  void _handleRecognitionEventError(String? error) {
    Logger.error('语音识别错误: ${error ?? "未知错误"}');

    _cleanupRecognition();
  }

  // 处理语音识别流错误
  void _handleRecognitionError(dynamic error) {
    Logger.error('语音识别错误', error);

    _cleanupRecognition();
  }

  // 清理语音识别资源
  void _cleanupRecognition() {
    // 查找并移除临时消息
    if (_tempMessageIndex >= 0 && _tempMessageIndex < messages.length) {
      if (messages[_tempMessageIndex].content.trim().isEmpty) {
        messages.removeAt(_tempMessageIndex);
      }
    }

    // 重置临时消息索引
    _tempMessageIndex = -1;

    // 停止语音识别
    isVoiceRecognitionActive.value = false;
    isListening.value = false;
    isSpeechDetected.value = false;
    _asrService.stopContinuousRecognition();
  }

  // 停止语音识别
  Future<void> stopVoiceRecognition() async {
    if (!isVoiceRecognitionActive.value) return;

    try {
      await _asrService.stopContinuousRecognition();
      _recognitionSubscription?.cancel();
      _recognitionSubscription = null;

      isVoiceRecognitionActive.value = false;
      isListening.value = false;
      recognizedText.value = '';
      isSpeechDetected.value = false;

      // 查找并移除临时消息
      if (_tempMessageIndex >= 0 && _tempMessageIndex < messages.length) {
        if (messages[_tempMessageIndex].content.trim().isEmpty) {
          messages.removeAt(_tempMessageIndex);
        }
      }

      // 重置临时消息索引
      _tempMessageIndex = -1;
    } catch (e) {
      Logger.error('停止语音识别失败', e);
    }
  }

  // 清空聊天记录
  void clearChat() {
    messages.clear();

    // 添加欢迎消息
    if (agent.welcomeMessage.isNotEmpty) {
      messages.add(Message(
        role: 'assistant',
        content: agent.welcomeMessage,
        timestamp: DateTime.now(),
      ));
    }

    // 删除存储的历史记录
    _historyService.clearHistory(agent.id);
  }

  // 加载聊天历史
  void _loadChatHistory() {
    // 从历史服务加载
    final history = _historyService.loadHistory(agent.id);
    if (history.isNotEmpty) {
      messages.clear();
      messages.addAll(history);
    }
  }

  // 保存聊天历史
  void _saveChatHistory() {
    _historyService.saveHistory(agent.id, messages);
  }

  // 添加消息，供外部调用
  void addMessage(Message message) {
    messages.add(message);
    _saveChatHistory();
    _scrollToBottom();
  }

  void _stopVoiceRecognitionAutomatically() {
    final int timeoutSeconds = _isVoiceInteractionMode ? 8 : 15;
    Logger.info('${timeoutSeconds}秒无活动，自动停止语音识别');
    stopVoiceRecognition();
  }

  /// 检查是否为重复消息
  bool _isDuplicateMessage(Message message) {
    return messages.any((m) =>
        m.role == message.role &&
        m.content == message.content &&
        (m.timestamp.millisecondsSinceEpoch -
                    message.timestamp.millisecondsSinceEpoch)
                .abs() <
            5000);
  }
}