import 'dart:io';
import 'dart:async';

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:get/get.dart';
import 'package:get_storage/get_storage.dart';
import 'package:intl/intl.dart';
import 'package:floating_ui_plugin/native_plugin.dart';
import 'package:path_provider/path_provider.dart';
import 'package:permission_handler/permission_handler.dart';
import 'package:device_info_plus/device_info_plus.dart';
import 'package:pip/pip.dart';
import 'package:voitrans/data/services/qq_music.dart';
import '../../../data/services/ast_service.dart';
import '../../../data/services/bluetooth_manager.dart';
import '../../../data/services/music_manager.dart';
import '../../../data/services/translation_usage_service.dart';
import '../../../data/services/volcano_translation_service.dart';
import '../../../data/services/tts_service.dart';
import '../../../data/services/language_manager.dart';
import '../../../core/utils/logger.dart';
import '../../../core/utils/permission_util.dart';
import '../../../core/services/floating_window_manager.dart';

import '../../../data/services/asr_service.dart';
import '../../../data/services/usage_stats_service.dart';
import '../../../data/services/ble_manager.dart';
import 'record_timer_controller.dart';
import 'translation_history_controller.dart';
import '../models/translation_models.dart';
import '../views/dialogs/translation_mode_selector.dart';
import '../../../data/models/user_Info.dart';
import '../../common/widgets/recharge_dialog.dart';

/// 音频输出设备枚举
enum AudioOutputDevice {
  defaultDevice, // 默认（如有耳机优先耳机，否则扬声器）
  headphones, // 强制耳机
  speaker, // 强制扬声器
}

/// 翻译主控制器 - 负责管理语音识别、翻译和TTS功能(主控制器)
class TranslationController extends GetxController with WidgetsBindingObserver {
  static const String TAG = 'TranslationController';

  // ==================== 服务依赖 ====================
  final AsrService _asrService = Get.find<AsrService>();
  final VolcanoTranslationService _translationService =
      Get.find<VolcanoTranslationService>();
  final TtsService _ttsService = Get.find<TtsService>();
  final AstService _astService = Get.find<AstService>();
  final LanguageManager _languageManager = Get.find<LanguageManager>();
  /// 最近一次通话模式初始化所选中的 AST provider，仅用于日志追踪
  String _lastCallAstProvider = '';
  final GetStorage _storage = GetStorage();
  final BluetoothManager bluetoothManager = Get.find<BluetoothManager>();
  final BleManager bleManager = Get.find<BleManager>();
  final _musiceManager = Get.find<MusicManager>();
  final _qqMusicManager = Get.find<QqMusicService>();
  late final UsageStatsService _usageService;
  // 安卓悬浮窗管理器
  late final FloatingWindowManager _floatingWindowManager;
  // 苹果悬浮窗管理器
  late final Pip _pip;
  late final NativePlugin _nativePlugin;
  int _pipContentView = 0;
  static const int _pipPreferredWidth = 375;
  static const int _pipCompactPreferredHeight = 72;
  static const int _pipExpandedPreferredHeight = 220;
  bool _isPipExpanded = false;

  // ==================== 悬浮窗相关 ====================
  final isFloatingWindowEnabled = false.obs; // 悬浮窗状态

  // ==================== ASR统计相关 ====================
  DateTime? _asrSessionStartTime; // ASR会话开始时间
  DateTime? _asrActiveStartTime; // ASR活跃开始时间（用户实际开始语音识别的时间）
  Duration _asrActiveDuration = Duration.zero; // ASR累计活跃时长
  bool _isAsrActive = false; // ASR是否处于活跃状态

  // ==================== 配置相关 ====================
  bool _audioSourceType = false; // 音频输入源类型
  bool isPlayback = false; // 是否开启播放
  bool isContinuePlaying = false; // 是否继续播放
  bool _isContinueQqMusicPlaying = false; // 是否继续播放QQ音乐

  // 存储相关配置
  static const String _sourceLanguageKey = 'translation_source_language';
  static const String _targetLanguageKey = 'translation_target_language';
  static const String _sourceLanguageUserSetKey =
      'translation_source_language_user_set';
  // 添加悬浮按钮位置存储键
  static const String _floatingButtonPositionKey = 'floating_button_position';

  // 分页加载相关状态
  final pageSize = 20; // 每页记录数量
  bool _scrollListenerSetup = false; // 滚动监听器设置标志

  // ==================== 状态变量 ====================
  RxInt activeSpeaker = 0.obs; // 0=无激活, 1=按钮1, 2=按钮2
  RxInt lastActiveSpeaker = 0.obs; // 上一次状态
  final isRecognizing = false.obs;
  final isPreparing = false.obs;
  final isTranslating = false.obs;
  final isTtsEnabled = true.obs;
  final isRecording = false.obs;
  final isCreateRecord = false.obs;
  final hasRecordPermission = false.obs;

  // 添加悬浮按钮位置状态
  final floatingButtonPosition = Rx<Offset>(Offset(2.0, 100.0)); // 默认位置

  // ==================== 语言相关 ====================
  final sourceLanguage = '中文(简体)'.tr.obs;
  final targetLanguage = '英语'.tr.obs;
  final sourceLanguageCode = 'zh-CN'.obs;
  final targetLanguageCode = 'en-US'.obs;
  var detectedLanguageCode = '';
  final detectedLanguageCode1 = ''.obs;
  final latestRecognitionText = ''.obs;
  final faceToFaceRecognitionText = ''.obs;
  // ==================== 翻译相关 ====================
  var currsessionid = '';
  final currentModeTitle = 'simultaneousTranslation'.obs;
  final currentMode = 'simultaneous'.obs;
  //String? fTFTranslationResult = '';
  String? currentSessionId;
  final appDocDir = getApplicationDocumentsDirectory();
  var appDir;
  var dir;

  // ==================== 管理器 ====================
  late final RecordTimerController _timerManager;
  late final TranslationHistoryManager _historyManager;

  // ==================== 访问器 ====================
  RxString get recordDurationText => _timerManager.recordDurationText;
  RxList<TranslationItem> get translationHistory =>
      _historyManager.translationHistory;
  ScrollController get scrollController => _historyManager.scrollController;
  RxBool get hasMoreHistory => _historyManager.hasMoreHistory;
  RxBool get isLoadingMore => _historyManager.isLoadingMore;
  RxBool get isLoadingMoreError => _historyManager.isLoadingMoreError;
  Map<String, String> get supportedLanguages =>
      _languageManager.getChineseNameToAsrCodeMap();

  // ==================== 流订阅 ====================
  StreamSubscription? _recognitionSubscription;
  StreamSubscription? _astEventSubscription;
  StreamSubscription? _voiceInteractionSubscription;
  Timer? _translationDebounceTimer;

  // ==================== 重新初始化守卫 ====================
  bool _isReinitializing = false; // 语言切换重新初始化期间为 true，抑制旧会话的错误事件

  // 语言切换互斥：连续切换语言时串行执行，避免并发的 _reinitializeAsrService 导致
  // 原生 AST 已启动但 isRecognizing 仍为 false 的状态不一致。
  Future<void>? _languageSwitchChain;

  // 播放防重复机制
  String? _lastPlayedItemKey; // 最后播放的项目标识
  int _lastPlayTime = 0; // 最后播放时间
  static const int _playDebounceInterval = 500; // 防抖间隔：500毫秒

  // 底部控制栏高度
  double _bottomBarHeight = 0.0;

  /// 初始化安卓悬浮窗管理器
  void _initFloatingWindowManager() {
    try {
      if (!Get.isRegistered<FloatingWindowManager>()) {
        Get.put(FloatingWindowManager(), permanent: true);
      }
      _floatingWindowManager = Get.find<FloatingWindowManager>();
      Logger.info('悬浮窗管理器初始化完成');
    } catch (e) {
      Logger.error('悬浮窗管理器初始化失败: $e');
    }
  }

  /// 初始化苹果悬浮窗管理器
  Future<void> initPlatformState() async {
    _pip = Pip();
    _nativePlugin = NativePlugin();
    try {
      isFloatingWindowEnabled.value = await _pip.isActived();
      await _pip.registerStateChangedObserver(
        PipStateChangedObserver(
          onPipStateChanged: (state, error) {
            isFloatingWindowEnabled.value = state == PipState.pipStateStarted;

            if (state == PipState.pipStateFailed) {
              _isPipExpanded = false;
              _pip.dispose();
            } else if (state == PipState.pipStateStopped) {
              _isPipExpanded = false;
            }
          },
        ),
      );
    } on PlatformException {
      isFloatingWindowEnabled.value = false;
    }
  }

  /// 切换悬浮窗功能
  Future<void> toggleFloatingWindow() async {
    if (isFloatingWindowEnabled.value) {
      if (Platform.isAndroid) {
        await _disableFloatingWindow();
      } else if (Platform.isIOS) {
        _isPipExpanded = false;
        await _pip.dispose();
      }
    } else {
      if (Platform.isAndroid) {
        await _enableFloatingWindow();
      } else if (Platform.isIOS) {
        await _startPip();
      }
    }
  }

  PipOptions _buildIosPipOptions({required int preferredHeight}) {
    return PipOptions(
      autoEnterEnabled: true,
      aspectRatioX: _pipPreferredWidth,
      aspectRatioY: preferredHeight,
      sourceRectHintLeft: 0,
      sourceRectHintTop: 0,
      sourceRectHintRight: 0,
      sourceRectHintBottom: 0,
      seamlessResizeEnabled: true,
      useExternalStateMonitor: true,
      externalStateMonitorInterval: 100,
      contentView: _pipContentView,
      preferredContentWidth: _pipPreferredWidth,
      preferredContentHeight: preferredHeight,
      controlStyle: 2,
    );
  }

