package com.tievd.jyz.Timer;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.RandomUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.tievd.jyz.cache.AlgorithmCache;
import com.tievd.jyz.constants.SystemConstant;
import com.tievd.jyz.entity.*;
import com.tievd.jyz.entity.vo.ClientVo;
import com.tievd.jyz.entity.vo.OilStatisVo;
import com.tievd.jyz.service.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;


@Slf4j
@Component
@EnableScheduling
public class SystemSchedule {

    @Autowired
    ICameraService cameraService;
    
    @Autowired
    IOilStaticService oilStaticService;
    
    @Autowired
    IOilRecordService oilRecordService;
    
    @Autowired
    IOiloutRecordService oiloutRecordService;
    
    @Autowired
    IOiloutEventService oiloutEventService;
    
    @Autowired
    IClientConfigService clientConfigService;
    
    /**
     * 统计车辆加油停靠等数据
     */
    @Scheduled(cron = "${jyz.timer.oil-statis:0 0 * * * ?}")
    public void statisOil() {
        log.info("----------------开始统计车辆信息数据-----------------");
        LambdaQueryWrapper<OilRecord> wrapper = new LambdaQueryWrapper();
//        wrapper.ge(OilRecord::getStartTime, statisTime);
        wrapper.isNotNull(OilRecord::getStandard)
                .isNotNull(OilRecord::getBehavior)
                .isNotNull(OilRecord::getStartTime);
        wrapper.orderByDesc(OilRecord::getStartTime);
        List<OilRecord> recordList = oilRecordService.list(wrapper);
        //数据统计
        Map<String, OilStatisVo> statisMap = new HashMap<>();
    
        //客户类型
        Map<String, List<OilRecord>> recordMap = new HashMap<>();

        for (OilRecord oilRecord : recordList) {
            String statisKey = oilRecord.getLicenseNum() + "_" + oilRecord.getOrgCode();
            statisMap.putIfAbsent(statisKey, new OilStatisVo(oilRecord));
            OilStatisVo statisVo = statisMap.get(statisKey);
            //出现次数
            statisVo.setAppearCount(statisVo.getAppearCount() + 1);
            //加油次数
            if (SystemConstant.BEHAVIOR_TYPE_OIL == oilRecord.getBehavior() + 0 ) {
                statisVo.setOilCount(statisVo.getOilCount() + 1);
    
                recordMap.putIfAbsent(statisKey, new ArrayList<>());
                recordMap.get(statisKey).add(oilRecord);
            }
            //加油量
            int oilVolume = oilRecord.getOilVolume() == null ? 0 : oilRecord.getOilVolume();
            statisVo.setOilSum(statisVo.getOilSum() + oilVolume);
            //异常次数
            if (SystemConstant.STANDARD_ERROR == oilRecord.getStandard() + 0 ) {
                statisVo.setEventCount(statisVo.getEventCount() + 1);
            }
            //停留时间
            int spandTime = oilRecord.getSpandTime() == null ? 0 : oilRecord.getSpandTime();
            statisVo.setStayTime(statisVo.getStayTime() + spandTime);
            
            //加油位
            if (StringUtils.isNotBlank(oilRecord.getOilPosition())) {
                Map<String, Integer> positionMap = statisVo.getPosition();
                String position = oilRecord.getOilPosition();
                positionMap.put(position, positionMap.getOrDefault(position, 0) + 1);
            }
            
            //高峰时段
            Map<Integer, Integer> phraseMap = statisVo.getPhrase();
            int timePhrase = getTimePhrase(oilRecord.getStartTime());
            phraseMap.put(timePhrase, phraseMap.getOrDefault(timePhrase, 0) + 1);
            
        }
        
        List<OilStatis> saveList = new ArrayList<>();
        
        //客户规则
        List<ClientVo> clientVos = clientConfigService.groupList();
        
        //计算汇总的数据
        for (Map.Entry<String, OilStatisVo> statis : statisMap.entrySet()) {
            OilStatisVo statisVo = statis.getValue();
            String key = statis.getKey();
            //客户类型
            for (ClientVo clientVo : clientVos) {
                if (!recordMap.containsKey(key) || CollectionUtils.isEmpty(clientVo.getClientConfigs())) {
                    continue;
                }
                ClientTypeInfer<OilRecord> clientInfer = new ClientTypeInfer<>(
                        clientVo, recordMap.get(key), r -> LocalDate.parse(r.getRecordDay()));
                if (clientInfer.infer() != null) {
                    statisVo.setClientName(clientVo.getClientName());
                    statisVo.setClientId(clientVo.getId());
                }
            }
            //加油位置
            if (statisVo.getPosition().size() != 0) {
                Map.Entry<String, Integer> pos = Collections.max(statisVo.getPosition().entrySet(), Comparator.comparingInt(Map.Entry::getValue));
                statisVo.setOilPosition(pos.getKey());
            }
            //高峰时段
            Map.Entry<Integer, Integer> phrase = Collections.max(statisVo.getPhrase().entrySet(), Comparator.comparingInt(Map.Entry::getValue));
            statisVo.setHigherPhrase(phrase.getKey().byteValue());
            OilStatis oilStatis = new OilStatis();
            BeanUtils.copyProperties(statisVo, oilStatis);
            saveList.add(oilStatis);
        }
        oilStaticService.saveOrUpdateBatch(saveList);
        log.info("----------------车辆信息数据统计成功-----------------");
    }
    
