dating_touchme_app/lib/controller/message/call_controller.dart

import 'dart:async';
import 'dart:convert';
import 'dart:typed_data';
import 'package:agora_rtc_engine/agora_rtc_engine.dart';
import 'package:agora_rtm/agora_rtm.dart';
import 'package:audioplayers/audioplayers.dart';
import 'package:dating_touchme_app/generated/assets.dart';
import 'package:dating_touchme_app/model/rtc/rtc_channel_data.dart';
import 'package:dating_touchme_app/network/network_service.dart';
import 'package:dating_touchme_app/rtc/rtc_manager.dart';
import 'package:dating_touchme_app/rtc/rtm_manager.dart';
import 'package:flutter_smart_dialog/flutter_smart_dialog.dart';
import 'package:get/get.dart';
import 'package:im_flutter_sdk/im_flutter_sdk.dart';
import 'package:permission_handler/permission_handler.dart';

import '../overlay_controller.dart';
import 'chat_controller.dart';

/// 通话类型
enum CallType {
  voice, // 语音通话
  video, // 视频通话
}

/// 通话状态
enum CallStatus {
  waitCalling, // 等待接通
  calling, // 通话中
  missed, // 未接听
  cancelled, // 已取消
  rejected, // 已拒绝
}

/// 通话会话信息
class CallSession {
  final String targetUserId;
  final CallType callType;
  final CallStatus status;
  final bool isInitiator; // 是否是发起方
  final DateTime startTime;
  DateTime? endTime;

  CallSession({
    required this.targetUserId,
    required this.callType,
    required this.status,
    required this.isInitiator,
    required this.startTime,
    this.endTime,
  });

  /// 获取通话时长（秒）
  int get duration {
    final end = endTime ?? DateTime.now();
    return end.difference(startTime).inSeconds;
  }
}

/// 通话相关控制器
class CallController extends GetxController {
  static CallController? _instance;
  static CallController get instance {
    _instance ??= Get.put(CallController());
    return _instance!;
  }

  CallController({NetworkService? networkService})
    : _networkService = networkService ?? Get.find<NetworkService>();

  final NetworkService _networkService;

  /// 当前频道信息
  final Rxn<RtcChannelData> rtcChannel = Rxn<RtcChannelData>();

  /// 是否正在创建频道
  final RxBool isCreatingChannel = false.obs;

  // 当前正在进行的通话
  final Rx<CallSession?> currentCall = Rx<CallSession?>(null);

  // 通话计时器（用于记录通话时长）
  Timer? _callTimer;
  int _callDurationSeconds = 0;
  final RxInt callDurationSeconds = RxInt(0);

  // 远端用户UID（用于显示远端视频）
  final Rxn<int> remoteUid = Rxn<int>();

  // 麦克风静音状态
  final RxBool isMicMuted = false.obs;

  // 扬声器开启状态
  final RxBool isSpeakerOn = false.obs;

  // 音频播放器（用于播放来电铃声）
  final AudioPlayer _callAudioPlayer = AudioPlayer();
  bool _isPlayingCallAudio = false;

  // 当前通话的频道ID和UID（用于发送RTM消息）
  String? _callChannelId;
  int? _callUid;

  @override
  void onInit() {
    super.onInit();
    print('📞 [CallController] 通话控制器已初始化');
    // 监听音频播放完成事件，实现循环播放
    _callAudioPlayer.onPlayerComplete.listen((_) async {
      if (_isPlayingCallAudio) {
        // 如果还在播放状态，重新播放（循环播放）
        await _callAudioPlayer.play(
          AssetSource(Assets.audioCall.replaceFirst('assets/', '')),
        );
      }
    });

    // 注册 RTM 消息监听器，用于接收通话相关的 RTM 消息
    _registerRtmMessageListener();
  }

  /// 注册 RTM 消息监听器
  void _registerRtmMessageListener() {
    RTMManager.instance.onMessageEvent = (MessageEvent event) {
      _handleRtmMessage(event);
    };
    print('✅ [CallController] RTM 消息监听器已注册');
  }