  Future<void> _startPip() async {
    if (_pipContentView == 0) {
      _pipContentView = await _nativePlugin.createPipContentView();
    }
    _isPipExpanded = false;
    await _pip.setup(
        _buildIosPipOptions(preferredHeight: _pipCompactPreferredHeight));
    await _pip.start();
  }

  /// 启用悬浮窗功能
  Future<void> _enableFloatingWindow() async {
    // 检查是否在支持悬浮窗的模式
    if (!_isFloatingWindowSupportedMode()) {
      // Get.snackbar(
      //   'unsupportedMode'.tr,
      //   '悬浮窗仅支持通话和音视频翻译模式',
      //   snackPosition: SnackPosition.TOP,
      // );
      return;
    }

    final bool success = await _floatingWindowManager.enableFloatingWindow();
    if (success) {
      isFloatingWindowEnabled.value = true;
      await _floatingWindowManager.showFloatingWindow();

      // 如果当前有翻译内容，立即更新到悬浮窗
      if (translationHistory.isNotEmpty) {
        final latestItem = translationHistory.last;
        await _updateFloatingWindowWithTranslation(latestItem);
      }

      // Get.snackbar(
      //   '悬浮窗已启用',
      //   '翻译结果将在悬浮窗中显示',
      //   snackPosition: SnackPosition.TOP,
      // );
    }
  }

  /// 禁用悬浮窗功能
  Future<void> _disableFloatingWindow() async {
    await _floatingWindowManager.disableFloatingWindow();
    isFloatingWindowEnabled.value = false;

    // Get.snackbar(
    //   '悬浮窗已禁用',
    //   '翻译结果将在应用内显示',
    //   snackPosition: SnackPosition.TOP,
    // );
  }

  /// 检查当前模式是否支持悬浮窗
  bool _isFloatingWindowSupportedMode() {
    return currentMode.value == 'call' || currentMode.value == 'audioVideo';
  }

  /// 更新悬浮窗翻译内容
  Future<void> _updateFloatingWindowWithTranslation(
      TranslationItem item) async {
    if (!isFloatingWindowEnabled.value) return;

    final sourceLanguageName =
        _languageManager.getChineseNameByAsrCode(item.sourceLanguageCode) ??
            'unknown';
    final targetLanguageName =
        _languageManager.getChineseNameByAsrCode(item.targetLanguageCode) ??
            'unknown';

    if (Platform.isAndroid) {
      final data = FloatingWindowData(
        sourceText: item.sourceText,
        translatedText: item.translatedText,
        sourceLanguage: sourceLanguageName,
        targetLanguage: targetLanguageName,
        timestamp: item.timestamp,
        isIntermediate: item.isIntermediate,
      );
      await _floatingWindowManager.updateFloatingWindowContent(data);
    } else if (Platform.isIOS) {
      final hasContent = item.sourceText.trim().isNotEmpty ||
          item.translatedText.trim().isNotEmpty;
      if (hasContent && !_isPipExpanded) {
        final ok = await _pip.setup(
            _buildIosPipOptions(preferredHeight: _pipExpandedPreferredHeight));
        if (ok) _isPipExpanded = true;
      } else if (!hasContent && _isPipExpanded) {
        final ok = await _pip.setup(
            _buildIosPipOptions(preferredHeight: _pipCompactPreferredHeight));
        if (ok) _isPipExpanded = false;
      }
      await _nativePlugin.updatePipContentView({
        'viewId': _pipContentView,
        'cn': item.sourceText,
        'en': item.translatedText,
        'lang': '$sourceLanguageName -> $targetLanguageName',
      });
    }
  }

  /// 更改翻译模式
  /// 参数：
  /// - [mode] 翻译模式：simultaneous(同声传译)、audioVideo(音视频)、call(通话)、faceToFace(面对面)
  /// 返回值：无
  /// 异常：可能抛出底层服务调用异常
  Future<void> changeTranslationMode(String mode) async {
    currentMode.value = mode;
    currentModeTitle.value = _getModeTitle(mode);
    _historyManager.setMode(mode);
    loadTranslationHistory();
    //stopAll();

    if (mode == 'faceToFace' || mode == 'call' || mode == 'simultaneous') {
      await suspendOtherServices();
    }

    if (Platform.isAndroid && (mode == 'call' || mode == 'audioVideo')) {
      try {
        _floatingWindowManager.setLastTranslationMode(mode);
      } catch (_) {}
    }

    //设置播报的模式
    if (mode == 'simultaneous') {
      await _ttsService.setTtsMode('phone_call');
    } else if (mode == 'faceToFace') {
      await _ttsService.setTtsMode('push_to_talk');
    } else {
      await _ttsService.setTtsMode('normal');
    }

    // 检查悬浮窗支持情况
    if (isFloatingWindowEnabled.value && !_isFloatingWindowSupportedMode()) {
      // 当前模式不支持悬浮窗，自动禁用
      await _disableFloatingWindow();
      // Get.snackbar(
      //   '模式已切换',
      //   '悬浮窗仅支持通话和音视频翻译模式',
      //   snackPosition: SnackPosition.TOP,
      // );
    } else if (!isFloatingWindowEnabled.value &&
        _isFloatingWindowSupportedMode()) {
      // 切换到支持悬浮窗的模式，提示用户可以启用
      // Get.snackbar(
      //   '模式已切换',
      //   '可以启用悬浮窗显示翻译结果',
      //   snackPosition: SnackPosition.TOP,
      //   duration: const Duration(seconds: 4),
      // );
    }

    if (mode == 'call') {
      await _initializeCallModeTranslationService();
    } else {
      await _reinitializeAsrService();
    }
  }

  /// 根据模式获取标题
  /// [mode] 翻译模式
  /// 返回对应的标题字符串
  String _getModeTitle(String mode) {
    switch (mode) {
      case 'audioVideo':
        return 'audioVideoTranslation';
      case 'call':
        return 'callTranslation';
      case 'faceToFace':
        return 'faceToFaceTranslation';
      default:
        return 'simultaneousTranslation';
    }
  }

  // ==================== 计时器相关方法 ====================
  /// 暂停录音计时器
  void pauseRecordTimer() => _timerManager.pauseTimer();

  /// 恢复录音计时器
  void resumeRecordTimer() => _timerManager.resumeTimer();

  /// 重置录音计时器
  void resetRecordTimer() => _timerManager.resetTimer();

  /// 设置激活的说话者（支持按住说话模式）
  /// [id] 说话者ID：0=无激活, 1=按钮1, 2=按钮2
  Future<void> setActiveSpeaker(int id) async {
    await _handleFaceToFaceHoldToTalk(id);
  }

  /// 处理面对面翻译的按住说话逻辑
  /// [id] 说话者ID
  Future<void> _handleFaceToFaceHoldToTalk(int id) async {
    if (id == 0) {
      // 松开按钮，停止当前激活的说话者
      if (activeSpeaker.value != 0) {
        lastActiveSpeaker.value = activeSpeaker.value; // 记录上一次激活的说话者
        activeSpeaker.value = id;
        await _stopFaceToFaceRecognition();
      }
    } else {
      // 按下按钮，只有在没有其他按钮激活时才能激活
      if (activeSpeaker.value == 0) {
        activeSpeaker.value = id;
        await _startFaceToFaceRecognition(id);
      }
    }
  }

  /// 开始面对面翻译的语音识别
  /// [speakerId] 说话者ID
  Future<void> _startFaceToFaceRecognition(int speakerId) async {
    try {
      if (User.isLoggedIn() && User.instance.tradeintegral <= 0) {
        showRechargeDialog('translation');
        activeSpeaker.value = 0;
        return;
      }
      if (_asrSessionStartTime == null) {
        await _initializeSession();
      }
      await _asrService.startContinuousRecognition(
        _audioSourceType,
        isRemoveFirstPunctuation: true,
        mode: 'push_to_talk',
      ); //开启识别
      _startAsrActiveTracking(); //开启识别活动跟踪
      if (isRecording.value) {
        if (isCreateRecord.value) {
          //已经创建文件
          await continueRecording();
        } else {
          await startRecording();
        }
      }
      Logger.info('面对面翻译：激活说话者 $speakerId');
    } catch (e) {
      Logger.error('启动面对面翻译失败: ${e.toString()}');
      activeSpeaker.value = 0;
    }
  }

  /// 停止面对面翻译的语音识别
  Future<void> _stopFaceToFaceRecognition() async {
    try {
      if (isRecording.value) {
        await pauseRecording(); //暂停
      }
      if (faceToFaceRecognitionText.value.isNotEmpty) {
        handleFinalResult(faceToFaceRecognitionText.value);
        faceToFaceRecognitionText.value = '';
      }
      await _asrService.stopContinuousRecognition();
      _stopAsrActiveTracking(); //停止识别活动跟踪
      _recordAsrUsageStats(sourceLanguage.value);
      isRecognizing.value = false;
      currentSessionId = null;

      Logger.info('面对面翻译：停止语音识别');
    } catch (e) {
      Logger.error('停止面对面翻译失败: ${e.toString()}');
    }
  }

  /// 获取当前翻译项（兼容旧版视图）
  Rx<TranslationItem?> get currentItem {
    if (translationHistory.isNotEmpty &&
        translationHistory.last.isIntermediate) {
      return Rx<TranslationItem?>(translationHistory.last);
    }
    return Rx<TranslationItem?>(null);
  }