    private int getTimePhrase(Date date) {
        int hour = date.getHours();
        if (hour >= 7 && hour < 10) {
            return SystemConstant.MORNING_PHRASE;
        } else if (hour >= 17 && hour < 19) {
            return SystemConstant.EVENING_PHRASE;
        } else if (hour >= 0 && hour < 7) {
            return SystemConstant.MIDNIGHT_PHRASE;
        } else {
            return SystemConstant.COMMON_PHRASE;
        }
        
    }
    
    
    /**
     * 每小时定时完结卸油记录及事件
     * 默认补齐卸油时长: 2h
     * 默认图片: 该次记录事件的最后一张
     */
    @Scheduled(cron = "${jyz.timer.oilout-complete:0 30 * * * ?}")
    public void oilOutComplet() {
        log.info("---------开始处理未正常完结的卸油流程----------");
        LambdaQueryWrapper<OiloutRecord> wrapper = new LambdaQueryWrapper<OiloutRecord>();
        wrapper.isNull(OiloutRecord::getEndTime)
                .le(OiloutRecord::getStartTime, LocalDateTime.now().minusHours(2));
        List<OiloutRecord> records = oiloutRecordService.list(wrapper);
        if (CollectionUtils.isEmpty(records)) {
            return;
        }
        log.info("---------检测到存在未正常完结的卸油流程----------", JSON.toJSONString(records));
        int hour = 2;
        for (OiloutRecord record : records) {
            Timestamp startTime = record.getStartTime();
            LocalDateTime endTime = startTime.toLocalDateTime().plusHours(hour);
            record.setEndTime(Timestamp.valueOf(endTime));
            record.setSpandTime(hour * 60);
            eventComplet(record);
        }
        oiloutRecordService.updateBatchById(records);
        log.info("---------已完善未正常完结的卸油流程----------");
    }
    
