package com.qianwen.mdc.collect.service;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
import org.apache.iotdb.tsfile.write.record.Tablet;
import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.google.common.collect.Lists;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.SpringUtil;
import com.qianwen.mdc.collect.cache.WorkstationCache;
import com.qianwen.mdc.collect.config.IotDBSessionConfig;
import com.qianwen.mdc.collect.constants.CommonConstant;
import com.qianwen.mdc.collect.constants.IOTDBConstant;
import com.qianwen.mdc.collect.dto.CalendarShiftInfoDTO;
import com.qianwen.mdc.collect.dto.StateAggregateTimeDTO;
import com.qianwen.mdc.collect.dto.WorkstationDTO;
import com.qianwen.mdc.collect.entity.iotdb.AggregateState;
import com.qianwen.mdc.collect.entity.iotdb.DeviceState;
import com.qianwen.mdc.collect.enums.FeedbackTimePointEnum;
import com.qianwen.mdc.collect.mapper.iotdb.DeviceStateMapper;
import com.qianwen.mdc.collect.mapper.mgr.CalendarMapper;
import com.qianwen.mdc.collect.service.feedback.WorkstationFeedbackService;
import com.qianwen.mdc.collect.utils.FeedbackAnalyseUtils;
import com.qianwen.mdc.collect.utils.LocalDateTimeUtils;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
/**
 * 设备状态聚合服务
 */
@Service
public class DeviceStateAggregateService{
    private static final Logger log = LoggerFactory.getLogger(DeviceStateAggregateService.class);
    
    @Autowired
    private CalendarMapper calendarMapper;
    @Autowired
    private DeviceStateMapper stateMapper;
    @Autowired
    private WorkstationCache workstationCache;
    @Autowired
	private IotDBCommonService iotDBCommonService;
    @Autowired
	private IotDBSessionConfig iotdbConfig;
    @Autowired
	private DeviceStateService deviceStateService;
    @Autowired
	private DeviceStateAggregateNoFeedbackService stateAggregateNoFeedbackService;
   
    @Autowired
	private WorkstationFeedbackService workstationFeedbackService;
    
    public void stateAggregate(Long workstationId) {
    	////获取时间阶段列表(2个),一个noFeedbackTime=true，一个noFeedbackTime=false,我们自己返回一个startTime，endTime即可，noFeedbackTime=true的即可
        //List<StateAggregateTimeDTO> effective = getCurrentStateAggregateTimeRange(workstationId);
    	StateAggregateTimeDTO timeRange = getAggregateTimeRange(workstationId);
        List<AggregateState> noFeedbackAggregateList = new ArrayList<>();
        
        //List<WorkstationAggregateStateWithFeedback> feedbackAggregateList = new ArrayList<>();//暂时不需要，没人填写反馈
        List<DeviceState> noFeedbackStateList = new ArrayList<>();//回填的列表
        noFeedbackAggregateList.addAll(this.stateAggregateNoFeedbackService.stateAggregateForSpecialTimeRange(workstationId, timeRange, noFeedbackStateList));
        
        /*
        Collection<DeviceState> effectiveState = getReallyEffectWorkstationStateList(noFeedbackStateList, feedbackStateList);
        List<DeviceState> effectiveStateList = effectiveState.stream().map(x -> {
            x.setIsSync(Boolean.TRUE);
            return x;
        }).collect(Collectors.toList());*/
        noFeedbackStateList.forEach(state -> {state.setIsSync(true);});//TODO 是否需要生成新列表？避免被修改数据
        
        //this.stateAggregateWithFeedbackService.handlerAggregateState(feedbackAggregateList, workstationId, effective);
        this.stateAggregateNoFeedbackService.handlerAggregateState(noFeedbackAggregateList, workstationId, timeRange);//过滤出有效状态数据并保存
        //更新isSync得状态
        /*
        if (Func.isNotEmpty(effectiveStateList)) {
            Map<String, List> stringListMap = CommonUtil.groupList(effectiveStateList, CommonConstant.MAX_RECORDS_FOR_SQL_LENGTH.intValue());
            stringListMap.forEach((k, v) -> {
                this.workstationStateMapper.batchSave(workstationId, v);
            });
        }*/
        deviceStateService.saveDeviceStates(noFeedbackStateList);//更新isSync=true
        ////使用workstationWcsFeedbackMapper更新反馈得状态,我们不需要
        //IWorkstationFeedbackService workstationFeedbackService = SpringUtil.getBean(IWorkstationFeedbackService.class);
        workstationFeedbackService.handlerFeedbackComplete(workstationId);
    }
    
   
    private StateAggregateTimeDTO getAggregateTimeRange(Long workstationId) {
        Long normalStartTime = FeedbackAnalyseUtils.getNormalStartTimePoint(workstationId, stateMapper);//最后一个已同步的isFixPoint=false时间，或者最新一个未同步的。总之就是查找聚合开始时间点。
    	//这个
    	StateAggregateTimeDTO nofeedBackTimeRange2 = new StateAggregateTimeDTO();
        nofeedBackTimeRange2.setStartTime(normalStartTime);
        nofeedBackTimeRange2.setEndTime(System.currentTimeMillis());
        nofeedBackTimeRange2.setNoFeedbackTime(Boolean.FALSE);

        return nofeedBackTimeRange2;
    }
    
