package com.qianwen.mdc.collect.utils;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import java.lang.invoke.SerializedLambda;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.core.tool.utils.BeanUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.mdc.collect.entity.iotdb.DeviceState;
import com.qianwen.mdc.collect.enums.FeedbackTimePointEnum;
import com.qianwen.mdc.collect.mapper.iotdb.DeviceStateMapper;

public class FeedbackAnalyseUtils {
    private static final Logger log = LoggerFactory.getLogger(FeedbackAnalyseUtils.class);
    /*
    public static List<WorkstationFeedbackTimeQuantumDTO> getRelatedFeedbackTimeQuantumInfo(List<WorkstationFeedbackViewDTO> workstationFeedbackViewList) {
        List<WorkstationFeedbackTimeQuantumDTO> result = new ArrayList<>();
        if (Func.isNotEmpty(workstationFeedbackViewList)) {
            workstationFeedbackViewList.forEach(item -> {
                WorkstationFeedbackTimeQuantumDTO temp = new WorkstationFeedbackTimeQuantumDTO();
                temp.setFeedbackId(item.getWorkstationWcsFeedback().getId());
                temp.setFeedbackTime(item.getWorkstationWcsFeedback().getFeedbackTime());
                temp.setWcs(item.getWorkstationWcsFeedback().getWcs());
                if (Func.isNotEmpty(item.getWorkstationWcsFeedbackDetails())) {
                    item.getWorkstationWcsFeedbackDetails().forEach(detail -> {
                        WorkstationFeedbackTimeQuantumDTO tempTime = (WorkstationFeedbackTimeQuantumDTO) BeanUtil.copyProperties(temp, WorkstationFeedbackTimeQuantumDTO.class);
                        tempTime.setStartTime(detail.getStartTime());
                        tempTime.setFeedbackDetailId(detail.getId());
                        tempTime.setEndTime(detail.getEndTime());
                        result.add(tempTime);
                    });
                } else if (!item.getIsDeleted().booleanValue()) {
                    temp.setStartTime(item.getWorkstationWcsFeedback().getStartTime());
                    temp.setEndTime(item.getWorkstationWcsFeedback().getEndTime());
                    result.add(temp);
                }
            });
        }
        return result;
    }

    // JADX WARN: Multi-variable type inference failed 
    public static List<WorkstationFeedbackTimePointDTO> buildFeedbackTimePointInfo(List<WorkstationFeedbackTimeQuantumDTO> feedbackTimeQuantumDTOList) {
        List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
        List<WorkstationFeedbackTimePointDTO> remove = new ArrayList<>();
        if (Func.isNotEmpty(feedbackTimeQuantumDTOList)) {
            for (int i = 0; i < feedbackTimeQuantumDTOList.size(); i++) {
                WorkstationFeedbackTimeQuantumDTO x = feedbackTimeQuantumDTOList.get(i);
                WorkstationFeedbackTimePointDTO startTimePoint = new WorkstationFeedbackTimePointDTO().setFeedbackId(x.getFeedbackId()).setReportTime(x.getFeedbackTime()).setFeedbackDetailId(x.getFeedbackDetailId()).setFeedbackTime(x.getStartTime()).setWcs(x.getWcs());
                WorkstationFeedbackTimePointDTO endTimePoint = new WorkstationFeedbackTimePointDTO().setFeedbackId(x.getFeedbackId()).setReportTime(x.getFeedbackTime()).setFeedbackTime(x.getEndTime()).setFeedbackDetailId(x.getFeedbackDetailId()).setWcs(x.getWcs());
                result.add(startTimePoint);
                result.add(endTimePoint);
            }
        }
        if (Func.isNotEmpty(result)) {
            result = (List) result.stream().sorted(Comparator.comparing((v0) -> {
                return v0.getReportTime();
            }).thenComparing((v0) -> {
                return v0.getFeedbackTime();
            })).collect(Collectors.toList());
        }
        for (int i2 = 0; i2 < result.size(); i2++) {
            result.get(i2).setIndex(Integer.valueOf(i2));
        }
        getCrossFeedbackTimePoints(result);
        List<WorkstationFeedbackTimePointDTO> finalResult = getEffectFeedbackTimePoints(result, remove);
        return fixFeedbackTimePointInfo(feedbackTimeQuantumDTOList, buildFeedbackTimePointsCompleteInfo(finalResult, remove));
    }

    private static List<WorkstationFeedbackTimePointDTO> fixFeedbackTimePointInfo(List<WorkstationFeedbackTimeQuantumDTO> feedbackTimeQuantumDTOList, List<WorkstationFeedbackTimePointDTO> finalResult) {
        List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
        List<WorkstationFeedbackTimePointDTO> finallyResult = new ArrayList<>();
        new ArrayList();
        List<WorkstationFeedbackTimeQuantumDTO> effectFeedbackTimeQuantumList = (List) feedbackTimeQuantumDTOList.stream().sorted(Comparator.comparing((v0) -> {
            return v0.getFeedbackTime();
        }).thenComparing((v0) -> {
            return v0.getStartTime();
        }).reversed()).collect(Collectors.toList());
        for (WorkstationFeedbackTimePointDTO item : finalResult) {
            if (FeedbackTimePointEnum.CROSS_POINT.isEqual(item.getPointEnum().getValue())) {
                WorkstationFeedbackTimeQuantumDTO matchDto = effectFeedbackTimeQuantumList.stream().filter(x -> {
                    return x.getStartTime().getTime() <= item.getFeedbackTime().getTime() && x.getEndTime().getTime() > item.getFeedbackTime().getTime();
                }).findFirst().orElse(null);
                if (Func.isNotEmpty(matchDto)) {
                    WorkstationFeedbackTimePointDTO tempTime = (WorkstationFeedbackTimePointDTO) BeanUtil.copyProperties(item, WorkstationFeedbackTimePointDTO.class);
                    tempTime.setFeedbackId(matchDto.getFeedbackId());
                    tempTime.setFeedbackDetailId(matchDto.getFeedbackDetailId());
                    tempTime.setWcs(matchDto.getWcs());
                    result.add(tempTime);
                }
            } else {
                result.add(item);
            }
        }
        for (int i = 0; i < result.size(); i++) {
            WorkstationFeedbackTimePointDTO temp = result.get(i);
            if (FeedbackTimePointEnum.CROSS_POINT.isEqual(temp.getPointEnum().getValue()) && FeedbackTimePointEnum.END_POINT.isEqual(result.get(i + 1).getPointEnum().getValue())) {
                temp.setWcs(result.get(i + 1).getWcs());
                temp.setFeedbackId(result.get(i + 1).getFeedbackId());
            }
            finallyResult.add(temp);
        }
        return finallyResult;
    }

    private static void getCrossFeedbackTimePoints(List<WorkstationFeedbackTimePointDTO> timePointList) {
        new ArrayList();
        if (Func.isNotEmpty(timePointList)) {
            for (WorkstationFeedbackTimePointDTO item : timePointList) {
                WorkstationFeedbackTimePointDTO start = timePointList.stream().filter(x -> {
                    return x.getFeedbackTime().getTime() < item.getFeedbackTime().getTime() && x.getIndex().intValue() < item.getIndex().intValue() && !x.getFeedbackId().equals(item.getFeedbackId());
                }).max(Comparator.comparing((v0) -> {
                    return v0.getIndex();
                })).orElse(null);
                WorkstationFeedbackTimePointDTO end = timePointList.stream().filter(x2 -> {
                    return x2.getFeedbackTime().getTime() > item.getFeedbackTime().getTime() && x2.getIndex().intValue() < item.getIndex().intValue() && !x2.getFeedbackId().equals(item.getFeedbackId());
                }).min(Comparator.comparing((v0) -> {
                    return v0.getIndex();
                })).orElse(null);
                if (Func.isNotEmpty(start) && Func.isNotEmpty(end) && start.getFeedbackId().equals(end.getFeedbackId())) {
                    item.setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
                }
            }
        }
    }

    private static List<WorkstationFeedbackTimePointDTO> buildFeedbackTimePointsCompleteInfo(List<WorkstationFeedbackTimePointDTO> effectFeedbackList, List<WorkstationFeedbackTimePointDTO> removeList) {
        new ArrayList();
        if (Func.isNotEmpty(effectFeedbackList)) {
            effectFeedbackList = (List) effectFeedbackList.stream().sorted(Comparator.comparing((v0) -> {
                return v0.getFeedbackTime();
            })).collect(Collectors.toList());
            for (int i = 0; i < effectFeedbackList.size(); i++) {
                if (i == 0) {
                    effectFeedbackList.get(0).setPointEnum(FeedbackTimePointEnum.START_POINT);
                } else if (i == effectFeedbackList.size() - 1) {
                    effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.END_POINT);
                } else {
                    WorkstationFeedbackTimePointDTO prePoint = effectFeedbackList.get(i - 1);
                    WorkstationFeedbackTimePointDTO currentPoint = effectFeedbackList.get(i);
                    WorkstationFeedbackTimePointDTO start = effectFeedbackList.stream().filter(x -> {
                        return x.getFeedbackTime().getTime() < currentPoint.getFeedbackTime().getTime() && !x.getFeedbackId().equals(currentPoint.getFeedbackId());
                    }).max(Comparator.comparing((v0) -> {
                        return v0.getFeedbackTime();
                    })).orElse(null);
                    WorkstationFeedbackTimePointDTO end = effectFeedbackList.stream().filter(x2 -> {
                        return x2.getFeedbackTime().getTime() > currentPoint.getFeedbackTime().getTime() && !x2.getFeedbackId().equals(currentPoint.getFeedbackId());
                    }).min(Comparator.comparing((v0) -> {
                        return v0.getFeedbackTime();
                    })).orElse(null);
                    if (Func.isNotEmpty(start) && Func.isNotEmpty(end) && start.getFeedbackId().equals(end.getFeedbackId())) {
                        currentPoint.setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
                    }
                    if (checkIsCrossFeedbackTimePoint(currentPoint, effectFeedbackList, removeList)) {
                        currentPoint.setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
                    }
                    if (!Func.isNotEmpty(currentPoint.getPointEnum())) {
                        if (Func.isNotEmpty(prePoint.getPointEnum()) && FeedbackTimePointEnum.CROSS_POINT.isEqual(prePoint.getPointEnum().getValue())) {
                            effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.END_POINT);
                        }
                        if (prePoint.getFeedbackId().equals(currentPoint.getFeedbackId())) {
                            effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.END_POINT);
                        } else {
                            if (prePoint.getPointEnum().isEqual(FeedbackTimePointEnum.START_POINT.getValue())) {
                                effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
                            }
                            if (prePoint.getPointEnum().isEqual(FeedbackTimePointEnum.END_POINT.getValue())) {
                                effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.START_POINT);
                            }
                        }
                    }
                }
            }
        }
        return effectFeedbackList;
    }

    private static List<WorkstationFeedbackTimePointDTO> getEffectFeedbackTimePoints(List<WorkstationFeedbackTimePointDTO> originalPointsList, List<WorkstationFeedbackTimePointDTO> removeList) {
        List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
        for (WorkstationFeedbackTimePointDTO item : originalPointsList) {
            if (checkIsKeepFeedbackTimePoint(item, originalPointsList)) {
                result.add(item);
            } else {
                removeList.add(item);
            }
        }
        return result;
    }

    private static boolean checkIsKeepFeedbackTimePoint(WorkstationFeedbackTimePointDTO pointDTO, List<WorkstationFeedbackTimePointDTO> originalPointsList) {
        long min = originalPointsList.stream().filter(x -> {
            return x.getIndex().intValue() > pointDTO.getIndex().intValue() && x.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime();
        }).count();
        if (min <= 0) {
            return true;
        }
        long max = originalPointsList.stream().filter(x2 -> {
            return x2.getIndex().intValue() > pointDTO.getIndex().intValue() && x2.getFeedbackTime().getTime() >= pointDTO.getFeedbackTime().getTime();
        }).count();
        if (max <= 0) {
            return true;
        }
        return false;
    }

    private static boolean checkIsCrossFeedbackTimePoint(WorkstationFeedbackTimePointDTO pointDTO, List<WorkstationFeedbackTimePointDTO> originalPointsList, List<WorkstationFeedbackTimePointDTO> removeList) {
        WorkstationFeedbackTimePointDTO exits;
        List<WorkstationFeedbackTimePointDTO> minList = (List) originalPointsList.stream().filter(x -> {
            return x.getFeedbackTime().getTime() < pointDTO.getFeedbackTime().getTime();
        }).collect(Collectors.toList());
        if (Func.isEmpty(minList)) {
            return false;
        }
        List<WorkstationFeedbackTimePointDTO> maxList = (List) originalPointsList.stream().filter(x2 -> {
            return x2.getFeedbackTime().getTime() > pointDTO.getFeedbackTime().getTime();
        }).collect(Collectors.toList());
        if (Func.isEmpty(maxList)) {
            return false;
        }
        for (WorkstationFeedbackTimePointDTO item : minList) {
            WorkstationFeedbackTimePointDTO exits2 = maxList.stream().filter(x3 -> {
                return x3.getFeedbackId().equals(item.getFeedbackId());
            }).findAny().orElse(null);
            if (Func.isNotEmpty(exits2)) {
                return true;
            }
        }
        for (WorkstationFeedbackTimePointDTO item2 : maxList) {
            if (Func.isNotEmpty(item2.getFeedbackDetailId())) {
                exits = removeList.stream().filter(x4 -> {
                    return Func.isNotEmpty(x4.getFeedbackDetailId()) && x4.getFeedbackDetailId().equals(item2.getFeedbackDetailId()) && x4.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime();
                }).findAny().orElse(null);
            } else {
                exits = removeList.stream().filter(x5 -> {
                    return x5.getFeedbackId().equals(item2.getFeedbackId()) && x5.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime();
                }).findAny().orElse(null);
            }
            if (Func.isNotEmpty(exits)) {
                return true;
            }
        }
        return false;
    }

    public static List<WorkstationFeedbackTimeQuantumDTO> buildFeedbackTimeQuantum(List<WorkstationFeedbackTimePointDTO> effectFeedbackList) {
        List<WorkstationFeedbackTimeQuantumDTO> result = new ArrayList<>();
        List<WorkstationFeedbackTimePointDTO> effectFeedbackList2 = (List) effectFeedbackList.stream().sorted(Comparator.comparing((v0) -> {
            return v0.getFeedbackTime();
        })).collect(Collectors.toList());
        for (int i = 0; i < effectFeedbackList2.size() - 1; i++) {
            WorkstationFeedbackTimePointDTO currentFeedbackPoint = effectFeedbackList2.get(i);
            if (FeedbackTimePointEnum.END_POINT.isEqual(currentFeedbackPoint.getPointEnum().getValue())) {
                break;
            }
            WorkstationFeedbackTimePointDTO nextFeedbackPoint = effectFeedbackList2.get(i + 1);
            WorkstationFeedbackTimeQuantumDTO tempFeedback = new WorkstationFeedbackTimeQuantumDTO();
            tempFeedback.setFeedbackId(currentFeedbackPoint.getFeedbackId());
            tempFeedback.setStartTime(currentFeedbackPoint.getFeedbackTime());
            tempFeedback.setEndTime(nextFeedbackPoint.getFeedbackTime());
            tempFeedback.setWcs(currentFeedbackPoint.getWcs());
            result.add(tempFeedback);
        }
        return result;
    }

    public static Long getStartFeedbackTimePoint(Long workstationId, WorkstationStateMapper stateMapper, List<WorkstationState> processingStateList) {
        if (Func.isNotEmpty(processingStateList)) {
        	//未同步反馈点的最早一条数据
            Long startTime = processingStateList.stream().sorted(Comparator.comparing(WorkstationState::getTs)).collect(Collectors.toList()).get(0).getTs();//最早一条的ts
            
            //查询在反馈点之前一条已同步的数据(小于startTime的最后一条、已同步，IsFixPoint=false的数据)
            WorkstationState startNoFixpoint = stateMapper.getLastWorkstationState(Wrappers.<WorkstationState>lambdaQuery()
            		.eq(WorkstationState::getWorkstationId, workstationId)
            		.lt(WorkstationState::getTs, startTime)
            		.eq(WorkstationState::getIsSync, Boolean.TRUE)
            		.eq(WorkstationState::getIsFixPoint, Boolean.FALSE)
            		
            		.ne(WorkstationState::getIsDeleted, Boolean.TRUE));
            
            
            if (Func.isNotEmpty(startNoFixpoint)) {
                startTime = startNoFixpoint.getTs();
            }
            return startTime;
        }
        return null;
    }
	*/
    /**
     * 
     * @param workstationId
     * @param stateMapper
     * @param processingStateList 未同步反馈点集合
     * @return
     */
    /*
    public static Long getEndFeedbackTimePoint(Long workstationId, WorkstationStateMapper stateMapper, List<WorkstationState> processingStateList) {
        Long result = null;
        if (Func.isNotEmpty(processingStateList)) {
            List<WorkstationState> processingStateList2 = processingStateList.stream().sorted(Comparator.comparing(WorkstationState::getTs)).collect(Collectors.toList());
            WorkstationState endTimePoint = processingStateList2.get(processingStateList2.size() - 1);//最晚的一条时间
            
            if (FeedbackTimePointEnum.END_POINT.isEqual(endTimePoint.getFeedbackPointType())) {//如果该反馈点是结束时间，则查找 第一个 时间晚于该反馈点的已同步状态点
                WorkstationState endNoFixPoint = stateMapper.getFirstWorkstationState(Wrappers.<WorkstationState>lambdaQuery()
                		.eq(WorkstationState::getWorkstationId, workstationId).
                		gt(WorkstationState::getTs, endTimePoint.getTs())
                		.eq(WorkstationState::getIsSync, Boolean.TRUE)
                		.eq(WorkstationState::getIsFixPoint, Boolean.FALSE)
                		.ne(WorkstationState::getIsDeleted, Boolean.TRUE));
                if (Func.isNotEmpty(endNoFixPoint)) {
                    result = endNoFixPoint.getTs();
                }
            }
        }
        return result;
    }
    */
    /**
     * 获得最后一个已同步非反馈点的时间，或者最早一个未同步非反馈点时间
     * @param workstationId
     * @param stateMapper
     * @return
     */
    public static Long getNormalStartTimePoint(Long workstationId, DeviceStateMapper stateMapper) {
    	//isFixPoint 必须是false
    	//获取isSync=true，NO_FEED_BACK_POINT的状态数据
    	/*
    	DeviceState resultTimePoint = stateMapper.getLastWorkstationState( Wrappers.<DeviceState>lambdaQuery()
        		.eq(DeviceState::getWorkstationId, workstationId).eq(DeviceState::getIsSync, Boolean.TRUE).eq(DeviceState::getIsFixPoint, Boolean.FALSE)
        		.eq(DeviceState::getFeedbackPointType, FeedbackTimePointEnum.NO_FEED_BACK_POINT.getValue()).ne(DeviceState::getIsDeleted, Boolean.TRUE));
        		*/
    	DeviceState resultTimePoint = stateMapper.lastSyncedNoFeedbackPointState(workstationId);
        if (Func.isEmpty(resultTimePoint)) {
        	//获取isSync=false,fixpoint=false，NO_FEED_BACK_POINT的数据
        	/*
            resultTimePoint = stateMapper.getFirstWorkstationState(Wrappers.<DeviceState>lambdaQuery().eq(DeviceState::getWorkstationId, workstationId)
            		.eq(DeviceState::getIsSync, Boolean.FALSE)
            		.eq(DeviceState::getIsFixPoint, Boolean.FALSE)
            		.eq(DeviceState::getFeedbackPointType, FeedbackTimePointEnum.NO_FEED_BACK_POINT.getValue())
            		.ne(DeviceState::getIsDeleted, Boolean.TRUE));
            		*/
        	resultTimePoint = stateMapper.firstNotSyncedNofeedbackPointState(workstationId);
        }
        if (Func.isNotEmpty(resultTimePoint)) {
            return resultTimePoint.getTime();
        }
        return null;
    }
}