    /**
     * 补充未入库的事件
     * @param record
     */
    private void eventComplet(OiloutRecord record) {
        LambdaQueryWrapper<OiloutEvent> wrapper = new LambdaQueryWrapper<OiloutEvent>();
        wrapper.eq(OiloutEvent::getRecordId, record.getId())
                .orderByAsc(OiloutEvent::getAlgorithmCode);
        List<OiloutEvent> eventList = oiloutEventService.list();
        if (CollectionUtils.isEmpty(eventList)) {
            return;
        }
        log.info("---------开始处理未正常完结的卸油卸油事件----------");
        List<String> completed = eventList.stream().map(OiloutEvent::getAlgorithmCode).collect(Collectors.toList());
        //获取未入库事件的算法code
        List<String> unComplete = new ArrayList<>();
        unComplete.addAll(AlgorithmCache.oiloutAlgMap().keySet());
        unComplete.removeAll(completed);
        //待补充事件采用最后一个事件的基础信息
        OiloutEvent lastEvent = eventList.get(eventList.size() - 1);
        List<OiloutEvent> unCompleteEvent = new ArrayList<>();
        for (String algCode : unComplete) {
            OiloutEvent event = new OiloutEvent();
            SysAlgorithmItem algorithm = AlgorithmCache.getAlgorithmMap(algCode);
            BeanUtil.copyProperties(lastEvent, event);
            event.setId(null)
                    .setAlgorithmCode(algCode)
                    .setAlgorithmName(algorithm.getAlgorithmName())
                    .setEventPhrase(algorithm.getPhrase())
                    .setImgUid(RandomUtil.randomNumbers(10))
                    .setEventType(SystemConstant.OILOUT_EVETN_TYPE_ERROR.byteValue())
                    .setCreateTime(new Date());
            unCompleteEvent.add(event);
        }
        oiloutEventService.saveBatch(unCompleteEvent);
        log.info("---------已完善未正常完结的卸油卸油事件----------");
    }
    
    
    public static void main(String[] args) {
        new SystemSchedule().test();
    }
    
    void test(){
        List<OilRecord> records = new ArrayList<>();
        records.add(new OilRecord().setRecordDay("2023-08-21"));
        records.add(new OilRecord().setRecordDay("2023-05-15"));
        records.add(new OilRecord().setRecordDay("2023-07-21"));
        records.add(new OilRecord().setRecordDay("2023-06-21"));
    
        ClientVo clientVo = new ClientVo();
        clientVo.setClientName("哈哈哈哈");
        List<ClientConfig> configs = new ArrayList<>();
        configs.add(new ClientConfig().setTimeValue(3)
                .setTimeUnit("months")
                .setCountType((byte) 2)
                .setCountRef((byte) 1)
                .setCountNum(0));
        clientVo.setClientConfigs(configs);
        ClientTypeInfer<OilRecord> clientInfer = new ClientTypeInfer<>(
                clientVo,
                records,
                r -> LocalDate.parse(r.getRecordDay()));
        clientInfer.infer();
    }
    
    /**
     * 客户类型推断
     * @param <T> record
     */
    class ClientTypeInfer<T> {
        
        ClientVo rules;
    
        List<T> dataList;
    
        Function<T, LocalDate> timeVal;
        
        public ClientTypeInfer(ClientVo rules, List<T> dataList, Function<T, LocalDate> timeVal){
            this.rules = rules;
            this.dataList = dataList;
            this.timeVal = timeVal;
        }
    
