package com.zksy.environment.service.impl;

import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zksy.environment.domain.po.PictureMessage;
import com.zksy.environment.mapper.PictureMessageMapper;
import com.zksy.environment.service.PictureMessageService;
import com.zksy.environment.utils.DataCheckUtil;
import com.zksy.environment.utils.DateTimeUtil;
import com.zksy.environment.utils.HexToImageConverter;
import com.zksy.service.MinioFileStorageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.File;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;
import java.util.regex.Pattern;

/**
 * <p>
 * 遥测站图片报或中心站查询遥测站图片采集信息 服务实现类
 * </p>
 *
 * @author Yang
 * @since 2024-08-09
 */
@Slf4j
@Service
public class PictureMessageServiceImpl extends ServiceImpl<PictureMessageMapper, PictureMessage> implements PictureMessageService {
    private final List<String> allDataSegments = new ArrayList<>();
    private final Object lock = new Object();
    private HashMap<String,String> map = new HashMap<>();
    @Autowired
    private MinioFileStorageService minioFileStorageService;
    @Override
    public boolean savePictureMessage(String oldDataStr, String dataStr) {
        boolean flag = false;
        try {
            PictureMessage pictureMessage = new PictureMessage();
            // 解析数据包
            String SYN = dataStr.substring(0, 2);
            String totalHex = dataStr.substring(2, 5);
            String total = DataCheckUtil.hexToDecimalExample(totalHex);
            String packageNumberHex = dataStr.substring(5, 8);
            String packageNumber = DataCheckUtil.hexToDecimalExample(packageNumberHex);

            // 处理数据包
            String segment;
            if ("01".equals(packageNumber)) {
                // 解析初始数据包
                String serialNumber = dataStr.substring(8, 12);
                String dataTime = dataStr.substring(12, 24);
                String sendingMessageTime = "20" + dataTime;
                map.put("sendingMessageTime", DateTimeUtil.parseDateTime(sendingMessageTime).toString());

                // 测站地址
                int stationAddressIndex = dataStr.indexOf("f1f1");
                if (stationAddressIndex != -1 && stationAddressIndex + 10 < dataStr.length()) {
                    String result = dataStr.substring(stationAddressIndex + 4, stationAddressIndex + 14);
                    map.put("measuringStationAddress",result);
                }

                // 测站类型
                Pattern pattern = Pattern.compile("F0F0", Pattern.CASE_INSENSITIVE);
                String[] f0F0s = pattern.split(dataStr);
                String f0F0 = f0F0s[0];
                if (f0F0.length() >= 2) {
                    String prefix = f0F0.substring(f0F0.length() - 2);
                    map.put("measuringStationType",prefix);
                }

                // 观测时间
                String f0F01 = f0F0s[1];
                if (f0F01.length() >= 10) {
                    String digits = f0F01.substring(0, 10);
                    String observeTime = "20" + digits + "00";
                    map.put("observeTime",DateTimeUtil.parseDateTime(observeTime).toString());
                }

                // 初始化数据段列表
                synchronized (lock) {
                    ((ArrayList<String>) allDataSegments).ensureCapacity(Integer.parseInt(total));
                }

                // 对于首个包，直接获取数据段
                List<String> dataSegments = new ArrayList<>();
                int startIndex = dataStr.indexOf("f3f3");
                if (startIndex != -1) {
                    segment = dataStr.substring(startIndex + "f3f3".length());
                    dataSegments.add(segment);
                }
                segment = String.join("", dataSegments);
            } else {
                // 对于非首个包，直接获取数据段
                segment = dataStr.substring(8);
            }

            // 保存数据段
            synchronized (lock) {
                int index = Integer.parseInt(packageNumber) - 1;
                if (index >= allDataSegments.size()) {
                    // 如果索引超出范围，扩展列表大小
                    while (allDataSegments.size() <= index) {
                        allDataSegments.add(null);
                    }
                }
                allDataSegments.set(index, segment);

                System.out.println("packageNumber====="+packageNumber+"total====="+total);
                // 检查是否所有数据包都已经收到
                if (Integer.parseInt(packageNumber) == Integer.parseInt(total)) {
                    // 重新组合所有的数据包
                    StringBuilder completeImageDataBuilder = new StringBuilder();
                    for (String segment1 : allDataSegments) {
                        // 确保 segment 不为 null
                        if (segment1 != null) {
                            completeImageDataBuilder.append(segment1);
                        }
                    }
                    String completeImageData = completeImageDataBuilder.toString();
                    System.out.println("图片集合：" + completeImageData);
                    File image = HexToImageConverter.hexStringToImage(completeImageData, "output.png");

                    if(ObjectUtils.isNotEmpty(image)){
                        String filePath = minioFileStorageService.uploadFileByFile(image, "environment-image");
                        // 设置完整的消息
                        pictureMessage.setMessage(filePath);
                        System.out.println("pictureMessage=====" + pictureMessage);
                        // 设置 ID 和创建时间
                        pictureMessage.setId(UUID.randomUUID().toString().replace("-", ""));
                        pictureMessage.setCreateTime(LocalDateTime.now());
                        pictureMessage.setSendingMessageTime(LocalDateTime.parse(map.get("sendingMessageTime")));
                        pictureMessage.setMeasuringStationAddress(map.get("measuringStationAddress"));
                        pictureMessage.setMeasuringStationType(map.get("measuringStationType"));
                        pictureMessage.setObserveTime(LocalDateTime.parse(map.get("observeTime")));
                        // 执行保存操作
                        flag = super.save(pictureMessage);
                    }
                    allDataSegments.clear(); // 清空列表以便下次使用
                }
            }
            return flag;
        } catch (Exception e) {
            log.info("==========数据解析错误==========", oldDataStr);
            e.printStackTrace();
            allDataSegments.clear(); // 清空列表以便下次使用
        }
        return flag;
    }
}