dating_touchme_app/lib/controller/discover/room_controller.dart

import 'package:agora_rtc_engine/agora_rtc_engine.dart';
import 'package:agora_token_generator/agora_token_generator.dart';
import 'package:dating_touchme_app/model/live/live_chat_message.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/service/live_chat_message_service.dart';
import 'package:flutter_smart_dialog/flutter_smart_dialog.dart';
import 'package:get/get.dart';
import 'package:permission_handler/permission_handler.dart';

/// 直播房间相关控制器
class RoomController extends GetxController {
  RoomController({NetworkService? networkService})
      : _networkService = networkService ?? Get.find<NetworkService>();

  final NetworkService _networkService;

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

  /// 聊天消息列表
  final RxList<LiveChatMessage> chatMessages = <LiveChatMessage>[].obs;

  /// 消息服务实例
  final LiveChatMessageService _messageService = LiveChatMessageService.instance;

  @override
  void onInit() {
    super.onInit();
    // 注册消息监听
    _registerMessageListener();
  }

  @override
  void onClose() {
    super.onClose();
    // 移除消息监听
    _messageService.unregisterMessageListener();
  }

  /// 注册消息监听
  void _registerMessageListener() {
    _messageService.registerMessageListener(
      onMessageReceived: (message) {
        _addMessage(message);
      },
      onMessageError: (error) {
        print('❌ 消息处理错误: $error');
      },
    );
  }

  /// 添加消息到列表（带去重和数量限制）
  void _addMessage(LiveChatMessage message) {
    // 去重：检查是否已存在相同的消息（基于 userId + content + timestamp）
    final exists = chatMessages.any((m) =>
        m.userId == message.userId &&
        m.content == message.content &&
        (m.timestamp - message.timestamp).abs() < 1000); // 1秒内的相同消息视为重复

    if (exists) {
      print('⚠️ 消息已存在，跳过添加');
      return;
    }

    chatMessages.add(message);
    print('✅ 消息已添加到列表，当前消息数: ${chatMessages.length}');

    // 限制消息数量，最多保留100条
    if (chatMessages.length > 100) {
      chatMessages.removeAt(0);
      print('📝 消息列表已满，移除最旧的消息');
    }
  }

  /// 调用接口创建 RTC 频道
  Future<void> createRtcChannel() async {
    final granted = await _ensureRtcPermissions();
    if (!granted) return;

    try {
      final response = await _networkService.rtcApi.createRtcChannel();
      final base = response.data;
      if (base.isSuccess && base.data != null) {
        rtcChannel.value = base.data;
        await _joinRtcChannel(base.data!.token, base.data!.channelId, base.data!.uid, ClientRoleType.clientRoleBroadcaster);
      } else {
        final message = base.message.isNotEmpty ? base.message : '创建频道失败';
        SmartDialog.showToast(message);
      }
    } catch (e) {
      SmartDialog.showToast('创建频道异常：$e');
    }
  }

  Future<void> joinChannel(String channelName) async {
    try {
      final response = await _networkService.rtcApi.getSwRtcToken(channelName);
      final base = response.data;
      if (base.isSuccess && base.data != null) {
        rtcChannel.value = base.data;
        await _joinRtcChannel(base.data!.token, channelName, base.data!.uid, ClientRoleType.clientRoleAudience);
      }
    } catch (e) {
      SmartDialog.showToast('加入频道异常：$e');
    }
  }

  Future<void> _joinRtcChannel(
    String token,
    String channelName,
    int uid,
      ClientRoleType roleType
  ) async {
    try {
      await RTCManager.instance.joinChannel(
        token: token,
        channelId: channelName,
        uid: uid,
        role: roleType,
      );
    } catch (e) {
      SmartDialog.showToast('加入频道失败：$e');
    }
  }

  /// 发送公屏消息
  Future<void> sendChatMessage(String content) async {
    final channelName = rtcChannel.value?.channelId ?? RTCManager.instance.currentChannelId;

    final result = await _messageService.sendMessage(
      content: content,
      channelName: channelName,
    );

    // 如果发送成功，立即添加到本地列表（优化体验，避免等待 RTM 回调）
    if (result.success && result.message != null) {
      _addMessage(result.message!);
    }
  }

  /// 发送消息（保留原有方法，用于兼容）
  Future<void> sendMessage(String message) async {
    await sendChatMessage(message);
  }

  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> leaveChannel() async {
    await RTCManager.instance.leaveChannel();
  }
}