  /// 处理 RTM 消息
  void _handleRtmMessage(MessageEvent event) {
    try {
      // 解析消息内容
      String messageText;
      if (event.message is String) {
        messageText = event.message as String;
      } else if (event.message is Uint8List) {
        messageText = utf8.decode(event.message as Uint8List);
      } else {
        messageText = event.message.toString();
      }

      final messageData = json.decode(messageText) as Map<String, dynamic>;
      print('📥 [CallController] 收到 RTM 消息: $messageData');

      // 处理通话消息
      if (messageData['type'] == 'call_message') {
        final event = messageData['event'] as String?;
        if (event == 'accept') {
          // 发起方收到 accept 消息，设置远端用户 UID 并启动计时器
          final uid = messageData['uid'];
          if (uid != null) {
            remoteUid.value = uid is int ? uid : int.tryParse(uid.toString());
            print(
              '📞 [CallController] 收到 accept 消息，设置 remoteUid: ${remoteUid.value}',
            );
          }
          // 发起方收到 accept 消息后，启动通话计时器
          _startCallTimer();
          print('📞 [CallController] 收到 accept 消息，已启动通话计时器');
        } else if (event == 'hangup') {
          // 收到挂断消息，执行退出逻辑
          print('📞 [CallController] 收到 hangup 消息，执行退出逻辑');
          RTMManager.instance.unsubscribe(messageData['channelId']);
          SmartDialog.dismiss(tag: 'video_call_invite_dialog');
          _handleHangupMessage();
        }
      }
    } catch (e) {
      print('❌ [CallController] 处理 RTM 消息失败: $e');
    }
  }

  /// 创建一对一RTC频道
  /// [type] 1为音频，2为视频
  Future<RtcChannelData?> createOneOnOneRtcChannel({required int type}) async {
    if (isCreatingChannel.value) {
      print('⚠️ 正在创建频道，请稍候');
      return null;
    }

    // 验证 type 参数
    if (type != 1 && type != 2) {
      SmartDialog.showToast('类型参数错误：1为音频，2为视频');
      return null;
    }

    isCreatingChannel.value = true;

    final response = await _networkService.rtcApi.createOneOnOneRtcChannel({
      'type': type,
    });

    if (response.data.isSuccess && response.data.data != null) {
      rtcChannel.value = response.data.data;
      print('✅ 创建一对一RTC频道成功: ${response.data.data?.channelId}');
      isCreatingChannel.value = false;
      return response.data.data;
    } else {
      final message = response.data.message.isNotEmpty
          ? response.data.message
          : '创建频道失败';
      SmartDialog.showToast(message);
      print('❌ 创建一对一RTC频道失败: $message');
      isCreatingChannel.value = false;
      return null;
    }
  }

  /// 创建音频通话频道
  Future<RtcChannelData?> createAudioChannel() {
    return createOneOnOneRtcChannel(type: 2);
  }

  /// 创建视频通话频道
  Future<RtcChannelData?> createVideoChannel() {
    return createOneOnOneRtcChannel(type: 3);
  }

  /// 发起通话
  /// [targetUserId] 目标用户ID
  /// [callType] 通话类型：语音或视频
  /// [chatController] 聊天控制器，用于发送通话消息
  Future<bool> initiateCall({
    required String targetUserId,
    required CallType callType,
    ChatController? chatController,
  }) async {
    if (currentCall.value != null) {
      SmartDialog.showToast('已有通话正在进行中');
      return false;
    }

    // 清空之前的远端用户UID和通话信息
    remoteUid.value = null;

    print(
      '📞 [CallController] 发起${callType == CallType.video ? "视频" : "语音"}通话，目标用户: $targetUserId',
    );

    // 发起通话前，先创建一对一 RTC 频道
    final type = callType == CallType.video ? 2 : 1; // 1为音频，2为视频
    final channelData = await createOneOnOneRtcChannel(type: type);
    _callUid = channelData?.uid;
    _callChannelId = channelData?.channelId;
    if (channelData == null) {
      print('❌ [CallController] 创建RTC频道失败，无法发起通话');
      SmartDialog.showToast('创建通话频道失败');
      return false;
    }

    print('✅ [CallController] RTC频道创建成功: ${channelData.channelId}');

    // 创建通话会话
    final session = CallSession(
      targetUserId: targetUserId,
      callType: callType,
      status: CallStatus.calling,
      isInitiator: true,
      startTime: DateTime.now(),
    );
    currentCall.value = session;

    // 发送通话消息（发起）
    final callTypeStr = callType == CallType.video ? 'video' : 'voice';
    await _sendCallMessage(
      targetUserId: targetUserId,
      callType: callTypeStr,
      callStatus: 'waitCalling', // 初始状态为未接听，等待对方响应
      channelId: channelData.channelId, // 传递频道ID
      chatController: chatController,
      uid: channelData.uid,
    );

    startCallAudio();

    // 根据通话类型设置摄像头状态
    if (callType == CallType.voice) {
      // 语音通话：禁用视频（关闭摄像头）
      await RTCManager.instance.disableVideo();
      print('📞 [CallController] 语音通话，已关闭摄像头');
    } else {
      // 视频通话：启用视频（打开摄像头）
      await RTCManager.instance.enableVideo();
      print('📞 [CallController] 视频通话，已打开摄像头');
    }

    // 加入 RTC 频道，发起真正的通话
    await RTCManager.instance.joinChannel(
      token: channelData.token,
      channelId: channelData.channelId,
      uid: channelData.uid,
      role: ClientRoleType.clientRoleBroadcaster,
      rtcType: RTCType.call,
    );
    print('✅ [CallController] 已加入 RTC 频道: ${channelData.channelId}');

    // 加入 RTC 频道后订阅 RTM 频道
    await RTMManager.instance.subscribe(channelData.channelId);
    print('✅ [CallController] 已订阅 RTM 频道: ${channelData.channelId}');

    return true;
  }