        /**
         * 获得客户类型
         * @return
         */
        public String infer() {
            try {
                if (CollectionUtils.isEmpty(rules.getClientConfigs())) {
                    return null;
                }
                for (ClientConfig rule : rules.getClientConfigs()) {
                    if (rule == null || rule.getTimeValue() == null || StringUtils.isBlank(rule.getTimeUnit())) {
                        return null;
                    }
                    ChronoUnit unit = ChronoUnit.valueOf(rule.getTimeUnit().toUpperCase());
                    LocalDate timeLimit = LocalDate.now().minus(rule.getTimeValue(), unit);
                    switch(unit) {
                        case MONTHS: timeLimit = timeLimit.with(ChronoField.DAY_OF_MONTH, 1); break;
                        case YEARS: timeLimit = timeLimit.with(ChronoField.DAY_OF_MONTH, 1); break;
                    }
                    LocalDate finalTimeLimit = timeLimit;
                    List<T> filterData = dataList.stream().filter(t -> !timeVal.apply(t).isBefore(finalTimeLimit)).collect(Collectors.toList());
                    
                    // 根据规则类型选择判断逻辑
                    Byte ruleType = rule.getRuleType();
                    if (ruleType == null) {
                        return null;
                    }
                    if (ruleType == 1) {
                        if (rule.getCountType() == null || rule.getCountRef() == null || rule.getCountNum() == null) {
                            return null;
                        }
                        // 加油频次（原有逻辑）
                        int limit = rule.getCountNum();
                        int ref = rule.getCountRef();
                        if (rule.getCountType() == 1) {
                            int sum = filterData.size();
                            if (Integer.compare(sum, limit) != ref) {
                                return null;
                            }
                        } else if((rule.getCountType() == 2)) {
                            Map<Integer, Integer> monthCount = new HashMap<>();
                            int nowMonth = LocalDate.now().getMonthValue();
                            for (int month = timeLimit.getMonthValue(); month != nowMonth ; month++) {
                                monthCount.put(month, 0);
                            }
                            for (T tmp : filterData) {
                                int month = timeVal.apply(tmp).getMonthValue();
                                if (monthCount.containsKey(month)) {
                                    monthCount.put(month, monthCount.get(month) + 1);
                                }
                            }
                            Collection<Integer> countNums = monthCount.values();
                            if (countNums.stream().anyMatch(n -> Integer.compare(n, limit) != ref)) {
                                return null;
                            }
                        } else {
                            return null;
                        }
                    } else if (ruleType == 2) {
                        // 加油趋势（新逻辑）
                        if (rule.getCountTrend() == null || rule.getCountNum() == null || rule.getHistoryMonths() == null || rule.getRecentMonths() == null) {
                            return null;
                        }
                        if (!checkTrend(rule, filterData)) {
                            return null;
                        }
                    } else {
                        return null;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
            return rules.getClientName();
        }
        
        /**
         * 趋势判断（使用配置的月数）
         * @param rule 规则
         * @param dataList 数据列表
         * @return
         */
        private boolean checkTrend(ClientConfig rule, List<T> dataList) {
            if (dataList == null || dataList.isEmpty()) {
                return false;
            }
            
            Byte countTrend = rule.getCountTrend();
            Integer countNum = rule.getCountNum();
            Integer historyMonths = rule.getHistoryMonths();
            Integer recentMonths = rule.getRecentMonths();
            if (countTrend == null || countNum == null || historyMonths == null || recentMonths == null) {
                return false;
            }
            if (historyMonths <= 0 || recentMonths <= 0 || countNum <= 0) {
                return false;
            }
            
            LocalDate now = LocalDate.now();
            LocalDate currentMonth = now.withDayOfMonth(1);
            LocalDate recentStart = currentMonth.minusMonths(recentMonths - 1L);
            LocalDate historyStart = recentStart.minusMonths(historyMonths);
            LocalDate historyEnd = recentStart;
            
            Map<LocalDate, Integer> recentMonthCount = new LinkedHashMap<>();
            for (int i = 0; i < recentMonths; i++) {
                LocalDate month = recentStart.plusMonths(i);
                recentMonthCount.put(month, 0);
            }

            Map<LocalDate, Integer> historyMonthCount = new LinkedHashMap<>();
            for (int i = 0; i < historyMonths; i++) {
                LocalDate month = historyStart.plusMonths(i);
                historyMonthCount.put(month, 0);
            }

            for (T tmp : dataList) {
                LocalDate month = timeVal.apply(tmp).withDayOfMonth(1);
                if (recentMonthCount.containsKey(month)) {
                    recentMonthCount.put(month, recentMonthCount.get(month) + 1);
                }
                if (historyMonthCount.containsKey(month) && !month.isBefore(historyStart) && month.isBefore(historyEnd)) {
                    historyMonthCount.put(month, historyMonthCount.get(month) + 1);
                }
            }
            
            if (countTrend == 1) {
                boolean historyStable = historyMonthCount.values().stream().allMatch(n -> n >= countNum);
                boolean recentStable = recentMonthCount.values().stream().allMatch(n -> n >= countNum);
                return historyStable && recentStable;
            } else if (countTrend == 2) {
                boolean historyStable = historyMonthCount.values().stream().allMatch(n -> n >= countNum);
                boolean recentDecrease = recentMonthCount.values().stream().allMatch(n -> n < countNum);
                return historyStable && recentDecrease;
            }
            
            return false;
        }
        
    }
    
}