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

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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.qianwen.mdc.collect.config.MqttConfig;
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.FeedbackTypeEnum;
import com.qianwen.mdc.collect.mapper.mgr.WorkstationWcsFeedbackDetailMapper;
import com.qianwen.mdc.collect.mapper.mgr.WorkstationWcsFeedbackMapper;
import com.qianwen.mdc.collect.mqtt.MqttMessageSender;
import com.qianwen.mdc.collect.utils.redis.RedisUtil;

import cn.hutool.core.util.ObjectUtil;

@DS("master")
@Service
public class WorkstationFeedbackService{
    private static final Logger log = LoggerFactory.getLogger(WorkstationFeedbackService.class);
    /**
     * 发消息的
     */
    //private final WorkstationFeedbackAnalyseProducer workstationFeedbackProducer;//
    @Autowired
    private WorkstationWcsFeedbackMapper workstationWcsFeedbackMapper;
    @Autowired
    private WorkstationWcsFeedbackDetailMapper workstationWcsFeedbackDetailMapper;
    
    //private final BladeRedis bladeRedis;
    
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private MqttMessageSender mqttMessageSender;
    
    //final String feedbackExecuteTopic = "forward/feedback";
    /*
    public WorkstationFeedbackService(final WorkstationFeedbackAnalyseProducer workstationFeedbackProducer, final WorkstationWcsFeedbackMapper workstationWcsFeedbackMapper, final WorkstationWcsFeedbackDetailMapper workstationWcsFeedbackDetailMapper, final BladeRedis bladeRedis) {
        this.workstationFeedbackProducer = workstationFeedbackProducer;
        this.workstationWcsFeedbackMapper = workstationWcsFeedbackMapper;
        this.workstationWcsFeedbackDetailMapper = workstationWcsFeedbackDetailMapper;
        this.bladeRedis = bladeRedis;
    }*/

    /**
     * 发送消息
     * @param workstationId
     */
    public void sendFeedbackAnalyseMessageForWorkStation(String workstationId) {
        //List<WorkstationFeedbackAnalyseMessage> WorkstationFeedbackMessages = new ArrayList<>();
    	List<String> workstationIds = new ArrayList<>();
        if (ObjectUtil.isNotEmpty(workstationId)) {
            //WorkstationFeedbackMessages.add(new WorkstationFeedbackAnalyseMessage().setWorkStationId(workstationId));
            workstationIds.add(workstationId);
        } else {
            List<WorkstationWcsFeedback> feedbacks = this.workstationWcsFeedbackMapper.selectList(Wrappers.<WorkstationWcsFeedback>lambdaQuery()
            		.eq(WorkstationWcsFeedback::getStatus, FeedbackProcessStatusEnum.WAITING.getValue()));
            
            if (!feedbacks.isEmpty()) {
                List<Long> workStationIdList = feedbacks.stream().map(WorkstationWcsFeedback::getWorkstationId).distinct().collect(Collectors.toList());
                workStationIdList.forEach(wId -> {
                    //WorkstationFeedbackMessages.add(new WorkstationFeedbackAnalyseMessage().setWorkStationId(workStationId.toString()));
                	workstationIds.add(wId.toString());
                });
            }
        }
        if (!workstationIds.isEmpty()) {
        	for(String wid : workstationIds) {
        		mqttMessageSender.sendMessage(MqttConfig.FEEDBACK_TOPIC, wid);
        	}
        	
            //this.workstationFeedbackProducer.sendWorkstationFeedbackAnalyseMessage(WorkstationFeedbackMessages);
        }
    }

    
   // @RedisLock(value = "lock:posting:state", param = "#workstationId", leaseTime = 240)
    /**
     * 处理状态反馈
     * @param workstationId
     */
    public void executeWaitAnalyseFeedback(Long workstationId) {
        if (checkSuitableExecuteAnalyseFeedback(workstationId)) {
            List<WorkstationWcsFeedback> waitingFeedbackList = this.workstationWcsFeedbackMapper.selectList(Wrappers.<WorkstationWcsFeedback>lambdaQuery()
            		.eq(WorkstationWcsFeedback::getWorkstationId, workstationId).eq(WorkstationWcsFeedback::getStatus, FeedbackProcessStatusEnum.WAITING.getValue()));
            
            WorkstationWcsFeedback firstFeedback = waitingFeedbackList.stream().sorted(Comparator.comparing(WorkstationWcsFeedback::getFeedbackTime)).findFirst().orElse(null);
            if (firstFeedback == null) {
                return;
            }
            FeedbackTypeEnum feedbackType = checkSuitableFeedbackHandlerStrategy(firstFeedback);
            WorkstationFeedbackHandlerFactory.getInstance().getConcreteStrategy(feedbackType.getType()).handlerFeedback(firstFeedback);
            //this.bladeRedis.del("blade:feedback::id:".concat(firstFeedback.getId().toString()));
            redisUtil.del("blade:feedback::id:".concat(firstFeedback.getId().toString()));
        }
    }