  @override
  void onInit() {
    super.onInit();
    // 初始化管理器
    _timerManager = RecordTimerController();
    _historyManager = TranslationHistoryManager();

    if (Platform.isAndroid) {
      // 初始化安卓悬浮窗管理器
      _initFloatingWindowManager();
    } else if (Platform.isIOS) {
      // 初始化苹果悬浮窗管理器
      initPlatformState();
    }

    // 预先检查权限，避免在用户交互时阻塞
    _preCheckPermissions();

    // 初始化统计服务
    _initUsageService();

    // 加载上次保存的语言设置
    _loadSavedLanguages();

    // 初始化语言代码
    final sourceAsrCode =
        _languageManager.getAsrCodeByChineseName(sourceLanguage.value);
    if (sourceAsrCode != null) {
      sourceLanguageCode.value = sourceAsrCode;
    }

    final targetAsrCode =
        _languageManager.getAsrCodeByChineseName(targetLanguage.value);
    if (targetAsrCode != null) {
      targetLanguageCode.value = targetAsrCode;
    }

    // 初始化翻译模式（用于历史隔离的初始加载）
    final initMode = Get.arguments?['translationId'] ?? 'simultaneous';
    _historyManager.setMode(initMode);

    // 按初始模式加载历史
    loadTranslationHistory();

    // 初始化服务
    _initServices();

    // 初始化历史管理器
    _historyManager.initialize();

    // 应用模式逻辑（含ASR/TTS配置等）
    changeTranslationMode(initMode);

    // 监听应用生命周期：当应用切到后台/失焦时兜底重置 activeSpeaker
    WidgetsBinding.instance.addObserver(this);
  }

  // @override
  // void onReady() {
  //   super.onReady();
  //   // 初始化翻译模式,根据跳转参数
  //   final mode = Get.arguments?['translationId'] ?? 'simultaneous';
  //   changeTranslationMode(mode);
  // }

  /// 预先检查权限
  Future<void> _preCheckPermissions() async {
    try {
      await requestRecordPermission();
    } catch (e) {
      Logger.e("Permission", "预检查权限失败: $e");
    }
  }

  /// 初始化用量统计服务
  void _initUsageService() {
    try {
      // 确保统计服务已注册
      if (!Get.isRegistered<UsageStatsService>()) {
        Get.put(UsageStatsService(), permanent: true);
      }
      _usageService = Get.find<UsageStatsService>();
      Logger.info('使用量统计服务初始化完成');
    } catch (e) {
      Logger.error('使用量统计服务初始化失败: $e');
    }
  }

  /// 加载保存的语言设置
  void _loadSavedLanguages() {
    final appDefaultSourceLanguage = _getSourceLanguageByAppLocale();
    final savedSourceLanguage = _storage.read(_sourceLanguageKey);
    final savedTargetLanguage = _storage.read(_targetLanguageKey);
    final bool isSourceLanguageUserSet =
        (_storage.read(_sourceLanguageUserSetKey) ?? false) == true;

    final bool isSavedSourceValid = savedSourceLanguage != null &&
        supportedLanguages.containsKey(savedSourceLanguage);
    final bool isSavedTargetValid = savedTargetLanguage != null &&
        supportedLanguages.containsKey(savedTargetLanguage);

    if (isSourceLanguageUserSet && isSavedSourceValid) {
      sourceLanguage.value = savedSourceLanguage;
    } else if (appDefaultSourceLanguage != null &&
        supportedLanguages.containsKey(appDefaultSourceLanguage)) {
      sourceLanguage.value = appDefaultSourceLanguage;
    } else if (isSavedSourceValid) {
      sourceLanguage.value = savedSourceLanguage;
    }

    if (isSavedTargetValid) {
      targetLanguage.value = savedTargetLanguage;
    }

    // 加载悬浮按钮位置
    _loadFloatingButtonPosition();
  }

  /// 加载悬浮按钮位置
  void _loadFloatingButtonPosition() {
    final savedPosition = _storage.read(_floatingButtonPositionKey);
    if (savedPosition != null && savedPosition is Map) {
      final dx = savedPosition['dx']?.toDouble() ?? 2.0;
      final dy = savedPosition['dy']?.toDouble() ?? 100.0;
      floatingButtonPosition.value = Offset(dx, dy);
    }
  }

  /// 保存悬浮按钮位置
  void saveFloatingButtonPosition(Offset position) {
    floatingButtonPosition.value = position;
    _storage.write(_floatingButtonPositionKey, {
      'dx': position.dx,
      'dy': position.dy,
    });
  }

  void _saveSourceLanguageSetting({required bool isUserSet}) {
    _storage.write(_sourceLanguageKey, sourceLanguage.value);
    if (isUserSet) {
      _storage.write(_sourceLanguageUserSetKey, true);
    }
  }

  void _saveTargetLanguageSetting() {
    _storage.write(_targetLanguageKey, targetLanguage.value);
  }

  ///根据当前系统语言获取默认源语言
  String? _getSourceLanguageByAppLocale() {
    final Locale? locale = Get.locale ?? Get.deviceLocale;
    if (locale == null) return null;

    final languageCode = locale.languageCode.toLowerCase();
    final countryCode = locale.countryCode?.toUpperCase();
    final scriptCode = locale.scriptCode;

    if (languageCode == 'zh') {
      if (countryCode == 'HK' || countryCode == 'MO') {
        return _languageManager.getChineseNameByAsrCode('zh-HK');
      }
      if (countryCode == 'TW') {
        return _languageManager.getChineseNameByAsrCode('zh-TW');
      }
      if (scriptCode == 'Hant') {
        return _languageManager.getChineseNameByAsrCode('zh-TW');
      }
      return _languageManager.getChineseNameByAsrCode('zh-CN');
    }

    final normalizedShortCode = switch (languageCode) {
      'nb' => 'no',
      _ => languageCode,
    };

    return _languageManager.getChineseNameByShortCode(normalizedShortCode);
  }

  /// 请求录音权限
  /// 返回是否授权成功
  Future<bool> requestRecordPermission() async {
    try {
      hasRecordPermission.value =
          await PermissionUtil.instance.requestPermission(
        permissionType: Permission.microphone,
        permissionName: 'microphonePermission'.tr,
        explanationText: 'microphonePermissionExplanation'.tr,
        permanentDenialText: 'microphonePermissionPermanentDenial'.tr,
      );

      if (hasRecordPermission.value) {
        Logger.d("Permission", "用户授予了录音权限");
        return true;
      } else {
        Logger.d("Permission", "用户未授予录音权限");
        return false;
      }
    } catch (e) {
      Logger.e("Permission", "请求录音权限时出错: $e");
      return false;
    }
  }

  /// 请求存储权限
  /// 返回是否授权成功
  Future<bool> _requestStoragePermission() async {
    // 只在Android 10及以下版本请求存储权限
    if (Platform.isAndroid) {
      try {
        final deviceInfo = DeviceInfoPlugin();
        final androidInfo = await deviceInfo.androidInfo;
        final sdkVersion = androidInfo.version.sdkInt;

        // Android 11+ (API 30+) 不需要存储权限
        if (sdkVersion >= 30) {
          Logger.d("Permission", "Android 11+版本，无需请求存储权限");
          return true; // 直接返回true，表示可以使用存储
        }
      } catch (e) {
        Logger.e("Permission", "获取Android版本信息失败: $e");
        // 如果获取版本失败，为了兼容性还是请求权限
      }
    }

    try {
      final bool granted = await PermissionUtil.instance.requestPermission(
        permissionType: Permission.storage,
        permissionName: 'storagePermission'.tr,
        explanationText: 'storagePermissionExplanation'.tr,
        permanentDenialText: 'storagePermissionPermanentDenial'.tr,
      );

      if (granted) {
        Logger.d("Permission", "用户授予了存储权限");
        return true;
      } else {
        Logger.d("Permission", "用户未授予存储权限");
        return true;
      }
    } catch (e) {
      Logger.e("Permission", "请求存储权限时出错: $e");
      return false;
    }
  }

  /// 暂停其他服务（如音乐播放）
  /// 参数：无
  /// 返回值：无
  /// 异常：内部捕获并记录日志，不向外抛出
  Future<void> suspendOtherServices() async {
    try {
      if (!isContinuePlaying) {
        final status = await _musiceManager.getStatus();
        final bool isPlaying = status['isPlaying'] ?? false;
        if (isPlaying == true) {
          isContinuePlaying = true;
          await _musiceManager.pause();
        }
      }

      if (!_isContinueQqMusicPlaying) {
        if (await _qqMusicManager.autopauseMusic()) {
          _isContinueQqMusicPlaying = true;
        }
      }
    } catch (e) {
      Logger.error('暂停其他服务失败: ${e.toString()}');
    }
  }

  /// 恢复其他服务（如音乐播放）
  /// 参数：无
  /// 返回值：无
  /// 异常：内部捕获并记录日志，不向外抛出
  Future<void> restoreOtherServices() async {
    try {
      if (isContinuePlaying) await _musiceManager.resume();
      if (_isContinueQqMusicPlaying) await _qqMusicManager.resumeMusic();
    } catch (e) {
      Logger.error('恢复其他服务失败: ${e.toString()}');
    } finally {
      isContinuePlaying = false;
      _isContinueQqMusicPlaying = false;
    }
  }

  /// 初始化所有服务
  Future<void> _initServices() async {
    try {
      await _translationService.initialize();

      // 初始化 ASR 服务时，明确指定需要支持的语言
      // final List<String> asrSupportedLanguages = [
      //   sourceLanguageCode.value,
      //   targetLanguageCode.value
      // ];
      //Logger.info('2初始化ASR服务，支持语言: $asrSupportedLanguages');

      //await _asrService.initialize(supportedLanguages: asrSupportedLanguages);

      // 获取识别事件流
      // var recognitionStream = await _asrService.recognizeCallback();
      // _recognitionSubscription?.cancel();
      // _recognitionSubscription =
      //     recognitionStream.listen(_handleRecognitionEvent);

      final bool storage = await _requestStoragePermission();
      if (!storage) {
        Logger.d("Permission", "未授予存储权限，无法提供录音功能");
        return;
      }

      appDir = await appDocDir;
      dir = Directory("${appDir.path}/TranslatAudio");
      if (!await dir.exists()) {
        await dir.create(recursive: true);
      }
      Logger.info('所有服务初始化完成');
    } catch (e) {
      Logger.error('初始化服务失败: ${e.toString()}');
    }
  }

