package com.qianwen.mdc.collect.service.feedback;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.SpringUtil;
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.entity.mgr.WorkstationWcsFeedback;
import com.qianwen.mdc.collect.entity.mgr.WorkstationWcsFeedbackDetail;
import com.qianwen.mdc.collect.enums.FeedbackDetailStatusEnum;
import com.qianwen.mdc.collect.enums.FeedbackTimePointEnum;
import com.qianwen.mdc.collect.enums.FeedbackTypeEnum;
import com.qianwen.mdc.collect.mapper.iotdb.DeviceStateMapper;
import com.qianwen.mdc.collect.mapper.mgr.WorkstationWcsFeedbackDetailMapper;
import com.qianwen.mdc.collect.mapper.mgr.WorkstationWcsFeedbackMapper;
import com.qianwen.mdc.collect.utils.FeedbackAnalyseUtils;

public class NoImmediateFeedbackAnalyseResultBuilder {
    private NoImmediateFeedbackAnalyseResult result = new NoImmediateFeedbackAnalyseResult();
    WorkstationWcsFeedbackMapper workstationWcsFeedbackMapper = SpringUtil.getBean(WorkstationWcsFeedbackMapper.class);
    WorkstationWcsFeedbackDetailMapper workstationWcsFeedbackDetailMapper = SpringUtil.getBean(WorkstationWcsFeedbackDetailMapper.class);
    DeviceStateMapper workstationStateMapper = SpringUtil.getBean(DeviceStateMapper.class);

    

    public static NoImmediateFeedbackAnalyseResultBuilder get() {
        return new NoImmediateFeedbackAnalyseResultBuilder();
    }

    public NoImmediateFeedbackAnalyseResultBuilder buildFeedbackBaseInfo(WorkstationWcsFeedback feedback) {
        List<Long> haveRelatedId = new ArrayList<>();
        haveRelatedId.add(feedback.getId());
        recursionRelatedWorkstationFeedbacks(feedback, haveRelatedId);
        List<WorkstationWcsFeedback> relatedWorkstationFeedbackList = this.workstationWcsFeedbackMapper.selectList(
            Wrappers.<WorkstationWcsFeedback>lambdaQuery().in(WorkstationWcsFeedback::getId, haveRelatedId));
        Date startTime = relatedWorkstationFeedbackList.stream().min(Comparator.comparing(WorkstationWcsFeedback::getStartTime)).map(WorkstationWcsFeedback::getStartTime).get();
        Date endTime = relatedWorkstationFeedbackList.stream().max(Comparator.comparing(WorkstationWcsFeedback::getEndTime)).map(WorkstationWcsFeedback::getEndTime).get();
        List<WorkstationFeedbackViewDTO> workstationFeedbackViewList = new ArrayList<>(relatedWorkstationFeedbackList.size());
        relatedWorkstationFeedbackList.forEach(item -> {
              WorkstationFeedbackViewDTO temp = new WorkstationFeedbackViewDTO();
              temp.setWorkstationWcsFeedback(item);
              temp.setIsDeleted(false);
              if (FeedbackTypeEnum.TIME_RANGE_FEEDBACK.isEqual(Integer.valueOf(feedback.getFeedbackType()))) {
                List<WorkstationWcsFeedbackDetail> detailList = this.workstationWcsFeedbackDetailMapper.selectList(Wrappers.<WorkstationWcsFeedbackDetail>lambdaQuery()
                		.eq(WorkstationWcsFeedbackDetail::getCancel, 0)
                		.eq(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.EFFECTED.getValue())
                		.eq(WorkstationWcsFeedbackDetail::getFeedbackId, item.getId()));
                if (Func.isNotEmpty(detailList)) {
                  temp.setWorkstationWcsFeedbackDetails(detailList);
                } else {
                  List<WorkstationWcsFeedbackDetail> deletedList = this.workstationWcsFeedbackDetailMapper.selectList(Wrappers.<WorkstationWcsFeedbackDetail>lambdaQuery()
                		  .eq(WorkstationWcsFeedbackDetail::getCancel, 1).eq(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.LOSE_EFFECT.getValue())
                		  .eq(WorkstationWcsFeedbackDetail::getFeedbackId, item.getId()));
                  if (Func.isNotEmpty(deletedList))
                    temp.setIsDeleted(true); 
                } 
              } 
              workstationFeedbackViewList.add(temp);
            });
        this.result.setFeedbackId(feedback.getId());
        this.result.setWorkstationId(feedback.getWorkstationId());
        this.result.setEffectiveFeedbackViewList(workstationFeedbackViewList);
        this.result.setEffectiveStartDate(startTime);
        this.result.setEffectiveEndDate(endTime);
        return this;
      }