  /// 接听通话
  /// [message] 通话消息
  /// [chatController] 聊天控制器，用于更新通话消息
  Future<bool> acceptCall({
    required EMMessage message,
    ChatController? chatController,
  }) async {
    final callInfo = _parseCallInfo(message);
    if (callInfo == null) {
      return false;
    }

    final targetUserId = message.from ?? '';
    final callTypeStr = callInfo['callType'] as String?;
    final callType = callTypeStr == 'video' ? CallType.video : CallType.voice;

    print(
      '📞 [CallController] 接听${callType == CallType.video ? "视频" : "语音"}通话',
    );

    // 清空之前的远端用户UID和通话信息
    remoteUid.value = null;
    _callChannelId = null;
    _callUid = null;

    // 创建通话会话
    final session = CallSession(
      targetUserId: targetUserId,
      callType: callType,
      status: CallStatus.calling,
      isInitiator: false,
      startTime: DateTime.now(),
    );
    currentCall.value = session;

    // 停止播放来电铃声（已接通）
    stopCallAudio();

    // 开始计时
    _startCallTimer();

    // 从通话信息中获取 channelId 和 uid
    final channelId = callInfo['channelId'] as String?;
    if (channelId == null || channelId.isEmpty) {
      print('❌ [CallController] channelId 为空，无法加入 RTC 频道');
      SmartDialog.showToast('频道ID不存在');
      return false;
    }

    // 保存 channelId 为全局变量
    _callChannelId = channelId;

    // 根据通话类型设置摄像头状态
    if (callType == CallType.voice) {
      // 语音通话：禁用视频（关闭摄像头）
      await RTCManager.instance.disableVideo();
      print('📞 [CallController] 语音通话，已关闭摄像头');
    } else {
      // 视频通话：启用视频（打开摄像头）
      await RTCManager.instance.enableVideo();
      print('📞 [CallController] 视频通话，已打开摄像头');
    }

    // 加入 RTC 频道，接听通话
    await joinChannel(channelId);
    print('✅ [CallController] 已加入 RTC 频道: $channelId');

    // 加入 RTC 频道后，从消息中获取发起方的 uid，设置为远端用户 UID
    final initiatorUid = callInfo['uid'] as int?;
    if (initiatorUid != null) {
      remoteUid.value = initiatorUid;
      print('📞 [CallController] 从消息中获取到发起方 UID: $initiatorUid，已设置 remoteUid');
    }

    return true;
  }

  /// 拒绝通话
  /// [message] 通话消息
  /// [chatController] 聊天控制器，用于更新通话消息
  Future<bool> rejectCall({
    required EMMessage message,
    ChatController? chatController,
  }) async {
    print('📞 [CallController] 拒绝通话');

    // 停止播放来电铃声（已拒绝）
    stopCallAudio();

    // 清理通话会话
    currentCall.value = null;

    // TODO: 这里可以集成实际的通话SDK，拒绝通话
    // 例如：await RTCManager.instance.rejectCall(message.from ?? '');

    return true;
  }

  /// 结束通话（通话完成）
  /// [callDuration] 通话时长（秒）
  /// [chatController] 聊天控制器，用于更新通话消息
  Future<bool> endCall({
    required int callDuration,
    EMMessage? message,
    ChatController? chatController,
  }) async {
    print('📞 [CallController] 结束通话，时长: ${callDuration}秒');

    // 停止播放来电铃声（通话结束）
    stopCallAudio();

    // 停止计时
    _stopCallTimer();

    // 清理通话会话和远端用户UID
    currentCall.value = null;
    remoteUid.value = null;

    // 清理保存的 channelId 和 uid
    _callChannelId = null;
    _callUid = null;

    // TODO: 这里可以集成实际的通话SDK，结束通话
    // 例如：await RTCManager.instance.endCall();

    return true;
  }