  /// 初始化通话模式的语音翻译服务
  Future<void> _initializeCallModeTranslationService() async {
    try {
      Logger.info('开始初始化通话模式语音翻译服务');

      final sourceShort = _languageManager.getShortCodeByAsrCode(sourceLanguageCode.value) ?? 'zh';
      final targetShort = _languageManager.getShortCodeByAsrCode(targetLanguageCode.value) ?? 'en';
      final sourceName = _languageManager.getChineseNameByAsrCode(sourceLanguageCode.value) ?? '?';
      final targetName = _languageManager.getChineseNameByAsrCode(targetLanguageCode.value) ?? '?';
      Logger.info(
          '[TRANS-INIT] 通话翻译语言对: $sourceName($sourceShort/${sourceLanguageCode.value}) -> $targetName($targetShort/${targetLanguageCode.value})');
      final bestProvider = _languageManager.findBestMatchingProvider(sourceShort, targetShort);
      final astProvider = bestProvider?.provider ?? 'azure';
      _lastCallAstProvider = astProvider;
      if (bestProvider == null) {
        Logger.warning(
            '[TRANS-INIT] 未找到匹配的提供商，回退到默认 ${LanguageManager.providerDisplayName('azure')}[azure]（asrCode=${sourceLanguageCode.value} -> ${targetLanguageCode.value}）');
      }

      // 构建完整的语言参数：[asrCode0, asrCode1, transCode0, transCode1, ttsVoice0, ttsVoice1]
      final transCode0 = bestProvider?.sourceSpec['translationCode'] ?? sourceLanguageCode.value;
      final transCode1 = bestProvider?.targetSpec['translationCode'] ?? targetLanguageCode.value;
      final ttsVoice0 = bestProvider?.sourceSpec['ttsCode'] ??
          (_languageManager.getTtsVoiceNameByAsrCode(sourceLanguageCode.value) ?? 'zh-CN-XiaoxiaoNeural');
      final ttsVoice1 = bestProvider?.targetSpec['ttsCode'] ??
          (_languageManager.getTtsVoiceNameByAsrCode(targetLanguageCode.value) ?? 'en-US-AriaNeural');
      final List<String> callModeLanguages = [
        sourceLanguageCode.value,  // [0] ASR source
        targetLanguageCode.value,  // [1] ASR target
        transCode0,                // [2] translation source
        transCode1,                // [3] translation target
        ttsVoice0,                 // [4] TTS voice source
        ttsVoice1,                 // [5] TTS voice target
      ];
      Logger.info(
          '[TRANS-INIT] 最终启动服务: ${LanguageManager.providerDisplayName(astProvider)}[$astProvider], asrSrc=${callModeLanguages[0]}, asrTgt=${callModeLanguages[1]}, transSrc=${callModeLanguages[2]}, transTgt=${callModeLanguages[3]}, ttsSrc=${callModeLanguages[4]}, ttsTgt=${callModeLanguages[5]}');

      await _astService.initialize(supportedLanguages: callModeLanguages, provider: astProvider);

      // 获取识别事件流（端到端服务已包含 ASR+翻译+TTS，不需要单独启动 ASR）
      var astStream = await _astService.recognizeCallback();
      _astEventSubscription?.cancel();
      _astEventSubscription = astStream.listen(_handleAstEvent, onError: (e) {
        Logger.error('[STS] astStream 错误: $e');
      }, onDone: () {
        Logger.info('[STS] astStream 已关闭');
      });
      Logger.info('[STS] 已订阅 astStream, subscription=${_astEventSubscription.hashCode}');

      Logger.info('通话模式语音翻译服务初始化完成');
    } catch (e) {
      Logger.error('通话模式语音翻译服务初始化失败: ${e.toString()}');
    }
  }

  @override
  void onClose() {
    stopAll();
    _recognitionSubscription?.cancel();
    _recognitionSubscription = null;
    _astEventSubscription?.cancel();
    _astEventSubscription = null;
    _voiceInteractionSubscription?.cancel();
    _translationDebounceTimer?.cancel();
    restoreOtherServices();
    // 移除对服务的 dispose，避免频繁销毁/重建造成卡顿
    // _asrService.dispose();
    // _astService.dispose();

    if (Platform.isAndroid) {
      _disableFloatingWindow();
    } else if (Platform.isIOS) {
      _pip.dispose();
      if (_pipContentView != 0) {
        _nativePlugin.disposePipContentView(_pipContentView);
      }
    }

    // 释放管理器资源
    _timerManager.dispose();
    _historyManager.dispose();

    // 取消应用生命周期监听
    WidgetsBinding.instance.removeObserver(this);

    super.onClose();
  }

