package com.whyc.util;

import com.github.pagehelper.PageInfo;
import com.whyc.dto.AlmHis.BattAlarmRes;
import com.whyc.dto.AlmHis.BattAlmPar;
import com.whyc.dto.AlmHis.DevAlmPar;
import com.whyc.dto.AlmHis.PwrAlmPar;
import com.whyc.factory.ThreadPoolExecutorFactory;
import com.whyc.mapper.CommonMapper;
import com.whyc.pojo.db_alarm.BattalarmDataHistory;
import com.whyc.pojo.db_alarm.DevalarmDataHistory;
import com.whyc.pojo.db_pwrdev_alarm.PwrdevAlarmHistory;
import com.whyc.service.SubTablePageInfoService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.text.ParseException;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 数据量极大的表,按照年份分表,分页查询时获取数据
 */
@Component
public class SubTablePageInfoUtils {

    @Resource
    private CommonMapper commonMapper;

    @Autowired
    private SubTablePageInfoService subService;

    /**按年份表分页查询*/
   public PageInfo<Object> getPageInfo(int pageNum,int pageSize,
                                Date startTime,Date endTime,
                                String dbName,String tablePrefix,
                                Object pojo) throws ParseException {
        Map<String, List<Date>> queryTimeForSubTables = DateUtil.getQueryTimeForSubTablesDesc(startTime, endTime);
        //查询分表是否存在,存在则查询结果
        Map<String,Integer> queryCountMap = new LinkedHashMap<>();
        Set<String> tableYearKeySet = queryTimeForSubTables.keySet();
        for (String tableYear : tableYearKeySet) {
            List<Date> queryTime = queryTimeForSubTables.get(tableYear);
            String tableName=tablePrefix+"_"+tableYear;;
            String existTableName = commonMapper.existTable(dbName, tableName);
            if(existTableName == null){
                continue;
            }
            //====== 根据不同类型类型对象对应调整 ======
             if(pojo instanceof PwrAlmPar) {
                PwrAlmPar param = (PwrAlmPar) pojo;
                param.setAlmStartTime(queryTime.get(0));
                param.setAlmEndTime(queryTime.get(1));
                param.setRecordYear(tableName);
                int currentCount = subService.getPwrAlmHisCount(param);
                queryCountMap.put(tableYear, currentCount);
            }
        }

        //分页信息
        //确认总页数,总记录数
        PageInfo<Object> pageInfo = new PageInfo<>();

        int total = 0;
        Set<String> queryKeySet = queryCountMap.keySet();
        for (String queryKey : queryKeySet) {
            int size = queryCountMap.get(queryKey);
            total+=size;
        }
        int pages = (int) Math.ceil(Float.parseFloat(String.valueOf(total))/pageSize);
        pageInfo.setTotal(total);
        pageInfo.setPages(pages);
        pageInfo.setPageNum(pageNum);
        pageInfo.setPageSize(pageSize);
        //根据当前页所需记录,查询当前页记录
        int startNum = (pageNum-1)*pageSize+1;
        int endNum = pageNum*pageSize;

        //最后一个算法:上面不应该先查询所有记录,应该取count. 这后面定位到哪个表或哪几张表后,采取limit获取当前页记录数;
        //格式:{表名,[limit 2,20]}
        Map<String,List<Integer>> tableAndLimitMap = MathUtil.getQueryTableAndLimit(startNum,endNum,pageSize,queryCountMap);
        Set<String> keySet = tableAndLimitMap.keySet();
        List<Object> dataList = new LinkedList<>();
        for (String key : keySet) {
            List<Date> queryTime = queryTimeForSubTables.get(key);
            //====== 根据不同类型类型对象对应调整 ======
            String recordYear = key.equals("default") ? tablePrefix : tablePrefix + "_" + key;


           if (pojo instanceof PwrAlmPar) {
                PwrAlmPar data = (PwrAlmPar) pojo;
                data.setAlmStartTime(queryTime.get(0));
                data.setAlmEndTime(queryTime.get(1));
                List<Integer> limitList = tableAndLimitMap.get(key);
                data.setLimitStart(limitList.get(0));
                data.setLimitEnd(limitList.get(1));
                data.setRecordYear(recordYear);
                List<PwrdevAlarmHistory> list= subService.getPwrAlmHisList(data);
                dataList.addAll(list);
            }

        }
        pageInfo.setList(dataList);
        return pageInfo;
    }
    /**按月分表,分页查询*/
    public PageInfo<Object> getPageInfoByMonthTable(int pageNum,int pageSize,
                                        Date startTime,Date endTime,
                                        String dbName,String tablePrefix,
                                        Object pojo) throws ParseException, InterruptedException {
        Map<String, List<Date>> queryTimeForSubTables = DateUtil.getQueryTimeForSubTablesByMonthDesc(startTime, endTime);
        //查询分表是否存在,存在则查询结果
        Map<String,Integer> queryCountMap = new LinkedHashMap<>();
        Set<String> tableYearKeySet = queryTimeForSubTables.keySet();
        //优化1-查询所有的符合月份规则的表和主表
        List<String> tableNameListDB = getTableList(dbName, tablePrefix, tablePrefix + "(_[0-9]{4}_[0-9]{2})?");
        List<String> tableYearListInDB = new LinkedList<>(); //查询时间段内的年月分表集合且在数据库中存在
        //过滤掉时间段内数据库中不存在的年月分表
        for (String tableYear : tableYearKeySet) {

            String tableName;
            if(!tableYear.equals("default")){
                //数值
                tableName = tablePrefix+"_"+tableYear;
                //String existTableName = commonMapper.existTable(dbName, tableName);
                if(!tableNameListDB.contains(tableName)){ //优化1-数据库中不存在,去除多次查表,一次查出
                    continue;
                }
            }
            tableYearListInDB.add(tableYear);
        }
        //查询年月分表的记录数
        //优化2:多线程读取
        ThreadPoolExecutor pool = ThreadPoolExecutorFactory.getPoolExecutor();
        CountDownLatch latch = new CountDownLatch(tableYearListInDB.size());
        for (String tableYear : tableYearListInDB) {
            List<Date> queryTime = queryTimeForSubTables.get(tableYear);
            String tableName;
            if(!tableYear.equals("default")){
                //数值
                tableName = tablePrefix+"_"+tableYear;
            }else{
                tableName = tablePrefix;
            }
            pool.execute(()-> {
                //====== 根据不同类型类型对象对应调整 ======
                if (pojo instanceof BattAlmPar) { //电池告警历史
                    BattAlmPar param = new BattAlmPar();
                    BeanUtils.copyProperties(pojo,param);
                    param.setAlmStartTime(queryTime.get(0));
                    param.setAlmEndTime(queryTime.get(1));
                    param.setRecordYear(tableName);
                    int currentCount = subService.getBattAlmHisCount(param);
                    queryCountMap.put(tableYear, currentCount);
                }
                else if (pojo instanceof DevAlmPar) {
                    DevAlmPar param = new DevAlmPar();
                    BeanUtils.copyProperties(pojo,param);
                    param.setAlmStartTime(queryTime.get(0));
                    param.setAlmEndTime(queryTime.get(1));
                    param.setRecordYear(tableName);
                    int currentCount = subService.getDevAlmHisCount(param);
                    queryCountMap.put(tableYear, currentCount);
                }

                latch.countDown();
            });
        }
        latch.await();
        //因为多线程后无序,需要重排序
        List<String> keySetDesc = queryCountMap.keySet().stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        Map<String,Integer> queryCountMapDesc = new LinkedHashMap<>();
        for (String key : keySetDesc) {
            Integer count = queryCountMap.get(key);
            queryCountMapDesc.put(key,count);
        }
        //分页信息
        //确认总页数,总记录数
        PageInfo<Object> pageInfo = new PageInfo<>();

        int total = 0;
        Set<String> queryKeySet = queryCountMap.keySet();
        for (String queryKey : queryKeySet) {
            int size = queryCountMap.get(queryKey);
            total+=size;
        }
        int pages = (int) Math.ceil(Float.parseFloat(String.valueOf(total))/pageSize);
        pageInfo.setTotal(total);
        pageInfo.setPages(pages);
        pageInfo.setPageNum(pageNum);
        pageInfo.setPageSize(pageSize);
        //根据当前页所需记录,查询当前页记录
        int startNum = (pageNum-1)*pageSize+1;
        int endNum = pageNum*pageSize;

        //最后一个算法:上面不应该先查询所有记录,应该取count. 这后面定位到哪个表或哪几张表后,采取limit获取当前页记录数;
        //格式:{表名,[limit 2,20]}
        Map<String,List<Integer>> tableAndLimitMap = MathUtil.getQueryTableAndLimit(startNum,endNum,pageSize,queryCountMapDesc);
        Set<String> keySet = tableAndLimitMap.keySet();
        List<Object> dataList = new LinkedList<>();
        for (String key : keySet) {
            List<Date> queryTime = queryTimeForSubTables.get(key);
            //====== 根据不同类型类型对象对应调整 ======
            String recordYear = key.equals("default") ? tablePrefix : tablePrefix + "_" + key;
            if (pojo instanceof BattAlmPar) {
                BattAlmPar data = (BattAlmPar) pojo;
                data.setAlmStartTime(queryTime.get(0));
                data.setAlmEndTime(queryTime.get(1));

                List<Integer> limitList = tableAndLimitMap.get(key);
                data.setLimitStart(limitList.get(0));
                data.setLimitEnd(limitList.get(1));
                data.setRecordYear(recordYear);
                List<BattalarmDataHistory> list = subService.getBattAlmHisList(data);
                dataList.addAll(list);
            }
            else if (pojo instanceof DevAlmPar) {
                DevAlmPar data = (DevAlmPar) pojo;
                data.setAlmStartTime(queryTime.get(0));
                data.setAlmEndTime(queryTime.get(1));

                List<Integer> limitList = tableAndLimitMap.get(key);
                data.setLimitStart(limitList.get(0));
                data.setLimitEnd(limitList.get(1));
                data.setRecordYear(recordYear);
                List<DevalarmDataHistory> list =  subService.getDevAlmHisList(data);
                dataList.addAll(list);
            }


        }
        pageInfo.setList(dataList);
        return pageInfo;
    }