    /**
     * 获取时间范围？？？
     */
    /*
    private List<StateAggregateTimeDTO> getCurrentStateAggregateTimeRange(Long workstationId) {
        Long currentTime = Long.valueOf(System.currentTimeMillis());
        List<StateAggregateTimeDTO> effectiveTimeRangeList = new ArrayList<>();
        //WorkstationStateMapper stateMapper = SpringUtil.getBean(WorkstationStateMapper.class);
        //List<DeviceState> processingStateList = stateMapper.getProcessingFeedbackState(workstationId); // is_sync = false AND feedback_point_type != 0
        List<DeviceState> processingStateList = Collections.emptyList();//我们没有feedback_point_type != 0的数据，就是没有反馈点数据
        Long normalStartTime = FeedbackAnalyseUtils.getNormalStartTimePoint(workstationId, stateMapper);//最后一个已同步的isFixPoint=false时间，或者最新一个未同步的。总之就是查找聚合开始时间点。
        if (Func.isNotEmpty(processingStateList)) {//非空(有未同步的反馈点)
        	//!!!这个IF里数据没用
        	//查找starttime，endtime (sync=true,IsFixPoint=false) : startTime<  processingStateList < endTime
            //Long startTime = FeedbackAnalyseUtils.getStartFeedbackTimePoint(workstationId, stateMapper, processingStateList);
            //Long endTime = FeedbackAnalyseUtils.getEndFeedbackTimePoint(workstationId, stateMapper, processingStateList);
        	Long startTime = 0L;//临时数据，没用
            Long endTime =0L;
            
            StateAggregateTimeDTO feedbackTimeRange = new StateAggregateTimeDTO();
            feedbackTimeRange.setNoFeedbackTime(Boolean.FALSE);
            feedbackTimeRange.setStartTime(startTime);
            if (Func.isNotEmpty(endTime)) {
                feedbackTimeRange.setEndTime(endTime);
            } else {
                endTime = currentTime;
                feedbackTimeRange.setEndTime(currentTime);
            }
            if (Func.isNotEmpty(normalStartTime)) {
                if (normalStartTime.longValue() <= startTime.longValue()) {
                    feedbackTimeRange.setStartTime(startTime);
                }
                if (startTime.longValue() >= normalStartTime.longValue() && endTime.longValue() >= normalStartTime.longValue()) {
                    feedbackTimeRange.setEndTime(currentTime);
                }
                if (normalStartTime.longValue() > endTime.longValue()) {
                	StateAggregateTimeDTO nofeedBackTimeRange = new StateAggregateTimeDTO();
                    nofeedBackTimeRange.setStartTime(normalStartTime);
                    nofeedBackTimeRange.setNoFeedbackTime(Boolean.FALSE);
                    nofeedBackTimeRange.setEndTime(currentTime);
                    effectiveTimeRangeList.add(nofeedBackTimeRange);
                }
            } else {
                feedbackTimeRange.setStartTime(null);
                feedbackTimeRange.setEndTime(currentTime);
            }
            effectiveTimeRangeList.add(feedbackTimeRange);
        } else {
        	//这个
        	StateAggregateTimeDTO nofeedBackTimeRange2 = new StateAggregateTimeDTO();
            nofeedBackTimeRange2.setStartTime(normalStartTime);
            nofeedBackTimeRange2.setEndTime(currentTime);
            nofeedBackTimeRange2.setNoFeedbackTime(Boolean.FALSE);
            effectiveTimeRangeList.add(nofeedBackTimeRange2);
        }
        StateAggregateTimeDTO nofeedBackTimeRange3 = new StateAggregateTimeDTO();
        nofeedBackTimeRange3.setStartTime(normalStartTime);
        nofeedBackTimeRange3.setEndTime(currentTime);
        nofeedBackTimeRange3.setNoFeedbackTime(Boolean.TRUE);
        
        effectiveTimeRangeList.add(nofeedBackTimeRange3);
        return effectiveTimeRangeList;
    }
    */
    /**
     * 去重的作用，将所有状态数据去重放到一个列表
     * @param noFeedbackStateList
     * @param feedbackStateList
     * @return
     */
    /*
    private Collection<DeviceState> getReallyEffectWorkstationStateList(List<DeviceState> noFeedbackStateList, List<DeviceState> feedbackStateList) {
        HashMap<Long, DeviceState> workstationStateMap = new HashMap<>();
        if (Func.isNotEmpty(noFeedbackStateList)) {
            noFeedbackStateList.forEach(item -> {
                workstationStateMap.put(item.getTime(), item);
            });
        }
        if (Func.isNotEmpty(feedbackStateList)) {
            for (DeviceState state : feedbackStateList) {
                if (!workstationStateMap.containsKey(state.getTime())) {
                    workstationStateMap.put(state.getTime(), state);
                }
            }
        }
        return workstationStateMap.values();
    }*/
}