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

import java.util.ArrayList;
import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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.entity.mgr.WorkstationWcsFeedback;
import com.qianwen.mdc.collect.entity.mgr.WorkstationWcsFeedbackDetail;
import com.qianwen.mdc.collect.enums.FeedbackDetailStatusEnum;
import com.qianwen.mdc.collect.enums.FeedbackProcessStatusEnum;
import com.qianwen.mdc.collect.enums.FeedbackTimePointEnum;
import com.qianwen.mdc.collect.dto.StateAggregateTimeDTO;
import com.qianwen.mdc.collect.entity.iotdb.AggregateStateWithFeedback;
import com.qianwen.mdc.collect.entity.iotdb.DeviceState;
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.service.AggregateStateWithFeedbackService;
import com.qianwen.mdc.collect.service.DeviceStateService;
import com.qianwen.mdc.collect.mapper.iotdb.AggregateStateWithFeedbackMapper;
import com.qianwen.mdc.collect.mapper.iotdb.DeviceStateMapper;
import com.qianwen.mdc.collect.utils.WorkstationStateAggregateCancelFeedbackUtils;

@Component
public class CancelFeedbackHandlerStrategy implements WorkstationFeedbackHandlerStrategy {
    private static final Logger log = LoggerFactory.getLogger(CancelFeedbackHandlerStrategy.class);
    @Autowired
    private WorkstationWcsFeedbackMapper feedbackMapper;
    @Autowired
    private AggregateStateWithFeedbackMapper  stateWithFeedbackMapper;
    @Autowired
    private WorkstationWcsFeedbackDetailMapper feedbackDetailMapper;
    @Autowired
    private DeviceStateMapper stateMapper;
    
    @Autowired
    private DeviceStateService stateService;
    
    @Autowired
    private AggregateStateWithFeedbackService  aggregateStateWithFeedbackService;
    /*
    public CancelFeedbackHandlerStrategy(final WorkstationWcsFeedbackMapper feedbackMapper, final WorkstationWcsFeedbackDetailMapper feedbackDetailMapper) {
        this.feedbackMapper = feedbackMapper;
        this.feedbackDetailMapper = feedbackDetailMapper;
    }*/

