package com.qianwen.smartman.modules.cps.utils;

import cn.hutool.core.util.NumberUtil;
import cn.hutool.json.JSONTokener;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.smartman.common.cache.RegionCache;
import com.qianwen.smartman.common.cache.cps.WorkstationCache;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.enums.WorkstationParamStateEnum;
import com.qianwen.smartman.common.enums.WorkstationParamTypeEnum;
import com.qianwen.core.tool.jackson.JsonUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.cps.dto.WorkstationParamTypeDTO;
import com.qianwen.smartman.modules.cps.message.dto.AlarmInfoDTO;
import com.qianwen.smartman.modules.cps.message.dto.TelemetryDataResponseDTO;
import com.qianwen.smartman.modules.cps.message.event.TelemetryDataMessage;

/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/cps/utils/TelemetryDataUtils.class */
/**
 * 遥测数据util
 */
public class TelemetryDataUtils {
    private static final Logger log = LoggerFactory.getLogger(TelemetryDataUtils.class);

    public static void handlerStatusUpdateValue(TelemetryDataMessage propertyData, WorkstationParamTypeDTO setting) {
        if (WorkstationParamTypeEnum.STATE.isEqual(setting.getType()) && WorkstationParamStateEnum.COMM_FAILURE.isEqual(propertyData.getDataStatus())) {
            propertyData.setValue("4");
        }
    }

    public static Boolean checkValue(TelemetryDataMessage telemetryDataMessage, WorkstationParamTypeDTO setting) {
        Boolean result = Boolean.TRUE;
        String paramValue = telemetryDataMessage.getValue();
        switch (WorkstationParamTypeEnum.of(setting.getType(), WorkstationParamTypeEnum.OTHER)) {
            case STATE:
                if (!WorkstationParamStateEnum.Good.isEqual(telemetryDataMessage.getDataStatus()) && !WorkstationParamStateEnum.COMM_FAILURE.isEqual(telemetryDataMessage.getDataStatus())) {
                    result = Boolean.FALSE;
                    break;
                } else if (NumberUtil.isInteger(paramValue)) {
                    Integer reallyIotState = Integer.valueOf(Integer.parseInt(paramValue));
                    if (CommonConstant.IOT_STATE_START.intValue() > reallyIotState.intValue() || CommonConstant.IOT_STATE_END.intValue() < reallyIotState.intValue()) {
                        result = Boolean.FALSE;
                        break;
                    }
                } else {
                    log.error("[状态转换错误] 消息详情：{}", paramValue);
                    result = Boolean.FALSE;
                    break;
                }
                break;
            case OUTPUT:
                if (!WorkstationParamStateEnum.Good.isEqual(telemetryDataMessage.getDataStatus())) {
                    result = Boolean.FALSE;
                    break;
                } else if (NumberUtil.isLong(paramValue)) {
                    Long reallyIotOutput = Long.valueOf(Long.parseLong(paramValue));
                    if (reallyIotOutput.longValue() < 0) {
                        log.error("[产量上报非正常值小于0 ] 消息详情：{}", paramValue);
                        result = Boolean.FALSE;
                        break;
                    }
                } else {
                    log.error("[产量转换错误] 消息详情：{}", paramValue);
                    result = Boolean.FALSE;
                    break;
                }
                break;
            case ALARM:
            case ALARM_NO:
                if (!WorkstationParamStateEnum.Good.isEqual(telemetryDataMessage.getDataStatus()) && !WorkstationParamStateEnum.BAD.isEqual(telemetryDataMessage.getDataStatus())) {
                    result = Boolean.FALSE;
                    break;
                }
                break;
            default:
                if (!WorkstationParamStateEnum.Good.isEqual(telemetryDataMessage.getDataStatus())) {
                    result = Boolean.FALSE;
                    break;
                }
                break;
        }
        return result;
    }

    public static TelemetryDataMessage handleTelemetryDataMessage(TelemetryDataMessage telemetryDataMessage, WorkstationParamTypeDTO workstationParam) {
        Boolean checkResult = checkValue(telemetryDataMessage, workstationParam);
        if (!checkResult.booleanValue()) {
            return null;
        }
        switch (WorkstationParamTypeEnum.of(workstationParam.getType(), WorkstationParamTypeEnum.OTHER)) {
            case STATE:
                handlerStatusUpdateValue(telemetryDataMessage, workstationParam);
                break;
            case ALARM:
            case ALARM_NO:
                packWorkStationAlarmMessageInfo(telemetryDataMessage, workstationParam.getWorkstationId());
                break;
            case ALARM_MSG:
                telemetryDataMessage = null;
                break;
            default:
            	break;
                	
        }
        return telemetryDataMessage;
    }

