import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

import 'package:flutter_easyloading/flutter_easyloading.dart';
import 'package:get/get.dart';
import 'package:path_provider/path_provider.dart';
import 'package:star_lock/app_settings/app_settings.dart';
import 'package:star_lock/talk/call/g711.dart';
import 'package:star_lock/talk/startChart/constant/message_type_constant.dart';
import 'package:star_lock/talk/startChart/constant/talk_status.dart';
import 'package:star_lock/talk/startChart/entity/scp_message.dart';
import 'package:star_lock/talk/startChart/handle/scp_message_base_handle.dart';
import 'package:star_lock/talk/startChart/handle/scp_message_handle.dart';
import 'package:star_lock/talk/startChart/proto/gateway_reset.pb.dart';
import 'package:star_lock/talk/startChart/proto/generic.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_data.pb.dart';
import 'package:star_lock/talk/startChart/proto/talk_data.pbserver.dart';
import 'package:star_lock/talk/startChart/proto/talk_data_h264_frame.pb.dart';

class UdpTalkDataHandler extends ScpMessageBaseHandle
    implements ScpMessageHandler {
  @override
  void handleReq(ScpMessage scpMessage) {}

  @override
  void handleResp(ScpMessage scpMessage) {}

  @override
  void handleInvalidReq(ScpMessage scpMessage) {}

  @override
  void handleRealTimeData(ScpMessage scpMessage) {
    // 收到数据后调用更新，防止定时器超时
    talkDataOverTimeTimerManager.renew();
    if (scpMessage.Payload != null) {
      final TalkData talkData = scpMessage.Payload;
      // 处理音视频数据
      _handleTalkData(talkData: talkData);
    }
  }

  String bufferToHexString(List<int> buffer) {
    return buffer.map((byte) => byte.toRadixString(16).padLeft(2, '0')).join();
  }

  @override
  deserializePayload(
      {required int payloadType,
      required int messageType,
      required List<int> byte,
      int? offset,
      int? PayloadLength,
      int? spTotal,
      int? spIndex,
      int? messageId}) {
    // AppLog.log(
    //     '没有组包之前的每一个包的数据:${byte.length} messageId:$messageId spTotal:$spTotal spIndex:$spIndex PayloadLength:$PayloadLength,byte:${bufferToHexString(byte)}');
    if (messageType == MessageTypeConstant.RealTimeData) {
      // 回声测试
      if (spTotal != null &&
          spTotal > 1 &&
          messageId != null &&
          spIndex != null) {
        // 分包处理
        return handleFragmentedPayload(
          messageId: messageId,
          spTotal: spTotal,
          spIndex: spIndex,
          byte: byte,
          payloadType: payloadType,
        );
      } else {
        // 没有分包直接解析
        final TalkData talkData = TalkData();
        talkData.mergeFromBuffer(byte);
        return talkData;
      }
    }
  }

  String listToHexString(List<int> intList) {
    // 将整数列表转换为十六进制字符串列表
    List<String> hexList = intList.map((num) => num.toRadixString(16)).toList();
    // 将十六进制字符串列表连接成一个字符串，没有空格
    return hexList.join('');
  }

  void _handleTalkData({required TalkData talkData}) {
    if (talkData == null) return;
    final contentType = talkData.contentType;
    switch (contentType) {
      case TalkData_ContentTypeE.H264:
        _handleVideoH264(talkData);
        break;
      case TalkData_ContentTypeE.Image:
        _handleVideoImage(talkData);
        break;
      case TalkData_ContentTypeE.G711:
        _handleVideoG711(talkData);
        break;
      default:
        print('❌未知的TalkData--->contentType类型');
        break;
    }
  }

  /// 处理h264协议的数据
  void _handleVideoH264(TalkData talkData) {
    final TalkDataH264Frame talkDataH264Frame = TalkDataH264Frame();
    talkDataH264Frame.mergeFromBuffer(talkData.content);
    AppLog.log('H264 TalkData :$talkDataH264Frame');
    talkDataRepository.addTalkData(talkData);
  }

  /// 处理图片数据
  void _handleVideoImage(TalkData talkData) async {
    final List<Uint8List> processCompletePayload =
        await _processCompletePayload(Uint8List.fromList(talkData.content));
    // AppLog.log('得到完整的帧：${processCompletePayload.length}'); // 循环发送每一帧的数据

    processCompletePayload.forEach((element) {
      talkData.content = element;
      talkDataRepository.addTalkData(talkData);
    });
  }

  /// 处理g711音频数据
  void _handleVideoG711(TalkData talkData) {
    try {
      final g711Data = talkData.content;
      // 转pcm数据
      List<int> pcmBytes = G711().convertList(g711Data);
      talkData.content = pcmBytes;
      talkDataRepository.addTalkData(talkData);
    } catch (e) {
      print('Error decoding G.711 to PCM: $e');
    }
  }

  Future<List<Uint8List>> _processCompletePayload(Uint8List payload) async {
    // 存储找到的所有完整帧
    List<Uint8List> frames = [];

    // 寻找完整帧 (0xFFD8 开始, 0xFFD9 结束)
    int startIdx = 0;
    while (startIdx < payload.length - 1) {
      // 找到帧的起始标志 0xFFD8
      startIdx = payload.indexOf(0xFF, startIdx);
      if (startIdx == -1 || startIdx + 1 >= payload.length) break;
      if (payload[startIdx + 1] == 0xD8) {
        // 找到帧的起始标志 0xFFD8
        int endIdx = startIdx + 2;
        while (endIdx < payload.length - 1) {
          endIdx = payload.indexOf(0xFF, endIdx);
          if (endIdx == -1 || endIdx + 1 >= payload.length) break;
          if (payload[endIdx + 1] == 0xD9) {
            // 找到帧的结束标志 0xFFD9
            Uint8List frame = payload.sublist(startIdx, endIdx + 2);
            frames.add(frame);
            startIdx = endIdx + 2; // 继续寻找下一个帧
            break;
          } else {
            endIdx += 1; // 继续寻找结束标志
          }
        }
      } else {
        startIdx += 1; // 继续寻找下一个起始标志
      }
    }

    // 返回找到的所有完整帧
    return frames;
  }
}