    public NoImmediateFeedbackAnalyseResultBuilder buildFeedbackTimePointInfo() {
        List<WorkstationFeedbackTimeQuantumDTO> relatedFeedbackTimeQuantumInfo = FeedbackAnalyseUtils.getRelatedFeedbackTimeQuantumInfo(this.result.getEffectiveFeedbackViewList());
        List<WorkstationFeedbackTimePointDTO> workstationFeedbackTimePointDTOS = FeedbackAnalyseUtils.buildFeedbackTimePointInfo(relatedFeedbackTimeQuantumInfo);
        this.result.setEffectiveFeedbackTimePointList(workstationFeedbackTimePointDTOS);
        return this;
    }

    public NoImmediateFeedbackAnalyseResultBuilder buildFeedbackTimeQuantumInfo() {
        this.result.setEffectiveFeedbackTimeQuantumList(FeedbackAnalyseUtils.buildFeedbackTimeQuantum(this.result.getEffectiveFeedbackTimePointList()));
        return this;
    }

    public NoImmediateFeedbackAnalyseResultBuilder buildFeedbackComplementStateInfo() {
        if (Func.isNotEmpty(this.result.getEffectiveFeedbackTimePointList())) {
          List<DeviceState> workstationStateList = new ArrayList<>();
          for (WorkstationFeedbackTimePointDTO item : this.result.getEffectiveFeedbackTimePointList()) {
        	  /*
        	  DeviceState resultTimePoint = this.workstationStateMapper.getLastWorkstationState(Wrappers.<WorkstationState>lambdaQuery()
                .eq(WorkstationState::getWorkstationId, this.result.getWorkstationId())
                .le(WorkstationState::getTs, Long.valueOf(item.getFeedbackTime().getTime()))
                .eq(WorkstationState::getIsFixPoint, Boolean.FALSE)
                .eq(WorkstationState::getFeedbackPointType, FeedbackTimePointEnum.NO_FEED_BACK_POINT.getValue())
                .ne(WorkstationState::getIsDeleted, Boolean.TRUE));
        	  */
        	  DeviceState resultTimePoint = workstationStateMapper.lastNoFeedbackStateLeTime(this.result.getWorkstationId(),item.getFeedbackTime().getTime());//这个没有测试
        	  if (Func.isEmpty(resultTimePoint)) {
	             resultTimePoint = new DeviceState();
	             resultTimePoint.setWorkstationId(this.result.getWorkstationId());
	             resultTimePoint.setWcs(0);
	             resultTimePoint.setValueCollect(0);
	             resultTimePoint.setRps(0);
	             resultTimePoint.setIsSync(false);
	             resultTimePoint.setIsFixPoint(false);
        	  } 
            resultTimePoint.setIsDeleted(false);
            resultTimePoint.setFeedbackPointType(FeedbackTimePointEnum.NO_FEED_BACK_POINT.getValue());
            resultTimePoint.setIsSync(false);
            resultTimePoint.setTime(Long.valueOf(item.getFeedbackTime().getTime() + 1L));
            workstationStateList.add(resultTimePoint);
          } 
          this.result.setCompensateStateList(workstationStateList);
        } 
        return this;
      }

    private void recursionRelatedWorkstationFeedbacks(WorkstationWcsFeedback workstationWcsFeedback, List<Long> haveRelatedId) {
        WorkstationWcsFeedbackMapper workstationWcsFeedbackMapper = SpringUtil.getBean(WorkstationWcsFeedbackMapper.class);
        List<WorkstationWcsFeedback> relatedWorkstationWcsFeedbacks = workstationWcsFeedbackMapper.getRelatedWorkstationWcsFeedbacks(workstationWcsFeedback, haveRelatedId);
        if (Func.isNotEmpty(relatedWorkstationWcsFeedbacks)) {
          haveRelatedId.addAll((Collection<? extends Long>)relatedWorkstationWcsFeedbacks.stream().map(WorkstationWcsFeedback::getId).collect(Collectors.toList()));
          relatedWorkstationWcsFeedbacks.forEach(x -> recursionRelatedWorkstationFeedbacks(x, haveRelatedId));
        } 
      }

    public NoImmediateFeedbackAnalyseResult analyse() {
        return this.result;
    }
}