package com.qianwen.mdc.collect.utils;

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.dto.WorkstationFeedbackTimePointDTO;
import com.qianwen.mdc.collect.dto.WorkstationFeedbackTimeQuantumDTO;
import com.qianwen.mdc.collect.dto.WorkstationFeedbackViewDTO;
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 = 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;
    }
    
    public static List<WorkstationFeedbackTimePointDTO> buildFeedbackTimePointInfo(List<WorkstationFeedbackTimeQuantumDTO> feedbackTimeQuantumDTOList) {
        List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
        List<WorkstationFeedbackTimePointDTO> remove = new ArrayList<>();
        if (Func.isNotEmpty(feedbackTimeQuantumDTOList))
          for (int j = 0; j < feedbackTimeQuantumDTOList.size(); j++) {
            WorkstationFeedbackTimeQuantumDTO x = feedbackTimeQuantumDTOList.get(j);
            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 = result.stream().sorted(Comparator.comparing(WorkstationFeedbackTimePointDTO::getReportTime)
        			.thenComparing(WorkstationFeedbackTimePointDTO::getFeedbackTime)).collect(Collectors.toList());
        }
        for (int i = 0; i < result.size(); i++) {
        	result.get(i).setIndex(i);
        }
        getCrossFeedbackTimePoints(result);
        List<WorkstationFeedbackTimePointDTO> finalResult = getEffectFeedbackTimePoints(result, remove);
        finalResult = buildFeedbackTimePointsCompleteInfo(finalResult, remove);
        finalResult = fixFeedbackTimePointInfo(feedbackTimeQuantumDTOList, finalResult);
        return finalResult;
    }
    
    private static void getCrossFeedbackTimePoints(List<WorkstationFeedbackTimePointDTO> timePointList) {
    	//List<WorkstationFeedbackTimePointDTO> finalResult = new ArrayList<>();
        if (Func.isNotEmpty(timePointList)) {
          for (WorkstationFeedbackTimePointDTO item : timePointList) {
            WorkstationFeedbackTimePointDTO start = timePointList.stream().filter(x -> (x.getFeedbackTime().getTime() < item.getFeedbackTime().getTime() && x.getIndex() < item.getIndex() && !x.getFeedbackId().equals(item.getFeedbackId()))).max(Comparator.comparing(WorkstationFeedbackTimePointDTO::getIndex)).orElse(null);
            WorkstationFeedbackTimePointDTO end = timePointList.stream().filter(x -> (x.getFeedbackTime().getTime() > item.getFeedbackTime().getTime() && x.getIndex() < item.getIndex() && !x.getFeedbackId().equals(item.getFeedbackId()))).min(Comparator.comparing(WorkstationFeedbackTimePointDTO::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) {
		//List<WorkstationFeedbackTimePointDTO> feedBackTimePointList = new ArrayList<>();
		if (Func.isNotEmpty(effectFeedbackList)) {
			effectFeedbackList = (List<WorkstationFeedbackTimePointDTO>) effectFeedbackList.stream()
					.sorted(Comparator.comparing(WorkstationFeedbackTimePointDTO::getFeedbackTime))
					.collect(Collectors.toList());
			for (int i = 0; i < effectFeedbackList.size(); i++) {
				if (i == 0) {
					((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(0))
							.setPointEnum(FeedbackTimePointEnum.START_POINT);
				} else if (i == effectFeedbackList.size() - 1) {
					((WorkstationFeedbackTimePointDTO) 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 -> (x.getFeedbackTime().getTime() < currentPoint.getFeedbackTime().getTime()
									&& !x.getFeedbackId().equals(currentPoint.getFeedbackId())))
							.max(Comparator.comparing(WorkstationFeedbackTimePointDTO::getFeedbackTime)).orElse(null);
					WorkstationFeedbackTimePointDTO end = effectFeedbackList.stream()
							.filter(x -> (x.getFeedbackTime().getTime() > currentPoint.getFeedbackTime().getTime()
									&& !x.getFeedbackId().equals(currentPoint.getFeedbackId())))
							.min(Comparator.comparing(WorkstationFeedbackTimePointDTO::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()))
							((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
									.setPointEnum(FeedbackTimePointEnum.END_POINT);
						if (prePoint.getFeedbackId().equals(currentPoint.getFeedbackId())) {
							((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
									.setPointEnum(FeedbackTimePointEnum.END_POINT);
						} else {
							if (prePoint.getPointEnum().isEqual(FeedbackTimePointEnum.START_POINT.getValue()))
								((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
										.setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
							if (prePoint.getPointEnum().isEqual(FeedbackTimePointEnum.END_POINT.getValue()))
								((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
										.setPointEnum(FeedbackTimePointEnum.START_POINT);
						}
					}
				}
			}
		}
		return effectFeedbackList;
	}
    
    private static boolean checkIsCrossFeedbackTimePoint(WorkstationFeedbackTimePointDTO pointDTO, List<WorkstationFeedbackTimePointDTO> originalPointsList, List<WorkstationFeedbackTimePointDTO> removeList) {
        List<WorkstationFeedbackTimePointDTO> minList = (List<WorkstationFeedbackTimePointDTO>)originalPointsList.stream().filter(x -> (x.getFeedbackTime().getTime() < pointDTO.getFeedbackTime().getTime())).collect(Collectors.toList());
        if (Func.isEmpty(minList))
          return false; 
        List<WorkstationFeedbackTimePointDTO> maxList = (List<WorkstationFeedbackTimePointDTO>)originalPointsList.stream().filter(x -> (x.getFeedbackTime().getTime() > pointDTO.getFeedbackTime().getTime())).collect(Collectors.toList());
        if (Func.isEmpty(maxList))
          return false; 
        for (WorkstationFeedbackTimePointDTO item : minList) {
          WorkstationFeedbackTimePointDTO exits = maxList.stream().filter(x -> x.getFeedbackId().equals(item.getFeedbackId())).findAny().orElse(null);
          if (Func.isNotEmpty(exits))
            return true; 
        } 
        for (WorkstationFeedbackTimePointDTO item : maxList) {
          WorkstationFeedbackTimePointDTO exits = null;
          if (Func.isNotEmpty(item.getFeedbackDetailId())) {
            exits = removeList.stream().filter(x -> (Func.isNotEmpty(x.getFeedbackDetailId()) && x.getFeedbackDetailId().equals(item.getFeedbackDetailId()) && x.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime())).findAny().orElse(null);
          } else {
            exits = removeList.stream().filter(x -> (x.getFeedbackId().equals(item.getFeedbackId()) && x.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime())).findAny().orElse(null);
          } 
          if (Func.isNotEmpty(exits))
            return true; 
        } 
        return false;
      }
    
    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() > pointDTO.getIndex() && x2.getFeedbackTime().getTime() >= pointDTO.getFeedbackTime().getTime();
        }).count();
        if (max <= 0) {
            return true;
        }
        return false;
    }
    
    private static List<WorkstationFeedbackTimePointDTO> fixFeedbackTimePointInfo(List<WorkstationFeedbackTimeQuantumDTO> feedbackTimeQuantumDTOList, List<WorkstationFeedbackTimePointDTO> finalResult) {
        List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
        List<WorkstationFeedbackTimePointDTO> finallyResult = new ArrayList<>();
        List<WorkstationFeedbackTimeQuantumDTO> effectFeedbackTimeQuantumList = new ArrayList<>();
        effectFeedbackTimeQuantumList = (List<WorkstationFeedbackTimeQuantumDTO>)feedbackTimeQuantumDTOList.stream().sorted(Comparator.comparing(WorkstationFeedbackTimeQuantumDTO::getFeedbackTime).thenComparing(WorkstationFeedbackTimeQuantumDTO::getStartTime).reversed()).collect(Collectors.toList());
        for (WorkstationFeedbackTimePointDTO item : finalResult) {
          if (FeedbackTimePointEnum.CROSS_POINT.isEqual(item.getPointEnum().getValue())) {
            WorkstationFeedbackTimeQuantumDTO matchDto = effectFeedbackTimeQuantumList.stream().filter(x -> (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);
            } 
            continue;
          } 
          result.add(item);
        } 
        for (int i = 0; i < result.size(); i++) {
          WorkstationFeedbackTimePointDTO temp = result.get(i);
          if (FeedbackTimePointEnum.CROSS_POINT.isEqual(temp.getPointEnum().getValue()))
            if (FeedbackTimePointEnum.END_POINT.isEqual(((WorkstationFeedbackTimePointDTO)result.get(i + 1)).getPointEnum().getValue())) {
              temp.setWcs(((WorkstationFeedbackTimePointDTO)result.get(i + 1)).getWcs());
              temp.setFeedbackId(((WorkstationFeedbackTimePointDTO)result.get(i + 1)).getFeedbackId());
            }  
          finallyResult.add(temp);
        } 
        return finallyResult;
      }
    /*
    // 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 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 = 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;
    }
}