    @Override
    public void handlerFeedback(WorkstationWcsFeedback feedback) {
        //WorkstationStateMapper stateMapper = (WorkstationStateMapper)SpringUtil.getBean(WorkstationStateMapper.class);
        //WorkstationAggregateStateWithFeedbackMapper stateWithFeedbackMapper = (WorkstationAggregateStateWithFeedbackMapper)SpringUtil.getBean(WorkstationAggregateStateWithFeedbackMapper.class);
        if (Func.isNotEmpty(feedback)) {
          WorkstationWcsFeedbackDetail cancelDetail = this.feedbackDetailMapper.selectOne(Wrappers.<WorkstationWcsFeedbackDetail>lambdaQuery()
              .eq(WorkstationWcsFeedbackDetail::getWorkstationId, feedback.getWorkstationId())
              .eq(WorkstationWcsFeedbackDetail::getFeedbackId, feedback.getId())
              .eq(WorkstationWcsFeedbackDetail::getCancel, 1));
          
          DeviceState startState = wrapperCancelWorkstationStateTimePoint(feedback.getWorkstationId(), cancelDetail.getStartTime().getTime(), true);
          DeviceState endState =   wrapperCancelWorkstationStateTimePoint(feedback.getWorkstationId(), cancelDetail.getEndTime().getTime(), false);
          /*
          DeviceState startNoFeedState = stateMapper.getLastWorkstationState(Wrappers.<WorkstationState>lambdaQuery()
              .eq(WorkstationState::getWorkstationId, feedback.getWorkstationId())
              .lt(WorkstationState::getTs,cancelDetail.getStartTime().getTime())
              .eq(WorkstationState::getIsFixPoint, Boolean.FALSE)
              .eq(WorkstationState::getFeedbackPointType, FeedbackTimePointEnum.NO_FEED_BACK_POINT.getValue())
              .ne(WorkstationState::getIsDeleted, Boolean.TRUE));
              */
          DeviceState startNoFeedState = stateMapper.lastNoFeedbackStateLessThanTime(feedback.getWorkstationId(),cancelDetail.getStartTime().getTime());//这个方法刚刚改过，还没测试
          /*
          List<WorkstationState> effectStateList = stateMapper.selectList(Wrappers.<WorkstationState>lambdaQuery()
              .eq(WorkstationState::getWorkstationId, feedback.getWorkstationId())
              .le(WorkstationState::getTs, cancelDetail.getEndTime().getTime())
              .ge(WorkstationState::getTs, cancelDetail.getStartTime().getTime())
              .and(wrapper -> wrapper.eq(WorkstationState::getIsDeleted, Boolean.FALSE).or().isNull(WorkstationState::getIsDeleted))
              .orderByAsc(WorkstationState::getTs));
              */
          StateAggregateTimeDTO timeRange = new StateAggregateTimeDTO();
          timeRange.setStartTime(cancelDetail.getStartTime().getTime());
          timeRange.setEndTime(cancelDetail.getEndTime().getTime());
          List<DeviceState> effectStateList = stateMapper.statesInTimeRange(feedback.getWorkstationId(), timeRange);
          
          List<AggregateStateWithFeedback> aggregateResult = WorkstationStateAggregateCancelFeedbackUtils.buildAggregateList(effectStateList, startNoFeedState);
          
          if (FeedbackTimePointEnum.END_POINT.isEqual(endState.getFeedbackPointType())) {
        	  /*
              WorkstationState endNoFeedState = stateMapper.getLastWorkstationState(Wrappers.<WorkstationState>lambdaQuery()
                  .eq(WorkstationState::getWorkstationId, feedback.getWorkstationId())
                  .lt(WorkstationState::getTs, Long.valueOf(cancelDetail.getEndTime().getTime()))
                  .eq(WorkstationState::getIsFixPoint, Boolean.FALSE)
                  .eq(WorkstationState::getFeedbackPointType, FeedbackTimePointEnum.NO_FEED_BACK_POINT.getValue())
                  .ne(WorkstationState::getIsDeleted, Boolean.TRUE));
                  */
        	  DeviceState endNoFeedState = stateMapper.lastNoFeedbackStateLessThanTime(feedback.getWorkstationId(), cancelDetail.getEndTime().getTime());
        	  /*
              WorkstationAggregateStateWithFeedback match = stateWithFeedbackMapper.selectOne(Wrappers.<WorkstationAggregateStateWithFeedback>lambdaQuery()
                  .eq(WorkstationAggregateStateWithFeedback::getWorkstationId, feedback.getWorkstationId())
                  .eq(WorkstationAggregateStateWithFeedback::getTs, endState.getTs())
                  .eq(WorkstationAggregateStateWithFeedback::getEndTime, Long.valueOf(endState.getTs().longValue() + 1L)));
              */
              AggregateStateWithFeedback match = stateWithFeedbackMapper.workstationStateByTimeAndEndTime(feedback.getWorkstationId(),endState.getTime(),endState.getTime() + 1L);;
              
              if (Func.isNotEmpty(match)) {
                if (Func.isNotEmpty(endNoFeedState)) {
                  match.setValueCollect(endNoFeedState.getValueCollect());
                  match.setWcs(endNoFeedState.getWcs());
                  match.setRps(endNoFeedState.getRps());
                  match.setIsPlan(endNoFeedState.getIsPlan());
                } else {
                  match.setValueCollect(Integer.valueOf(0));
                  match.setWcs(Integer.valueOf(0));
                  match.setRps(Integer.valueOf(0));
                  match.setIsPlan(Integer.valueOf(0));
                } 
                aggregateResult.add(match);
              } 
            } 
            List<DeviceState> insertWorkstationState = new ArrayList<>();
            insertWorkstationState.add(startState);
            insertWorkstationState.add(endState);
            //stateMapper.batchSave(feedback.getWorkstationId(), insertWorkstationState);
            stateService.saveDeviceStates(insertWorkstationState);
            
            //stateWithFeedbackMapper.batchSave(feedback.getWorkstationId(), aggregateResult);
            aggregateStateWithFeedbackService.saveStatesWithFeedback(aggregateResult);
            
            //更新反馈状态
            feedback.setStatus(FeedbackProcessStatusEnum.COMPLETED.getValue().intValue());
            cancelDetail.setStatus(FeedbackDetailStatusEnum.LOSE_EFFECT.getValue());
            this.feedbackDetailMapper.updateById(cancelDetail);
            this.feedbackMapper.updateById(feedback);
          /*
          
          
          */
        } 
      }

    private DeviceState wrapperCancelWorkstationStateTimePoint(Long workstationId, Long time, boolean isStartPoint) {
        //WorkstationStateMapper stateMapper = (WorkstationStateMapper) SpringUtil.getBean(WorkstationStateMapper.class);
        /*
        WorkstationState startState = stateMapper.selectOne(Wrappers.<WorkstationState>lambdaQuery().eq(WorkstationState::getWorkstationId
        , workstationId).ne(WorkstationState::getIsDeleted, Boolean.TRUE).eq(WorkstationState::getTs, time));
        */
    	DeviceState startState = stateMapper.getByWorkstationIdAndTime(workstationId,time);
        if (isStartPoint) {
            if (FeedbackTimePointEnum.CROSS_POINT.isEqual(startState.getFeedbackPointType())) {
                startState.setFeedbackPointType(FeedbackTimePointEnum.END_POINT.getValue());
            } else if (FeedbackTimePointEnum.START_POINT.isEqual(startState.getFeedbackPointType())) {
                startState.setIsDeleted(true);
            }
        } else if (FeedbackTimePointEnum.CROSS_POINT.isEqual(startState.getFeedbackPointType())) {
            startState.setFeedbackPointType(FeedbackTimePointEnum.START_POINT.getValue());
        } else if (FeedbackTimePointEnum.END_POINT.isEqual(startState.getFeedbackPointType())) {
            startState.setIsDeleted(true);
        }
        return startState;
    }
}