    /**查询是否包含特定规则的表,存在,则返回表名*/
    public List<String> getTableList(String dbName,String tableLike,String regex){
        List<String> resultTableList = new LinkedList<>();
        List<String> tableList = commonMapper.getTableListLike(dbName,tableLike);
        for (String tableName : tableList) {
            boolean matches = Pattern.matches(regex, tableName);
            if(matches){
                resultTableList.add(tableName);
            }
        }
        return resultTableList;
    }

   /* *//**所有记录分为四级查询个数*//*
    public List<Integer> getLevelList(int uId,String dbName,String tableLike,String regex,List<Integer> almTypes ){
        List<Integer> result = new LinkedList<>();
        List<String> tableList = getTableList(dbName, tableLike, regex);
        List<Integer> levelList = new LinkedList();
        for (String tableName : tableList) {
            List<BattalarmDataHistory> levelInfoSubList;
            List<Integer> levelSubList;
            if(tableLike.equals("tb_battalarm_data_history")) {
                //levelInfoSubList = battAlarmDataHistoryMapper.getLevelSubList(uId, tableName);
                levelInfoSubList = subService.getLevelSubList_batt(uId, tableName);
            }
            else if(tableLike.equals("tb_devalarm_data_history")){
                //levelInfoSubList = devAlarmDataHistoryMapper.getLevelSubList(uId, tableName);
                levelInfoSubList = subService.getLevelSubList_dev(uId, tableName);
            }
            else{
                //levelInfoSubList = powerAlarmHistoryMapper.getLevelSubList(uId, tableName,almTypes);
                levelInfoSubList = subService.getLevelSubList_pwr(uId, tableName,almTypes);
            }
            levelSubList = levelInfoSubList.stream().map(BattalarmDataHistory::getAlmLevel).collect(Collectors.toList());
            levelList.addAll(levelSubList);
        }
        //分为四级查询个数
        Map<Integer, List<Integer>> levelMap = levelList.stream().collect(Collectors.groupingBy(Integer::intValue));
        Set<Integer> levelSet = levelMap.keySet();
        List<Integer> listOfLevelSet = new LinkedList();
        //补齐1,2,3,4四级
        listOfLevelSet.add(1);
        listOfLevelSet.add(2);
        listOfLevelSet.add(3);
        listOfLevelSet.add(4);
        if(!levelSet.contains(1)){
            levelMap.put(1,new LinkedList<>());
        }
        if(!levelSet.contains(2)){
            levelMap.put(2,new LinkedList<>());
        }
        if(!levelSet.contains(3)){
            levelMap.put(3,new LinkedList<>());
        }
        if(!levelSet.contains(4)){
            levelMap.put(4,new LinkedList<>());
        }
        //待测试
        for (Integer level : listOfLevelSet) {
            result.add(levelMap.get(level).size());
        }
        return result;
    }
*/
    public static void main(String[] args) {
        //String regex = "tb_battalarm_data_history_?[0-9]*";
        String regex = "tb_battalarm_data_history(_[0-9]{4}_[0-9]{2})?";
        //String table = "tb_battalarm_data_history";
        String table = "tb_battalarm_data_history_0222_04";
        System.out.println(Pattern.matches(regex,table));
    }
}