    private static void packWorkStationAlarmMessageInfo(TelemetryDataMessage entity, Long workstationId) {
        List<AlarmInfoDTO> list = new ArrayList<>();
        if (WorkstationParamStateEnum.BAD.isEqual(entity.getDataStatus())) {
            entity.setValue(JsonUtil.toJson(list));
            return;
        }
        try {
            String paramValue = entity.getValue();
            Object checkObject = JSON.parse(paramValue);
            if (checkObject instanceof JSONObject) {
                JSONObject jsonObject = JSON.parseObject(paramValue);
                if (paramValue.contains(CommonConstant.ALARM_ARRAY)) {
                    JSONArray jsonArray = jsonObject.getJSONArray(CommonConstant.ALARM_ARRAY);
                    jsonArray.stream().forEach(json -> {
                        JSONObject alarmInfoObject = (JSONObject) json;
                        AlarmInfoDTO alarmInfoDTO = buildAlarm(alarmInfoObject);
                        if (Func.isNotEmpty(alarmInfoDTO)) {
                            list.add(alarmInfoDTO);
                        }
                    });
                } else {
                    list.add(buildAlarm(jsonObject));
                }
            } else if (checkObject instanceof JSONArray) {
                JSONArray jsonArray2 = JSON.parseArray(paramValue);
                jsonArray2.stream().forEach(json2 -> {
                    JSONObject alarmInfoObject = (JSONObject) json2;
                    list.add(buildAlarm(alarmInfoObject));
                });
            }
            Map<String, Object> workstationRealTime = WorkstationCache.getWorkstationRealTime(workstationId.toString());
            TelemetryDataResponseDTO existingResult = (TelemetryDataResponseDTO) workstationRealTime.get(entity.getName());
            if (Func.isNotEmpty(existingResult)) {
                List<AlarmInfoDTO> alarmInfoDTOS = getAlarmInfo(existingResult.getV());
                list.addAll(0, alarmInfoDTOS);
            }
            entity.setValue(JsonUtil.toJson(handlerRepeatAlarmInfo(list)));
        } catch (Exception e) {
            log.error("[报警转换出错,错误信息：{}]", e.getMessage());
        }
    }

    private static AlarmInfoDTO buildAlarm(JSONObject jsonObject) {
        AlarmInfoDTO propertyData = null;
        try {
            propertyData = new AlarmInfoDTO();
            propertyData.setCode(jsonObject.getString("code"));
            long longTimeStamp = new Long(new Long(jsonObject.getString("timestamp")).longValue()).longValue();
            propertyData.setTimestamp(Long.valueOf(longTimeStamp));
            propertyData.setLevel(jsonObject.getString(CommonConstant.ALARM_LEVEL));
            propertyData.setMsg(jsonObject.getString(CommonConstant.ALARM_MSG));
        } catch (Exception e) {
            log.error("报警时间解析错误：{},原始时间：{}", e.getMessage(), jsonObject.getString("timestamp"));
        }
        return propertyData;
    }

    private static List<AlarmInfoDTO> handlerRepeatAlarmInfo(List<AlarmInfoDTO> alarmInfoDTOS) {
        ArrayList<AlarmInfoDTO>  arrayList = new ArrayList<>(CommonConstant.ALARM_MAX_COUNT.intValue());
        List<AlarmInfoDTO> alarmList = alarmInfoDTOS.stream().collect(
                Collectors.collectingAndThen(
                  Collectors.toCollection(() -> new TreeSet<AlarmInfoDTO>(Comparator.comparing(
                		  alarm -> {
                			  return alarm.getCode() + ";" + alarm.getMsg();
                		  })//end of comparing
                		 )//end new treeset
                		  )//end toCollection
                , ArrayList::new)//collectingAndThen
                );
        
        alarmList = alarmList.stream().sorted(Comparator.comparing(AlarmInfoDTO::getTimestamp).reversed()).collect(Collectors.toList());
        /*
        List<AlarmInfoDTO> alarmList = (List) ((List) alarmInfoDTOS.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> {
            return new TreeSet(Comparator.comparing(alarm -> {
                return alarm.getCode() + ";" + alarm.getMsg();
            }));
        }), (v1) -> {
            return new ArrayList(v1);
        }))).stream().sorted(Comparator.comparing((v0) -> {
            return v0.getTimestamp();
        }).reversed()).collect(Collectors.toList());
        */
        for (int i = 0; i < alarmList.size() && arrayList.size() < CommonConstant.ALARM_MAX_COUNT.intValue(); i++) {
            arrayList.add(alarmList.get(i));
        }
        return arrayList;
    }

    private static List<AlarmInfoDTO> getAlarmInfo(String value) {
        List<AlarmInfoDTO> alarmInfoDTOS = new ArrayList<>();
        try {
            Object json = new JSONTokener(value).nextValue();
            if (json instanceof JSONObject) {
                AlarmInfoDTO jsonObject = (AlarmInfoDTO) JSON.parseObject(value, AlarmInfoDTO.class);
                alarmInfoDTOS.add(jsonObject);
            } else {
                alarmInfoDTOS.addAll(JSON.parseArray(value, AlarmInfoDTO.class));
            }
        } catch (Exception e) {
            log.error("[报警转换出错,错误信息：{}]", e.getMessage());
        }
        return alarmInfoDTOS;
    }
}