  /// 开始通话计时
  void _startCallTimer() {
    _callDurationSeconds = 0;
    callDurationSeconds.value = 0;
    _callTimer?.cancel();
    _callTimer = Timer.periodic(Duration(seconds: 1), (timer) {
      _callDurationSeconds++;
      callDurationSeconds.value = _callDurationSeconds;
    });
  }

  /// 停止通话计时
  void _stopCallTimer() {
    _callTimer?.cancel();
    _callTimer = null;
    _callDurationSeconds = 0;
    callDurationSeconds.value = 0;
  }

  /// 发送通话消息
  Future<bool> _sendCallMessage({
    required String targetUserId,
    required String callType,
    required String callStatus,
    int? callDuration,
    int? uid,
    String? channelId,
    ChatController? chatController,
  }) async {
    // 如果提供了 chatController，使用它发送消息
    return await chatController!.sendCallMessage(
      callType: callType,
      callStatus: callStatus,
      callDuration: callDuration,
      channelId: channelId,
      uid: uid,
    );
  }

  /// 从自定义消息中解析通话信息
  Map<String, dynamic>? _parseCallInfo(EMMessage message) {
    if (message.body.type == MessageType.CUSTOM) {
      final customBody = message.body as EMCustomMessageBody;
      if (customBody.event == 'call' && customBody.params != null) {
        final params = customBody.params!;
        return {
          'callType': params['callType'] ?? 'voice',
          'callStatus': params['callStatus'] ?? 'missed',
          'callDuration': params['callDuration'] != null
              ? int.tryParse(params['callDuration']!)
              : null,
          'channelId': params['channelId'],
          'uid': params['uid'] != null ? int.tryParse(params['uid']!) : null,
        };
      }
    }
    return null;
  }

  /// 检查是否有正在进行的通话
  bool get isInCall => currentCall.value != null;

  /// 获取当前通话时长（秒）
  int get currentCallDuration => callDurationSeconds.value;

  /// 开始播放来电铃声（循环播放）
  /// 可以是发起方或接收方调用
  Future<void> startCallAudio() async {
    if (_isPlayingCallAudio) {
      return; // 已经在播放中
    }

    _isPlayingCallAudio = true;
    print('🔊 [CallController] 开始播放来电铃声');
    await _callAudioPlayer.play(
      AssetSource(Assets.audioCall.replaceFirst('assets/', '')),
    );
  }

  /// 停止播放来电铃声
  /// 可以是发起方或接收方调用
  Future<void> stopCallAudio() async {
    if (!_isPlayingCallAudio) {
      return; // 没有在播放
    }

    _isPlayingCallAudio = false;
    print('🔇 [CallController] 停止播放来电铃声');
    await _callAudioPlayer.stop();
  }

  Future<void> joinChannel(String channelName) async {
    final response = await _networkService.rtcApi.getSwRtcToken(channelName);
    final base = response.data;
    if (base.isSuccess && base.data != null) {
      rtcChannel.value = base.data;

      // 保存 UID 为全局变量
      _callUid = base.data!.uid;

      // 订阅 RTM 频道
      await RTMManager.instance.subscribe(channelName);

      // 获取当前通话信息
      final callSession = currentCall.value;
      final callType = callSession?.callType == CallType.video
          ? 'video'
          : 'voice';

      // 发布 RTM 消息，包含 UID 和通话相关字段
      await RTMManager.instance.publishChannelMessage(
        channelName: channelName,
        message: json.encode({
          'type': 'call_message',
          'uid': base.data!.uid,
          'callType': callType,
          'event': 'accept',
        }),
      );

      await _joinRtcChannel(
        base.data!.token,
        channelName,
        base.data!.uid,
        ClientRoleType.clientRoleBroadcaster,
      );
    }
  }

  Future<void> _joinRtcChannel(
    String token,
    String channelName,
    int uid,
    ClientRoleType roleType,
  ) async {
    final granted = await _ensureRtcPermissions();
    if (!granted) return;
    await RTCManager.instance.joinChannel(
      token: token,
      channelId: channelName,
      uid: uid,
      role: roleType,
      rtcType: RTCType.call,
    );

    final data = {
      'channelId': channelName,
      'seatNumber': 1,
      'isMicrophoneOn': true,
      'isVideoOn': true,
    };
    final response = await _networkService.rtcApi.connectRtcChannel(data);
    if (!response.data.isSuccess) {
      SmartDialog.showToast(response.data.message);
      return;
    }
    SmartDialog.showToast('加入通话成功');
  }