    /**/
    /**
     * 处理反馈完成，在状态聚合完成的时候调用
     * @param workstationId
     */
    public void handlerFeedbackComplete(Long workstationId) {
        WorkstationWcsFeedback processFeedback = this.workstationWcsFeedbackMapper.selectOne(Wrappers.<WorkstationWcsFeedback>lambdaQuery()
        		.eq(WorkstationWcsFeedback::getWorkstationId, workstationId).eq(WorkstationWcsFeedback::getStatus, FeedbackProcessStatusEnum.PROCESSING.getValue()));
        if (processFeedback != null) {
            Integer processStatus = FeedbackProcessStatusEnum.COMPLETED.getValue();
            if (ObjectUtil.isEmpty(processFeedback.getEndTime())) {
                processStatus = FeedbackProcessStatusEnum.WAITING.getValue();
            }
            this.workstationWcsFeedbackDetailMapper.update(null, Wrappers.<WorkstationWcsFeedbackDetail>lambdaUpdate()
            		.eq(WorkstationWcsFeedbackDetail::getWorkstationId, workstationId)
            		.ge(WorkstationWcsFeedbackDetail::getStartTime, processFeedback.getStartTime())
            		.le(ObjectUtil.isNotEmpty(processFeedback.getEndTime()), WorkstationWcsFeedbackDetail::getEndTime, processFeedback.getEndTime())
            				.eq(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.EFFECTED.getValue())
            				.set(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.LOSE_EFFECT.getValue()));
            this.workstationWcsFeedbackMapper.update(null, Wrappers.<WorkstationWcsFeedback>lambdaUpdate().eq(WorkstationWcsFeedback::getWorkstationId, workstationId)
            		.eq(WorkstationWcsFeedback::getStatus, FeedbackProcessStatusEnum.PROCESSING.getValue())
            		.set(WorkstationWcsFeedback::getStatus, processStatus));
            //this.bladeRedis.del("blade:feedback::id:".concat(processFeedback.getId().toString()));
            this.redisUtil.del("blade:feedback::id:".concat(processFeedback.getId().toString()));
            List<WorkstationWcsFeedbackDetail> detailList = this.workstationWcsFeedbackDetailMapper.selectList(Wrappers.<WorkstationWcsFeedbackDetail>lambdaQuery()
            		.eq(WorkstationWcsFeedbackDetail::getWorkstationId, workstationId)
            		.eq(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.BE_EFFECTIVE.getValue()));
            if (!detailList.isEmpty()) {
                List<Long> feedbackList = detailList.stream().map(x -> {
                    return x.getFeedbackId();
                }).distinct().collect(Collectors.toList());
                
                this.workstationWcsFeedbackDetailMapper.update(null, Wrappers.<WorkstationWcsFeedbackDetail>lambdaUpdate()
                		.in(WorkstationWcsFeedbackDetail::getFeedbackId, feedbackList)
                		.eq(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.EFFECTED.getValue())
                		.set(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.LOSE_EFFECT.getValue()));
                
                this.workstationWcsFeedbackDetailMapper.update(null, Wrappers.<WorkstationWcsFeedbackDetail>lambdaUpdate()
                		.in(WorkstationWcsFeedbackDetail::getFeedbackId, feedbackList)
                		.eq(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.BE_EFFECTIVE.getValue())
                		.set(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.EFFECTED.getValue()));
                detailList.forEach(item -> {
                    //this.bladeRedis.del("blade:feedback::id:".concat(item.getId().toString()));
                    this.redisUtil.del("blade:feedback::id:".concat(item.getId().toString()));
                });
            }
        }
    }
	
    private FeedbackTypeEnum checkSuitableFeedbackHandlerStrategy(WorkstationWcsFeedback feedback) {
        Long waitCancelCount = this.workstationWcsFeedbackDetailMapper.selectCount(Wrappers.<WorkstationWcsFeedbackDetail>lambdaQuery()
        		.eq(WorkstationWcsFeedbackDetail::getFeedbackId, feedback.getId())
        		.eq(WorkstationWcsFeedbackDetail::getStatus, FeedbackDetailStatusEnum.EFFECTED.getValue()).eq(WorkstationWcsFeedbackDetail::getCancel, 1));
        
        if (waitCancelCount > 0) {//存在feedbackdetail，且状态是撤销的就要撤销反馈
            return FeedbackTypeEnum.CANCEL_FEEDBACK;
        }
        if (FeedbackTypeEnum.TIME_RANGE_FEEDBACK.isEqual(Integer.valueOf(feedback.getFeedbackType()))) {
            return FeedbackTypeEnum.TIME_RANGE_FEEDBACK;
        }
        if (ObjectUtil.isNotEmpty(feedback.getEndTime())) {
            return FeedbackTypeEnum.TIME_RANGE_FEEDBACK;
        }
        return FeedbackTypeEnum.IMMEDIATE_FEEDBACK;
    }

    /**
     * 检查，存在 执行中的，等待执行的都视为检查不通过
     * @param workStationId
     * @return
     */
    private boolean checkSuitableExecuteAnalyseFeedback(Long workStationId) {
        Long processingFeedbackCount = this.workstationWcsFeedbackMapper.selectCount( Wrappers.<WorkstationWcsFeedback>lambdaQuery()
        		.eq(WorkstationWcsFeedback::getWorkstationId, workStationId).eq(WorkstationWcsFeedback::getStatus, FeedbackProcessStatusEnum.PROCESSING.getValue()));
        if (processingFeedbackCount > 0) {
            return false;
        }
        
        Long waitProcessFeedbackCount = this.workstationWcsFeedbackMapper.selectCount(Wrappers.<WorkstationWcsFeedback>lambdaQuery()
        		.eq(WorkstationWcsFeedback::getWorkstationId, workStationId).eq(WorkstationWcsFeedback::getStatus, FeedbackProcessStatusEnum.WAITING.getValue()));
        if (waitProcessFeedbackCount > 0) {
            return true;
        }
        return false;
    }
}