  /// 应用生命周期变化回调
  /// 当应用进入后台、失去焦点或分离时，兜底将 activeSpeaker 重置为 0
  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.inactive ||
        state == AppLifecycleState.paused ||
        state == AppLifecycleState.detached) {
      if (activeSpeaker.value != 0) {
        Future.microtask(() {
          setActiveSpeaker(0);
        });
      }
    }
  }

  /// 切换TTS功能开关
  void toggleTts() => isTtsEnabled.toggle();

  /// 切换录音功能开关
  Future<void> toggleisRecord() async {
    isRecording.toggle();
    if (isRecording.value &&
        isRecognizing.value &&
        currentMode.value != 'faceToFace') {
      startRecording();
    } else if (!isRecording.value) {
      stopRecording();
    }
  }

  /// 开始录音
  Future<void> startRecording() async {
    _timerManager.startTimer();
    final formattedTime = DateFormat('yyyyMMdd_HHmmss').format(DateTime.now());
    AudioSourceType audioSourceType;
    if (currentMode.value == 'call') {
      audioSourceType = AudioSourceType.external;
    } else if (currentMode.value == 'audioVideo') {
      audioSourceType = AudioSourceType.systemAudio;
    } else {
      audioSourceType = AudioSourceType.microphone;
    }
    await _asrService.enableRecord(
      audioSourceType,
      "${dir.path}/${currentModeTitle.value.tr}_$formattedTime.wav",
      false,
    );

    // if (currentMode.value == 'call') {
    //   await _astService.enableRecord(
    //       "${dir.path}/${currentModeTitle.value.tr}_${formattedTime}_mic.wav");
    // }
    isCreateRecord.value = true;
  }

  /// 停止录音
  Future<void> stopRecording() async {
    _timerManager.stopTimer();
    _asrService.stopRecord(true);
    isCreateRecord.value = false;
    Logger.info('录音已停止，计时器已重置');
  }

  /// 暂停录音
  Future<void> pauseRecording() async {
    _timerManager.pauseTimer();
    _asrService.pauseRecord();

    Logger.info(' 录音已暂停');
  }

  /// 继续录音
  Future<void> continueRecording() async {
    _timerManager.resumeTimer();
    _asrService.resumeRecord();

    Logger.info(' 录音已继续');
  }

  /// 开始语音识别
  /// 同声翻译、通话翻译、多媒体翻译的语音识别调用入口
  Future<void> startRecognition() async {
    Logger.info('开始语音识别');
    final srcName = _languageManager.getChineseNameByAsrCode(sourceLanguageCode.value) ?? '?';
    final tgtName = _languageManager.getChineseNameByAsrCode(targetLanguageCode.value) ?? '?';
    if (currentMode.value == 'call') {
      final p = _lastCallAstProvider.isEmpty ? 'azure(未初始化)' : _lastCallAstProvider;
      Logger.info(
          '[TRANS-INIT] startRecognition: mode=call, 语言对=$srcName(${sourceLanguageCode.value}) -> $tgtName(${targetLanguageCode.value}), 服务=${LanguageManager.providerDisplayName(p)}[$p]');
    } else {
      Logger.info(
          '[TRANS-INIT] startRecognition: mode=${currentMode.value}, 语言对=$srcName(${sourceLanguageCode.value}) -> $tgtName(${targetLanguageCode.value})');
    }
    //检查用户是否登录且积分是否足够，不足则提示充值
    if (User.isLoggedIn() && User.instance.tradeintegral <= 0) {
      showRechargeDialog('translation');
      return;
    }

    if (!await _checkPermissions()) return;
    if (isRecognizing.value) return;

    try {
      await _initializeSession();
      await _configureAudioMode();
      if (currentMode.value != 'faceToFace') {
        if ((currentMode.value == 'audioVideo' ||
                currentMode.value == 'call') &&
            !bleManager.isCodecActive) {
          return;
        }
        if (currentMode.value == 'simultaneous') {
          Logger.info('liwei-------- 开始语音识别，模式：同声传译，ASR phone_call');
          await _startAsrService('phone_call');
        } else if (currentMode.value == 'faceToFace') {
          Logger.info('iwei-------- 开始语音识别，模式：面对面，ASR push_to_talk');
          await _startAsrService('push_to_talk');
        } else if (currentMode.value == 'call') {
          Logger.info('iwei-------- 通话模式：AST端到端服务已启动，跳过Azure ASR');
        } else {
          Logger.info(
              'iwei-------- 开始语音识别，模式：${currentMode.value}，ASR 模式：normal');
          await _startAsrService('normal');
        }
        await _finalizeRecognitionStart();
      }
    } catch (e) {
      isPreparing.value = false;
      isRecognizing.value = false;
      Logger.error('启动语音识别失败: ${e.toString()}');
    }
  }

  /// 检查权限
  Future<bool> _checkPermissions() async {
    final bool record = await requestRecordPermission();
    if (!record) {
      Logger.d("Permission", "录音权限被拒绝，无法开始录音");
      return false;
    }
    return true;
  }

  /// 初始化会话
  Future<void> _initializeSession() async {
    currentSessionId = DateTime.now().millisecondsSinceEpoch.toString();

    try {
      _usageService.startNewSession();
      _asrSessionStartTime = DateTime.now();
      _asrActiveDuration = Duration.zero;
      _isAsrActive = false;
    } catch (e) {
      Logger.error('开始新会话统计失败: $e');
    }
  }

  /// 配置音频模式
  Future<void> _configureAudioMode() async {
    switch (currentMode.value) {
      case "audioVideo":
        await _configureAudioVideoMode();
        break;
      case "call":
        await _configureCallMode();
        break;
      default:
        await _configureDefaultMode();
    }
  }

  /// 配置音视频模式
  Future<void> _configureAudioVideoMode() async {
    isPreparing.value = true;
    await bleManager.openDecoder();
    int attempts = 0;
    while (!bleManager.isCodecActive && attempts < 10) {
      await Future.delayed(const Duration(milliseconds: 150));
      attempts++;
    }
    isPreparing.value = false;
    if (!bleManager.isCodecActive) {
      Get.snackbar('tip'.tr, 'operationFailedPleaseRetry'.tr);
      throw Exception('lxm--BLE编解码打开失败');
    }
    _audioSourceType = true;
    isTtsEnabled.value = false;
    Logger.info('发送ble音乐或者通话远端声音');
  }

  /// 配置通话模式
  /// 配置通话模式（只做 BLE 配置，AST 已在 _initializeCallModeTranslationService 中初始化）
  Future<void> _configureCallMode() async {
    isPreparing.value = true;
    await bleManager.openA2DPDecoder();
    int attempts = 0;
    while (!bleManager.isCodecActive && attempts < 10) {
      await Future.delayed(const Duration(milliseconds: 150));
      attempts++;
    }
    isPreparing.value = false;
    if (!bleManager.isCodecActive) {
      Get.snackbar('tip'.tr, 'bluetoothCallStateError'.tr);
      throw Exception('lxm--BLE编解码打开失败');
    }
    _audioSourceType = true;
    isTtsEnabled.value = false;
    Logger.info('发送ble系统mic和dac（音乐或者通话远端）声音');
  }

  /// 配置默认模式
  Future<void> _configureDefaultMode() async {
    _audioSourceType = false;
    isTtsEnabled.value = true;
  }

  /// 启动语音识别
  Future<void> _startAsrService(String mode) async {
    if (mode == 'push_to_talk') {
      await _asrService.startContinuousRecognition(
        _audioSourceType,
        isRemoveFirstPunctuation: false,
        mode: mode,
      );
    } else {
      await _asrService.startContinuousRecognition(
        _audioSourceType,
        isRemoveFirstPunctuation: true,
        mode: mode,
      );
    }
  }

  /// 完成识别启动
  Future<void> _finalizeRecognitionStart() async {
    _startAsrActiveTracking();
    isRecognizing.value = true;

    if (isRecording.value && isRecognizing.value) {
      startRecording();
    }
  }

  /// 处理语音识别事件
  /// [event] 识别事件
  void _handleRecognitionEvent(RecognitionEvent event) {
    // Logger.info("处理识别事件:${event}");
    final String asrProvider = event.provider;
    if (asrProvider.isNotEmpty) Logger.info('ASR provider: $asrProvider');
    switch (event.type) {
      case RecognitionEventType.finalResult:
        if (event.text.isEmpty) break;
        // 通话模式下：目标语言即为识别语言，无需判断
        detectedLanguageCode = currentMode.value == 'call'
            ? targetLanguageCode.value
            : event.detectedLanguage;
        Logger.info("处理识别完成:${event.text}");
        if (currentMode.value != 'faceToFace') {
          handleFinalResult(event.text);
        } else {
          faceToFaceRecognitionText.value += event.text;
          Logger.info('lxm-面对面翻译识别文本更新: ${faceToFaceRecognitionText.value}');
        }
        if (currentMode.value == 'faceToFace' && activeSpeaker.value == 0) {
          handleFinalResult(faceToFaceRecognitionText.value);
          faceToFaceRecognitionText.value = '';
        }
        break;

      case RecognitionEventType.finalResult1:
        // 通话模式下：己方（麦克风）识别完成事件（对应ast服务）
        if (event.text.isEmpty) break;
        //通话模式下：己方语言即为源语言，无需判断
        detectedLanguageCode = sourceLanguageCode.value;
        Logger.info("lxm---处理己方识别完成:${event.text}");
        handleFinalResult(event.text);
        break;

      case RecognitionEventType.intermediateResult:
        if (event.text.isEmpty) break;
        // 通话模式下：目标语言即为识别语言，无需判断
        detectedLanguageCode = currentMode.value == 'call'
            ? targetLanguageCode.value
            : event.detectedLanguage;
        Logger.info("处理识别中事件:${event.text}");
        handleIntermediateResult(event.text);
        break;

      case RecognitionEventType.error:
        final errorMsg = event.error;
        var displayMsg = errorMsg;
        if (errorMsg.contains('Xunfei connection failed') ||
            errorMsg.contains('Socket is not connected')) {
          displayMsg = 'asrConnectionFailed'.tr; // 语音识别服务连接失败，请检查网络或稍后重试
        }
        Get.snackbar('error'.tr, displayMsg);
        isRecognizing.value = false;
        Logger.error('语音识别错误: $errorMsg');
        break;

      case RecognitionEventType.canceled:
        isRecognizing.value = false;
        Logger.error('语音识别取消: ${event.error}');
        break;

      case RecognitionEventType.sessionStarted:
        // 可按需处理会话开始事件
        break;

      case RecognitionEventType.sessionStopped:
        // 可按需处理会话结束事件
        break;
    }
  }

  /// 处理 AST（语音识别+翻译一体）事件
  /// 按 serviceId 区分双路（A=己方, B=对方），用 utteranceId 匹配同一句话的事件
  void _handleAstEvent(ASTEvent event) {
    Logger.info('[STS] _handleAstEvent 收到: type=${event.type}, serviceId=${event.serviceId}, text=${event.text}');
    // 根据 serviceId 确定语言方向
    final String srcCode = event.serviceId == "A"
        ? sourceLanguageCode.value
        : targetLanguageCode.value;
    final String tgtCode = event.serviceId == "A"
        ? targetLanguageCode.value
        : sourceLanguageCode.value;

    switch (event.type) {
      case ASTEventType.intermediateResult:
        if (event.text.isEmpty) break;
        Logger.info('AST 识别中 [${event.serviceId}]: ${event.text}');
        currentSessionId ??= DateTime.now().millisecondsSinceEpoch.toString();

        // 按 utteranceId 查找已有项
        TranslationItem? target;
        int targetIndex = -1;
        if (event.utteranceId.isNotEmpty) {
          for (int i = translationHistory.length - 1; i >= 0; i--) {
            if (translationHistory[i].isIntermediate &&
                translationHistory[i].utteranceId == event.utteranceId) {
              target = translationHistory[i];
              targetIndex = i;
              break;
            }
          }
        }

        if (target != null) {
          target.sourceText = event.text;
          target.sourceLanguageCode = srcCode;
          target.targetLanguageCode = tgtCode;
          target.serviceId = event.serviceId;
          translationHistory.refresh();
        } else {
          _historyManager.addTranslationItem(TranslationItem(
            sourceText: event.text,
            translatedText: '',
            sourceLanguageCode: srcCode,
            targetLanguageCode: tgtCode,
            timestamp: DateTime.now(),
            sessionId: currentSessionId!,
            isFirstInSession: translationHistory.isEmpty ||
                translationHistory.last.sessionId != currentSessionId,
            isIntermediate: true,
            utteranceId: event.utteranceId,
            serviceId: event.serviceId,
          ));
        }
        break;

      case ASTEventType.finalResult:
        if (event.text.isEmpty) break;
        Logger.info('AST 识别完成 [${event.serviceId}]: ${event.text}');
        currentSessionId ??= DateTime.now().millisecondsSinceEpoch.toString();

        TranslationItem? target;
        if (event.utteranceId.isNotEmpty) {
          for (int i = translationHistory.length - 1; i >= 0; i--) {
            if (translationHistory[i].isIntermediate &&
                translationHistory[i].utteranceId == event.utteranceId) {
              target = translationHistory[i];
              break;
            }
          }
        }

        if (target == null) {
          target = TranslationItem(
            sourceText: event.text,
            translatedText: '',
            sourceLanguageCode: srcCode,
            targetLanguageCode: tgtCode,
            timestamp: DateTime.now(),
            sessionId: currentSessionId!,
            isFirstInSession: translationHistory.isEmpty ||
                translationHistory.last.sessionId != currentSessionId,
            isIntermediate: true,
            utteranceId: event.utteranceId,
            serviceId: event.serviceId,
            isFinalResultReceived: true,
          );
          _historyManager.addTranslationItem(target);
        } else {
          target.sourceText = event.text;
          target.sourceLanguageCode = srcCode;
          target.targetLanguageCode = tgtCode;
          target.serviceId = event.serviceId;
          target.isFinalResultReceived = true;
        }

        // 识别+翻译都到齐才标记完成
        if (target.isFinalResultReceived && target.isTranslationResultReceived) {
          target.isIntermediate = false;
          translationHistory.refresh();
          _scrollToBottom();
          saveTranslationHistory();
        } else {
          translationHistory.refresh();
        }
        break;

      case ASTEventType.translationInterim:
        if (event.text.isEmpty) break;
        Logger.info('AST 翻译中 [${event.serviceId}]: ${event.text}');
        currentSessionId ??= DateTime.now().millisecondsSinceEpoch.toString();

        TranslationItem? target;
        if (event.utteranceId.isNotEmpty) {
          for (int i = translationHistory.length - 1; i >= 0; i--) {
            if (translationHistory[i].isIntermediate &&
                translationHistory[i].utteranceId == event.utteranceId) {
              target = translationHistory[i];
              break;
            }
          }
        }

        if (target != null) {
          target.translatedText = event.text;
          target.sourceLanguageCode = srcCode;
          target.targetLanguageCode = tgtCode;
          translationHistory.refresh();
        } else {
          _historyManager.addTranslationItem(TranslationItem(
            sourceText: '',
            translatedText: event.text,
            sourceLanguageCode: srcCode,
            targetLanguageCode: tgtCode,
            timestamp: DateTime.now(),
            sessionId: currentSessionId!,
            isFirstInSession: translationHistory.isEmpty ||
                translationHistory.last.sessionId != currentSessionId,
            isIntermediate: true,
            utteranceId: event.utteranceId,
            serviceId: event.serviceId,
          ));
        }
        break;

      case ASTEventType.translationResult:
        if (event.text.isEmpty) break;
        Logger.info('AST 翻译完成 [${event.serviceId}]: ${event.text}');
        currentSessionId ??= DateTime.now().millisecondsSinceEpoch.toString();

        TranslationItem? target;
        if (event.utteranceId.isNotEmpty) {
          for (int i = translationHistory.length - 1; i >= 0; i--) {
            if (translationHistory[i].isIntermediate &&
                translationHistory[i].utteranceId == event.utteranceId) {
              target = translationHistory[i];
              break;
            }
          }
        }

        if (target == null) {
          target = TranslationItem(
            sourceText: '',
            translatedText: event.text,
            sourceLanguageCode: srcCode,
            targetLanguageCode: tgtCode,
            timestamp: DateTime.now(),
            sessionId: currentSessionId!,
            isFirstInSession: translationHistory.isEmpty ||
                translationHistory.last.sessionId != currentSessionId,
            isIntermediate: true,
            utteranceId: event.utteranceId,
            serviceId: event.serviceId,
            isTranslationResultReceived: true,
          );
          translationHistory.add(target);
          translationHistory.refresh();
          _scrollToBottom();
        } else {
          target.translatedText = event.text;
          target.sourceLanguageCode = srcCode;
          target.targetLanguageCode = tgtCode;
          target.isTranslationResultReceived = true;
        }

        if (target.isFinalResultReceived && target.isTranslationResultReceived) {
          target.isIntermediate = false;
          translationHistory.refresh();
          _scrollToBottom();
          saveTranslationHistory();
        } else {
          translationHistory.refresh();
        }
        break;

      case ASTEventType.error:
        Logger.error('AST 错误: ${event.error}');
        // 重新初始化期间的错误来自旧会话，忽略
        if (_isReinitializing) {
          Logger.info('[STS] 正在重新初始化，忽略旧会话错误');
          break;
        }
        // 非重新初始化期间的错误：终止通话服务并还原状态
        _terminateCallOnError('AST 错误: ${event.error}');
        break;

      case ASTEventType.canceled:
        Logger.error('AST 取消: ${event.error}');
        if (_isReinitializing) {
          Logger.info('[STS] 正在重新初始化，忽略旧会话取消');
          break;
        }
        _terminateCallOnError('AST 取消: ${event.error}');
        break;

      default:
        break;
    }
  }

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

    try {
      await stopRecording();
      await _asrService.stopContinuousRecognition();
      if (currentMode.value == "call") {
        await _astService.stopContinuousTranslation();
      }
      _stopAsrActiveTracking();
      final langName = _languageManager.getChineseNameByAsrCode(
              (detectedLanguageCode.isNotEmpty
                  ? detectedLanguageCode
                  : sourceLanguageCode.value)) ??
          '未知';
      _recordAsrUsageStats(langName);
      isRecognizing.value = false;
      currentSessionId = null;
    } catch (e) {
      Logger.error('停止语音识别失败: ${e.toString()}');
    }
  }

  /// 处理中间识别结果
  /// [text] 识别的文本
  void handleIntermediateResult(String text) {
    if (text.isEmpty) return;
    Logger.info(
        "handleIntermediateResult:${translationHistory.isEmpty}${translationHistory.isNotEmpty ? translationHistory.last.isIntermediate : 'N/A'}");
    if (translationHistory.isEmpty ||
        (translationHistory.isNotEmpty &&
            !translationHistory.last.isIntermediate)) {
      currentSessionId ??= DateTime.now().millisecondsSinceEpoch.toString();

      // 关键调整：使用与最终结果一致的语言方向，避免左右“跳变”
      final languageCodes = _determineLanguageCodes();

      final newItem = TranslationItem(
        sourceText: text,
        translatedText: '',
        sourceLanguageCode: languageCodes['source']!,
        targetLanguageCode: languageCodes['target']!,
        timestamp: DateTime.now(),
        sessionId: currentSessionId!,
        isFirstInSession: translationHistory.isEmpty ||
            translationHistory.last.sessionId != currentSessionId,
        isIntermediate: true,
      );

      if (currentMode.value == 'faceToFace' && activeSpeaker.value == 0) {
        _asrService.stopContinuousRecognition();
      } else {
        _historyManager.addTranslationItem(newItem);
      }
    } else {
      // 更新当前项
      if (currentMode.value != 'faceToFace') {
        translationHistory.last.sourceText = text;
      } else {
        translationHistory.last.sourceText =
            faceToFaceRecognitionText.value + text;
      }
      translationHistory.refresh();
      _historyManager.scrollToBottom();
    }

    // 防抖处理翻译请求
    _translationDebounceTimer?.cancel();
    _translationDebounceTimer = Timer(const Duration(milliseconds: 300), () {
      if (translationHistory.isNotEmpty &&
          translationHistory.last.isIntermediate &&
          translationHistory.last.sourceText.isNotEmpty) {
        translateText(translationHistory.last.sourceText,
            translationHistory.last.timestamp,
            isFinal: false);
      }
    });
  }

  /// 处理最终识别结果
  /// [text] 识别的文本
  Future<void> handleFinalResult(String text) async {
    if (text.isEmpty) return;

    // 更新当前项
    if (translationHistory.isNotEmpty &&
        translationHistory.last.isIntermediate) {
      translationHistory.last.sourceText = text;
      translationHistory.last.isIntermediate = false;
      translationHistory.refresh();
      _scrollToBottom();
      saveTranslationHistory();
//如果识别中，且是面对面翻译，则停止识别
      if (activeSpeaker.value == 0 && currentMode.value == 'faceToFace') {
        _asrService.stopContinuousRecognition();
      }

      translateText(text, translationHistory.last.timestamp, isFinal: true);
    } else {
      // 创建新项
      final newItem = TranslationItem(
        sourceText: text,
        translatedText: '',
        sourceLanguageCode: sourceLanguageCode.value,
        targetLanguageCode: targetLanguageCode.value,
        timestamp: DateTime.now(),
        sessionId: currentSessionId ??
            DateTime.now().millisecondsSinceEpoch.toString(),
        isFirstInSession: translationHistory.isEmpty ||
            translationHistory.last.sessionId != currentSessionId,
        isIntermediate: false,
      );

      if (currentMode.value == 'faceToFace' && activeSpeaker.value == 0) {
        _asrService.stopContinuousRecognition();
      }

      translationHistory.add(newItem);
      translationHistory.refresh();
      _scrollToBottom();
      saveTranslationHistory();
      translateText(text, newItem.timestamp, isFinal: true);
    }
  }

  /// 翻译文本
  /// [sourceText] 源文本
  /// [timestamp] 时间戳
  /// [isFinal] 是否为最终结果
  /// 返回翻译结果
  Future<String?> translateText(String sourceText, DateTime timestamp,
      {bool isFinal = false}) async {
    if (sourceText.isEmpty) return null;

    isTranslating.value = true;
    String? translationResult;

    try {
      final languageCodes = _determineLanguageCodes();
      translationResult = await _performTranslation(
          sourceText, languageCodes['source']!, languageCodes['target']!);

      if (translationResult != null) {
        await _updateTranslationHistory(
            sourceText, translationResult, timestamp, languageCodes, isFinal);
      }
    } catch (e) {
      Logger.error('翻译失败: ${e.toString()}');
    } finally {
      isTranslating.value = false;
    }

    return translationResult;
  }

  /// 确定语言代码
  /// 返回源语言和目标语言代码的映射
  Map<String, String> _determineLanguageCodes() {
    String detectedSourceLanguageCode;
    String detectedTargetLanguageCode;

    if (_isFaceToFaceSpeaker1()) {
      detectedLanguageCode = sourceLanguageCode.value;
      detectedSourceLanguageCode = sourceLanguageCode.value;
      detectedTargetLanguageCode = targetLanguageCode.value;
    } else if (_isFaceToFaceSpeaker2()) {
      detectedLanguageCode = targetLanguageCode.value;
      detectedSourceLanguageCode = targetLanguageCode.value;
      detectedTargetLanguageCode = sourceLanguageCode.value;
    } else {
      final shouldSwap = detectedLanguageCode == sourceLanguageCode.value;
      detectedSourceLanguageCode =
          shouldSwap ? sourceLanguageCode.value : targetLanguageCode.value;
      detectedTargetLanguageCode =
          shouldSwap ? targetLanguageCode.value : sourceLanguageCode.value;
    }

    return {
      'source': detectedSourceLanguageCode,
      'target': detectedTargetLanguageCode,
    };
  }

  /// 判断是否为面对面说话者1
  bool _isFaceToFaceSpeaker1() {
    return (currentMode.value == 'faceToFace' && activeSpeaker.value == 1) ||
        (currentMode.value == 'faceToFace' &&
            activeSpeaker.value == 0 &&
            lastActiveSpeaker.value == 1);
  }

  /// 判断是否为面对面说话者2
  bool _isFaceToFaceSpeaker2() {
    return (currentMode.value == 'faceToFace' && activeSpeaker.value == 2) ||
        (currentMode.value == 'faceToFace' &&
            activeSpeaker.value == 0 &&
            lastActiveSpeaker.value == 2);
  }

  /// 执行翻译
  /// [sourceText] 源文本
  /// [sourceCode] 源语言代码
  /// [targetCode] 目标语言代码
  /// 返回翻译结果
  Future<String?> _performTranslation(
      String sourceText, String sourceCode, String targetCode) async {
    return await _translationService.translateText(
      text: sourceText,
      sourceLanguageCode: sourceCode,
      targetLanguageCode: targetCode,
    );
  }

  /// 更新翻译历史
  /// [sourceText] 源文本
  /// [translationResult] 翻译结果
  /// [timestamp] 时间戳
  /// [languageCodes] 语言代码映射
  /// [isFinal] 是否为最终结果
  Future<void> _updateTranslationHistory(
    String sourceText,
    String translationResult,
    DateTime timestamp,
    Map<String, String> languageCodes,
    bool isFinal,
  ) async {
    final index = translationHistory
        .indexWhere((item) => item.timestamp.isAtSameMomentAs(timestamp));

    if (index != -1) {
      await _updateExistingHistoryItem(
          index, translationResult, languageCodes, sourceText, isFinal);
    } else {
      Logger.info('未找到匹配的历史项 $sourceText ${timestamp.toIso8601String()}');
    }
  }

  /// 更新现有历史项
  /// [index] 历史项索引
  /// [translationResult] 翻译结果
  /// [languageCodes] 语言代码映射
  /// [sourceText] 源文本
  /// [isFinal] 是否为最终结果
  Future<void> _updateExistingHistoryItem(
    int index,
    String translationResult,
    Map<String, String> languageCodes,
    String sourceText,
    bool isFinal,
  ) async {
    // 更新历史项
    translationHistory[index].translatedText = translationResult;
    translationHistory[index].sourceLanguageCode = languageCodes['source']!;
    translationHistory[index].targetLanguageCode = languageCodes['target']!;
    translationHistory.refresh();

    // 更新悬浮窗内容
    if (isFloatingWindowEnabled.value) {
      await _updateFloatingWindowWithTranslation(translationHistory[index]);
    }

    // 添加TranslationItem日志打印
    if (isFinal) {
      final item = translationHistory[index];
      Logger.info('lxm-翻译完成 - TranslationItem详情: '
          '源文本: ${item.sourceText}, '
          '翻译文本: ${item.translatedText}, '
          '源语言: ${item.sourceLanguageCode}, '
          '目标语言: ${item.targetLanguageCode}, '
          '时间戳: ${item.timestamp.toIso8601String()}, '
          '会话ID: ${item.sessionId}, '
          '是否会话首项: ${item.isFirstInSession}, '
          '是否中间结果: ${item.isIntermediate}');
    }

    if (isFinal) {
      saveTranslationHistory();
      await _recordTranslationStats(
          sourceText, translationResult, languageCodes);
    }

    _scrollToBottom();

    if (isFinal) {
      await _handleTtsPlayback(translationResult);
    }
  }

  /// 记录翻译统计
  /// [sourceText] 源文本
  /// [translationResult] 翻译结果
  /// [languageCodes] 语言代码映射
  Future<void> _recordTranslationStats(
    String sourceText,
    String translationResult,
    Map<String, String> languageCodes,
  ) async {
    try {
      final sourceLanguageName =
          _languageManager.getChineseNameByAsrCode(languageCodes['source']!) ??
              '未知';
      final targetLanguageName =
          _languageManager.getChineseNameByAsrCode(languageCodes['target']!) ??
              '未知';

      _usageService.recordTranslationApiCall(
        sourceText: sourceText,
        targetText: translationResult,
        sourceLanguage: sourceLanguageName,
        targetLanguage: targetLanguageName,
        mode: currentMode.value,
      );

      Logger.info(
          '翻译统计: 源文本${sourceText.length}字符, 模式${currentMode.value}, 语言对$sourceLanguageName→$targetLanguageName');
    } catch (e) {
      Logger.error('记录翻译统计失败: $e');
    }
  }

  /// 处理TTS播放
  /// [translationResult] 翻译结果
  Future<void> _handleTtsPlayback(String translationResult) async {
    if (isTtsEnabled.value) {
      await playTranslatedText(translationResult);
    }
  }

  // /// 处理面对面TTS
  // /// [translationResult] 翻译结果
  // Future<void> _handleFaceToFaceTts(String translationResult) async {
  //   fTFTranslationResult = (fTFTranslationResult ?? '') + translationResult;
  //   print("translationResult=$translationResult");

  //   if (activeSpeaker.value == 0 && !isPlayback) {
  //     isPlayback = true;
  //     await playTranslatedText(fTFTranslationResult!);
  //     fTFTranslationResult = '';
  //   }
  // }

  /// 播放翻译文本
  /// [text] 要播放的文本
  Future<void> playTranslatedText(String text) async {
    if (text.isEmpty) return;

    try {
      final bool shouldSwap = detectedLanguageCode == targetLanguageCode.value;
      final detectedTargetLanguageCode =
          shouldSwap ? sourceLanguageCode.value : targetLanguageCode.value;
      final voiceName = _languageManager
              .getTtsVoiceNameByAsrCode(detectedTargetLanguageCode) ??
          'en-US-AriaNeural';
      Logger.info("voiceName=$voiceName,text=$text");

      final startTime = DateTime.now();
      await _ttsService.setVoice(voiceName);
      await _ttsService.speakOnce(currsessionid, text);
      final endTime = DateTime.now();

      // 记录TTS API调用统计
      try {
        final durationSeconds = endTime.difference(startTime).inSeconds;
        final languageName = _languageManager
                .getChineseNameByAsrCode(detectedTargetLanguageCode) ??
            '未知';

        _usageService.recordTtsApiCall(
          text: text,
          durationSeconds: durationSeconds,
          language: languageName,
        );

        Logger.info(
            'TTS统计: 文本${text.length}字符, 播放${durationSeconds}秒, 语言$languageName');
      } catch (e) {
        Logger.error('记录TTS统计失败: $e');
      }
    } catch (e) {
      Logger.error('播放翻译失败: ${e.toString()}');
    }
  }

  /// 停止所有操作
  Future<void> stopAll() async {
    try {
      isPreparing.value = false;
      if (currentMode.value == "audioVideo" || currentMode.value == "call") {
        bleManager.closeCodec();
        Logger.info('关闭ble编解码器');
      }
      if (isRecognizing.value) {
        await stopRecognition();
      }

      _stopAsrActiveTracking();
      _translationDebounceTimer?.cancel();
      await _ttsService.stop();
    } catch (e) {
      Logger.error('停止操作失败: ${e.toString()}');
    }
  }

  /// 通话模式发生错误时终止服务并还原状态
  Future<void> _terminateCallOnError(String reason) async {
    Logger.error('[STS] 通话错误，终止服务: $reason');
    try {
      _astEventSubscription?.cancel();
      _astEventSubscription = null;
      try {
        await _astService.stopContinuousTranslation();
      } catch (_) {}
      isRecognizing.value = false;
      isPreparing.value = false;
      _stopAsrActiveTracking();
      _translationDebounceTimer?.cancel();
      await _ttsService.stop();
      if (currentMode.value == "call" || currentMode.value == "audioVideo") {
        bleManager.closeCodec();
      }
    } catch (e) {
      Logger.error('[STS] 终止通话服务失败: $e');
    }
  }

  /// 播放特定翻译项
  /// [item] 翻译项
  Future<void> playTranslationItem(TranslationItem item) async {
    if (item.translatedText.isEmpty) return;

    // 防重复点击：如果短时间内重复点击同一项，忽略后续点击
    final currentTime = DateTime.now().millisecondsSinceEpoch;
    final itemKey =
        '${item.sessionId}_${item.timestamp.millisecondsSinceEpoch}';

    // 检查是否是重复点击同一项
    if (_lastPlayedItemKey == itemKey &&
        currentTime - _lastPlayTime < _playDebounceInterval) {
      Logger.info('防重复播放：忽略短时间内的重复点击');
      return;
    }

    // 如果正在播放，先停止当前播放
    if (_ttsService.isSpeaking) {
      await _ttsService.stop();
      // 短暂延迟确保停止完成
      await Future.delayed(const Duration(milliseconds: 100));
    }

    try {
      // 更新播放记录
      _lastPlayedItemKey = itemKey;
      _lastPlayTime = currentTime;

      final voiceName =
          _languageManager.getTtsVoiceNameByAsrCode(item.targetLanguageCode) ??
              'en-US-AriaNeural';
      await _ttsService.setVoice(voiceName);
      await _ttsService.speakOnce(currsessionid, item.translatedText);
    } catch (e) {
      Logger.error('播放翻译项失败: ${e.toString()}');
    }
  }

  /// 播放文本
  /// [text] 要播放的文本
  /// [languageCode] 语言代码（可选）
  Future<void> playText(String text, {String? languageCode}) async {
    if (text.isEmpty) return;

    // 防重复点击：基于文本内容和语言代码生成唯一标识
    final currentTime = DateTime.now().millisecondsSinceEpoch;
    final textKey = '${text}_${languageCode ?? targetLanguageCode.value}';

    // 检查是否是重复点击同一文本
    if (_lastPlayedItemKey == textKey &&
        currentTime - _lastPlayTime < _playDebounceInterval) {
      Logger.info('防重复播放：忽略短时间内的重复文本播放请求');
      return;
    }

    // 如果正在播放，先停止当前播放
    if (_ttsService.isSpeaking) {
      await _ttsService.stop();
      // 短暂延迟确保停止完成
      await Future.delayed(const Duration(milliseconds: 100));
    }

    try {
      // 更新播放记录
      _lastPlayedItemKey = textKey;
      _lastPlayTime = currentTime;

      final voiceName = languageCode != null
          ? _languageManager.getTtsVoiceNameByAsrCode(languageCode) ??
              'en-US-AriaNeural'
          : _languageManager
                  .getTtsVoiceNameByAsrCode(targetLanguageCode.value) ??
              'en-US-AriaNeural';

      await _ttsService.setVoice(voiceName);
      await _ttsService.speakOnce(currsessionid, text);
    } catch (e) {
      Logger.error('播放文本失败: ${e.toString()}');
    }
  }

  /// 滚动到底部（适配reverse模式）
  /// [animate] 是否使用动画
  void _scrollToBottom({bool animate = true}) {
    if (scrollController.hasClients &&
        (translationHistory.isNotEmpty || currentSessionId != null)) {
      try {
        const targetPosition = 0.0; // reverse模式下最新消息在顶部

        if (animate) {
          scrollController.animateTo(
            targetPosition,
            duration: const Duration(milliseconds: 300),
            curve: Curves.easeOut,
          );
        } else {
          scrollController.jumpTo(targetPosition);
        }
      } catch (e) {
        Logger.error('滚动到顶部失败（reverse模式）: ${e.toString()}');
      }
    }
  }

  /// 设置滚动监听器（简化版，保留接口兼容性）
  void setupScrollListener() {
    // 简化后的空方法，保留接口兼容性
  }

  /// 设置底部控制栏高度
  /// [height] 高度值
  void setBottomBarHeight(double height) {
    _bottomBarHeight = height;
  }

  /// 获取底部控制栏高度
  double get bottomBarHeight => _bottomBarHeight;

  /// 串行化语言切换，避免并发 reinit 造成 UI 与原生 AST 状态不一致
  Future<T> _runLanguageSwitch<T>(Future<T> Function() action) {
    final previous = _languageSwitchChain;
    final completer = Completer<T>();
    final gate = Completer<void>();
    Future<void> run() async {
      if (previous != null) {
        try {
          await previous;
        } catch (_) {}
      }
      try {
        completer.complete(await action());
      } catch (e, st) {
        completer.completeError(e, st);
      } finally {
        gate.complete();
      }
    }

    _languageSwitchChain = gate.future;
    run();
    return completer.future;
  }

  /// 切换源语言和目标语言
  Future<void> swapLanguages() => _runLanguageSwitch(() async {
        final wasRecognizing = isRecognizing.value;
        await stopAll();

        final tempName = sourceLanguage.value;
        sourceLanguage.value = targetLanguage.value;
        targetLanguage.value = tempName;

        final tempCode = sourceLanguageCode.value;
        sourceLanguageCode.value = targetLanguageCode.value;
        targetLanguageCode.value = tempCode;

        _saveSourceLanguageSetting(isUserSet: true);
        _saveTargetLanguageSetting();
        await _reinitializeAsrService(restartRecognition: wasRecognizing);
      });

  /// 设置源语言
  /// [language] 语言名称
  Future<void> setSourceLanguage(String language) => _runLanguageSwitch(() async {
        if (sourceLanguage.value == language) return;
        final wasRecognizing = isRecognizing.value;
        await stopAll();

        sourceLanguage.value = language;

        final asrCode = _languageManager.getAsrCodeByChineseName(language);
        if (asrCode != null) {
          sourceLanguageCode.value = asrCode;
        }

        _saveSourceLanguageSetting(isUserSet: true);
        await _reinitializeAsrService(restartRecognition: wasRecognizing);
      });

  /// 设置目标语言
  /// [language] 语言名称
  Future<void> setTargetLanguage(String language) => _runLanguageSwitch(() async {
        if (targetLanguage.value == language) return;
        final wasRecognizing = isRecognizing.value;
        await stopAll();

        targetLanguage.value = language;

        final asrCode = _languageManager.getAsrCodeByChineseName(language);
        if (asrCode != null) {
          targetLanguageCode.value = asrCode;
        }

        _saveTargetLanguageSetting();
        await _reinitializeAsrService(restartRecognition: wasRecognizing);
      });

  /// 重新初始化ASR服务
  /// [restartRecognition] 初始化完成后是否自动重新开始识别
  Future<void> _reinitializeAsrService({bool restartRecognition = false}) async {
    _isReinitializing = true;
    try {
      // 通话模式：无论 isRecognizing 状态如何，都强制停止 AST 服务
      // 防止旧会话未完全关闭就创建新会话（Socket 1011 / Session 1012）
      if (currentMode.value == "call") {
        _astEventSubscription?.cancel();
        _astEventSubscription = null;
        try {
          await _astService.stopContinuousTranslation();
        } catch (e) {
          Logger.info('[STS] 停止旧AST服务(忽略): $e');
        }
      }

      //1.统一先停止旧识别
      if (isRecognizing.value) {
        await stopRecognition();
      }
      isRecognizing.value = false;

      late final List<String> asrSupportedLanguages;

      if (currentMode.value == 'audioVideo') {
        asrSupportedLanguages = [sourceLanguageCode.value];
      } else {
        asrSupportedLanguages = [
          sourceLanguageCode.value,
          targetLanguageCode.value
        ];
      }

      if (currentMode.value == "call") {
        await _initializeCallModeTranslationService();
        // _astService.initialize 的原生实现会自动启动 AST（AzureAsrToAsr / DoubaoE2E
        // 等在 initialize 中都调用了 startContinuousTranslation）。若切换语言前未处于
        // 识别状态，这里需要立即停止原生 AST，避免 UI 显示未启动但原生仍在识别。
        if (!restartRecognition) {
          try {
            await _astService.stopContinuousTranslation();
            Logger.info('[STS] 语言切换：非识别状态，已停止新AST保持状态一致');
          } catch (e) {
            Logger.info('[STS] 停止新AST(忽略): $e');
          }
        }
      } else {
        Logger.info('重新初始化ASR服务，支持语言: $asrSupportedLanguages');

        await _asrService.initialize(supportedLanguages: asrSupportedLanguages);

        var recognitionStream = await _asrService.recognizeCallback();
        _recognitionSubscription?.cancel();
        _recognitionSubscription =
            recognitionStream.listen(_handleRecognitionEvent);
      }
      Logger.info('ASR服务重新初始化成功');

      // 切换语言前正在识别，自动恢复识别状态
      if (restartRecognition) {
        Logger.info('[STS] 语言切换完成，自动恢复识别');
        await startRecognition();
      }
    } catch (e) {
      Logger.error('重新初始化ASR服务失败: ${e.toString()}');
    } finally {
      _isReinitializing = false;
    }
  }

  // ==================== 历史记录相关方法 ====================
  /// 加载翻译历史
  void loadTranslationHistory() => _historyManager.loadTranslationHistory();

  /// 保存翻译历史
  void saveTranslationHistory() => _historyManager.saveTranslationHistory();

  /// 设置滚动监听器（适配reverse模式）
  void _setupScrollListener() {
    if (_scrollListenerSetup) return;

    scrollController.addListener(() {
      if (scrollController.position.pixels >=
          scrollController.position.maxScrollExtent - 100) {
        if (hasMoreHistory.value && !isLoadingMore.value) {
          Logger.d(TAG, '触发加载更多翻译历史记录（reverse模式）');
          loadMoreHistory();
        }
      }
    });

    _scrollListenerSetup = true;
  }

  /// 清空翻译历史
  void clearTranslationHistory() => _historyManager.clearTranslationHistory();

  /// 删除会话历史
  /// [sessionId] 会话ID
  void deleteSessionHistory(String sessionId) =>
      _historyManager.deleteSessionHistory(sessionId);

  /// 删除翻译项
  /// [sessionId] 会话ID
  /// [timestamp] 时间戳
  void deleteTranslationItem(String sessionId, DateTime timestamp) =>
      _historyManager.deleteTranslationItem(sessionId, timestamp);

  /// 获取所有历史记录
  /// 返回所有翻译项列表
  List<TranslationItem> getAllHistory() => _historyManager.getAllHistory();

  /// 加载更多历史记录
  Future<void> loadMoreHistory() => _historyManager.loadMoreHistory();

  /// 滚动到底部
  /// [animate] 是否使用动画
  void scrollToBottom({bool animate = true}) =>
      _historyManager.scrollToBottom(animate: animate);

  // ==================== ASR活跃时长跟踪 ====================
  /// 开始ASR活跃时长跟踪
  void _startAsrActiveTracking() {
    if (!_isAsrActive) {
      _asrActiveStartTime = DateTime.now();
      _isAsrActive = true;
      Logger.info('开始ASR活跃时长跟踪');
    }
  }

  /// 停止ASR活跃时长跟踪
  void _stopAsrActiveTracking() {
    if (_isAsrActive && _asrActiveStartTime != null) {
      final activeDuration = DateTime.now().difference(_asrActiveStartTime!);
      _asrActiveDuration += activeDuration;
      _isAsrActive = false;
      _asrActiveStartTime = null;
      Logger.info('停止ASR活跃时长跟踪，本次活跃时长: ${activeDuration.inSeconds}秒');
    }
  }

  /// 记录ASR使用统计 - 基于精确时长跟踪
  /// [language] 语言名称
  void _recordAsrUsageStats(String language) {
    try {
      if (_asrSessionStartTime == null) return;

      _stopAsrActiveTracking();

      final now = DateTime.now();
      final totalDurationSeconds =
          now.difference(_asrSessionStartTime!).inSeconds;
      final effectiveDurationSeconds = _asrActiveDuration.inSeconds;

      _usageService.recordAsrApiCall(
        effectiveDurationSeconds: effectiveDurationSeconds,
        totalDurationSeconds: totalDurationSeconds,
        language: language,
        mode: currentMode.value,
        audioFormat: 'pcm',
        sampleRate: 16000,
      );

      Logger.info(
          'ASR会话统计: 总时长${totalDurationSeconds}秒, 实际活跃时长${effectiveDurationSeconds}秒, 语言$language');
      _asrSessionStartTime = null;
      _asrActiveDuration = Duration.zero;
      _isAsrActive = false;
      _asrActiveStartTime = null;
    } catch (e) {
      Logger.error('记录ASR统计失败: $e');
    }
  }
}