  Future<bool> _ensureRtcPermissions() async {
    final statuses = await [Permission.camera, Permission.microphone].request();
    final allGranted = statuses.values.every((status) => status.isGranted);
    if (allGranted) {
      return true;
    }

    final permanentlyDenied = statuses.values.any(
      (status) => status.isPermanentlyDenied,
    );
    if (permanentlyDenied) {
      SmartDialog.showToast('请在系统设置中开启摄像头和麦克风权限');
      await openAppSettings();
    } else {
      SmartDialog.showToast('请允许摄像头和麦克风权限以进入房间');
    }
    return false;
  }

  /// 切换麦克风状态
  Future<void> toggleMic() async {
    isMicMuted.value = !isMicMuted.value;
    await RTCManager.instance.muteLocalAudio(isMicMuted.value);
    print('📞 [CallController] 麦克风${isMicMuted.value ? "已静音" : "已取消静音"}');
  }

  /// 切换扬声器状态
  Future<void> toggleSpeaker() async {
    isSpeakerOn.value = !isSpeakerOn.value;
    await RTCManager.instance.setEnableSpeakerphone(isSpeakerOn.value);
    print('📞 [CallController] 扬声器${isSpeakerOn.value ? "已开启" : "已关闭"}');
  }

  /// 挂断通话
  Future<void> hangUpCall() async {
    final callSession = currentCall.value;

    // 如果是发起方且处于呼叫中状态（对方还没接听），先调用取消接口
    if (callSession != null &&
        callSession.isInitiator &&
        callDurationSeconds.value == 0 &&
        _callChannelId != null &&
        _callChannelId!.isNotEmpty) {
      final response = await _networkService.rtcApi.cancelOneOnOneRtcChannel({
        'channelId': _callChannelId!,
      });
      if (!response.data.isSuccess) {
        SmartDialog.showToast(response.data.message);
        return;
      }
      print('✅ [CallController] 已调用取消一对一RTC频道接口，channelId: $_callChannelId');
    }

    if (_callChannelId != null &&
        _callChannelId!.isNotEmpty &&
        _callUid != null) {
      final callType = callSession?.callType == CallType.video
          ? 'video'
          : 'voice';

      await RTMManager.instance.publishChannelMessage(
        channelName: _callChannelId!,
        message: json.encode({
          'type': 'call_message',
          'uid': _callUid!,
          'channelId': _callChannelId,
          'callType': callType,
          'event': 'hangup',
        }),
      );
      print(
        '✅ [CallController] 已发送 RTM 挂断消息，channelId: $_callChannelId, uid: $_callUid',
      );
    }

    // 离开RTC频道
    await RTCManager.instance.leaveChannel();

    // 取消订阅 RTM 频道
    if (_callChannelId != null && _callChannelId!.isNotEmpty) {
      await RTMManager.instance.unsubscribe(_callChannelId!);
      print('✅ [CallController] 已取消订阅 RTM 频道: $_callChannelId');
    }

    // 结束通话（传递通话时长）
    await endCall(callDuration: callDurationSeconds.value);

    print('✅ [CallController] 通话已挂断');
  }

  /// 处理挂断消息（对方挂断时调用）
  Future<void> _handleHangupMessage() async {
    // 关闭视频通话邀请弹框（如果正在显示）
    SmartDialog.dismiss();
    print('✅ [CallController] 已关闭视频通话邀请弹框');

    // 停止播放来电铃声
    stopCallAudio();

    // 离开RTC频道
    await RTCManager.instance.leaveChannel();

    // 取消订阅 RTM 频道
    if (_callChannelId != null && _callChannelId!.isNotEmpty) {
      await RTMManager.instance.unsubscribe(_callChannelId!);
      print('✅ [CallController] 已取消订阅 RTM 频道: $_callChannelId');
    }

    // 结束通话
    await endCall(callDuration: callDurationSeconds.value);

    // 关闭通话小窗口
    if (Get.isRegistered<OverlayController>()) {
      final overlayController = Get.find<OverlayController>();
      overlayController.hideVideoCall();
      print('✅ [CallController] 已关闭通话小窗口');
    }

    // 退出 VideoCallPage（如果当前在 VideoCallPage）
    if (Get.currentRoute.contains('VideoCallPage')) {
      Get.back();
      print('✅ [CallController] 已退出 VideoCallPage');
    }
  }

  @override
  void onClose() {
    stopCallAudio();
    _stopCallTimer();
    currentCall.value = null;
    rtcChannel.value = null;
    remoteUid.value = null;
    isMicMuted.value = false;
    isSpeakerOn.value = false;
    _callChannelId = null;
    _callUid = null;
    _callAudioPlayer.dispose();
    super.onClose();
  }
}