package com.tofly.xrtygis.custom.service.zsdata.impl;

import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tofly.common.core.util.StringUtil;
import com.tofly.xrtygis.custom.entity.dataquery.WaterPlanSearch;
import com.tofly.xrtygis.custom.service.zsdata.DataQueryService;
import com.tofly.xrtygis.em.Constant;
import com.tofly.xrtygis.em.ExcelExportFileTypeEnum;
import com.tofly.xrtygis.mapper.CostbgwaterMapper;
import com.tofly.xrtygis.strategy.ExcelStrategyContext;
import com.tofly.xrtygis.util.ExcelUtil;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;

/**
 * @author FlashWJL
 * @date 2021/4/27 15:37
 */
@Service
@AllArgsConstructor
public class DataQueryServiceImpl implements DataQueryService {

    private final ExcelStrategyContext excelStrategyContext;
    private final CostbgwaterMapper baseMapper;

    /**
     * 计划数据
     *
     * @param page
     * @param search
     * @return
     */
    @Override
    public IPage<Map> getWaterPlanValue(HttpServletResponse response, Page page, WaterPlanSearch search) {


        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();
        IPage<Map> result = page;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            List<Map> reslutMap = baseMapper.selectPlanYearData(startYear);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumPlanYearData(startYear));
            }

            result.setRecords(reslutMap);
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            List<Map> reslutMap = baseMapper.selectPlanMonthByYearData(year);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumPlanMonthByYearData(year));
            }
            result.setRecords(reslutMap);
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            List<Map> reslutMap = baseMapper.selectPlanMonthData(month, yearDay);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumPlanMonthData(month, yearDay));
            }
            result.setRecords(reslutMap);
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("waterPlanServiceImpl", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            List<Map> records = result.getRecords();
            if (records != null && !records.isEmpty()){
                records.remove(records.size()-1);
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(records);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("waterPlanServiceImpl", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);
        }
        return result;
    }


    /**
     * 实际数据
     *
     * @param page
     * @param search
     * @return
     */
    @Override
    public IPage<Map> getWaterRealityValue(HttpServletResponse response, Page page, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();
        IPage<Map> result = page;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            List<Map> reslutMap = baseMapper.selectRealityYearData(startYear);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumRealityYearData(startYear));
            }

            result.setRecords(reslutMap);
        }
        //按年份查询；以该年中每月数据展示
        /**
         * 真实数据存在多个的情况
         * 一个月录入多次，而计划一个月就只录入一次
         */
        else if (StringUtil.isNotEmpty(year)) {
            List<Map> reslutMap = baseMapper.selectRealityMonthByYearData(year);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumRealityMonthByYearData(year));
            }

            result.setRecords(reslutMap);
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            List<Map> reslutMap = baseMapper.selectRealityMonthData(month, yearDay);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumRealityMonthData(month, yearDay));
            }

            result.setRecords(reslutMap);
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("waterRealityServiceImpl", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            List<Map> records = result.getRecords();
            if (records != null && !records.isEmpty()){
                records.remove(records.size()-1);
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(records);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("waterRealityServiceImpl", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);
        }
        return result;

    }

    /**
     * 计划单耗
     * @param response response
     * @param search search
     * @return list
     */
    @Override
    public List<Map> getWaterPlanUnit(HttpServletResponse response, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();

        List<Map> reslutMap;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            reslutMap = baseMapper.selectPlanUnitYearData(startYear);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumPlanUnitYearData(startYear));
            }
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            reslutMap = baseMapper.selectPlanUnitMonthData(year);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumPlanUnitMonthData(year));
            }
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
           reslutMap = baseMapper.selectPlanUnitData(month, yearDay);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumPlanUnitData(month, yearDay));
            }
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {

            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("unitPlanService", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            if (!reslutMap.isEmpty()){
                reslutMap.remove(reslutMap.size() - 1);
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(reslutMap);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("unitPlanService", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);
        }
        return reslutMap;
    }

    /**
     * 实际单耗
     * @param response response
     * @param search search
     * @return list
     */
    @Override
    public List<Map> getWaterRealUnit(HttpServletResponse response, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();

        List<Map> reslutMap;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            reslutMap = baseMapper.selectRealUnitYearData(startYear);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumRealUnitYearData(startYear));
            }
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            reslutMap = baseMapper.selectRealUnitMonthData(year);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumRealUnitMonthData(year));
            }
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            reslutMap = baseMapper.selectRealUnitData(month, yearDay);
            if (!reslutMap.isEmpty()) {
                reslutMap.add(baseMapper.sumRealUnitData(month, yearDay));
            }
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("unitPlanService", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            if (!reslutMap.isEmpty()){
                reslutMap.remove(reslutMap.size() - 1);
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(reslutMap);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("unitPlanService", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);
        }
        return reslutMap;
    }

    @Override
    public IPage<Map> getProduceMaterialsPlan(HttpServletResponse response, Page page, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();
        IPage<Map> result = page;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            List<Map> reslutMap = baseMapper.selectPlanProduceYearData(startYear);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumPlanProduceYearData(startYear));
            }
            result.setRecords(reslutMap);
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            List<Map> reslutMap = baseMapper.selectPlanProduceMonthByYear(year);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumPlanProduceMonthByYear(year));
            }
            result.setRecords(reslutMap);
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            List<Map> reslutMap = baseMapper.selectPlanProduceMonthData(month, yearDay);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumPlanProduceMonthData(month,yearDay));
            }
            result.setRecords(reslutMap);
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("producePlanServiceImpl", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            List<Map> records = result.getRecords();
            if (records != null && !records.isEmpty()){
                records.remove(records.size()-1);
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(records);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("producePlanServiceImpl", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);
        }
        return result;
    }

    @Override
    public IPage<Map> getProduceMaterialsReality(HttpServletResponse response, Page page, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();
        IPage<Map> result = page;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            List<Map> reslutMap = baseMapper.selectRealityProduceYearData(startYear);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumRealityProduceYearData(startYear));
            }
            result.setRecords(reslutMap);
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            List<Map> reslutMap = baseMapper.selectRealityProduceMonthByYear(year);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumRealityProduceMonthByYear(year));
            }
            result.setRecords(reslutMap);
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            List<Map> reslutMap = baseMapper.selectRealityProduceMonthData(month, yearDay);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumRealityProduceMonthData(month, yearDay));
            }
            result.setRecords(reslutMap);
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("produceRealityServiceImpl", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            List<Map> records = result.getRecords();
            if (records != null && !records.isEmpty()){
                records.remove(records.size()-1);
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(records);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("produceRealityServiceImpl", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);

        }
        return result;
    }

    @Override
    public IPage<Map> getProduceCostPlan(HttpServletResponse response, Page page, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();
        IPage<Map> result = page;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            List<Map> reslutMap = baseMapper.selectPlanCostYearData(startYear);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumPlanCostYearData(startYear));
            }
            result.setRecords(reslutMap);
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            List<Map> reslutMap = baseMapper.selectPlanCostMonthByYear(year);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumPlanCostMonthByYear(year));
            }
            result.setRecords(reslutMap);
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            List<Map> reslutMap = baseMapper.selectPlanCostMonthData(month, yearDay);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumPlanCostMonthData(month,yearDay));
            }
            result.setRecords(reslutMap);
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("costPlanServiceImpl", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            List<Map> records = result.getRecords();
            if (records != null && !records.isEmpty()){
                records.remove(records.size()-1);
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(records);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("costPlanServiceImpl", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);

        }
        return result;
    }

    @Override
    public IPage<Map> getProduceCostReality(HttpServletResponse response, Page page, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();
        IPage<Map> result = page;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            List<Map> reslutMap = baseMapper.selectRealityCostYearData(startYear);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumRealityCostYearData(startYear));
            }
            result.setRecords(reslutMap);
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            List<Map> reslutMap = baseMapper.selectRealityCostMonthByYear(year);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumRealityCostMonthByYear(year));
            }
            result.setRecords(reslutMap);
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            List<Map> reslutMap = baseMapper.selectRealityCostMonthData(month, yearDay);
            if (!reslutMap.isEmpty()){
                reslutMap.add(baseMapper.sumRealityCostMonthData(month,yearDay));
            }
            result.setRecords(reslutMap);
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("costRealityServiceImpl", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            List<Map> records = result.getRecords();
            if (records != null && !records.isEmpty()){
                records.remove(records.size()-1);
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(records);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("costRealityServiceImpl", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);

        }
        return result;
    }

    @Override
    public List<Map> getTargetPricePlan(HttpServletResponse response, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();
        List<Map> result;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            result = baseMapper.selectPlanPriceYearData(startYear);
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            result = baseMapper.selectPlanPriceMonthByYear(year);
        }

        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            result = baseMapper.selectPlanPriceMonthData(month, yearDay);

            /**
             * 下面注释不能删
             */
//            //如果存在当月没有数据的情况，比如说 2020-05 没有计划数据，则需要拿之前月份的最新数据，先用个数比较
//            int start = Integer.valueOf(startYearStr);
//            int end = Integer.valueOf(endYearStr);
//            //应查询出来的个数
//            int size = end - start +1 ;
//            //实际查询出来的个数
//            int resultSize = result.size();
//            if (size>resultSize){
//                //应查询出来的年份
//                List<String> yearList = new ArrayList<>();
//                //如果实际查询出来的长度小于应查询的，那么则代表当月（查询月）可能没有计划的单价，那么就需要获取前面月份的最新计划单价
//                //生成年份集合
//                for (int i = 0 ; i < size ; i++){
//                    yearList.add((start + i)+"");
//                }
//                //map转实体类
//                List<QueryPrice> priceList = JSONObject.parseArray(JSONObject.toJSONString(result), QueryPrice.class);
//                //只要年份这一属性
////                List<String> resultYearList = priceList.stream().map(Costbgprice::getYear).collect(Collectors.toList());
//                //比较两个年份，把没有的过滤出来，然后再去查当月（查询月）之前的最新单价
//                Map<String , String> yearMap = priceList.stream().collect(Collectors.toMap(QueryPrice::getYear,QueryPrice::getYear));
//                //过滤得到没有查询出来的数据
//                List<String> fileterYear = yearList.stream().filter(m -> StringUtil.isEmpty(yearMap.get(m))).collect(Collectors.toList());
//                //查询数据
//                List<Map> fileterPrice = baseMapper.selectPriceMonthByYear("TF_YWPN_COSTBGPRICE_W", fileterYear , startMonthStr);
//
////                if (result.getRecords().size()==0){
////                    result.setRecords(fileterPrice);
////                    result.setTotal(fileterPrice.size());
////                }else {
////                    result.getRecords().addAll(fileterPrice);
////                    result.setTotal(result.getTotal()+fileterPrice.size());
////                }
//            }
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("targetPricePlanServiceImpl", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(result);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("targetPricePlanServiceImpl", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);
        }
        return result;
    }

    @Override
    public List<Map> getTargetPriceReality(HttpServletResponse response, WaterPlanSearch search) {
        //判断是根据什么进行查询的；如：年度查询、年份查询、月度查询
        String startYear = search.getStartYear();
        String year = search.getYear();
        String month = search.getMonth();
        String yearDay = search.getYearDay();
        List<Map> result;
        //首先按年度查询；以年为单位展示数据
        if (StringUtil.isNotEmpty(startYear)) {
            result = baseMapper.selectRealityPriceYearData(startYear);
        }
        //按年份查询；以该年中每月数据展示
        else if (StringUtil.isNotEmpty(year)) {
            result = baseMapper.selectRealityPriceMonthByYear(year);
        }
        //月份查询；如2016-01 ---2021-01，则是2016-01，2017-01，2018-01，2019-01，2020-01的数据
        else if (StringUtil.isNotEmpty(month) && StringUtil.isNotEmpty(yearDay)) {
            result = baseMapper.selectRealityPriceMonthData(month, yearDay);

            /**
             * 下面注释不能删
             */
//            //如果存在当月没有数据的情况，比如说 2020-05 没有计划数据，则需要拿之前月份的最新数据，先用个数比较
//            int start = Integer.valueOf(startYearStr);
//            int end = Integer.valueOf(endYearStr);
//            //应查询出来的个数
//            int size = end - start +1 ;
//            //实际查询出来的个数
//            int resultSize = result.size();
//            if (size>resultSize){
//                //应查询出来的年份
//                List<String> yearList = new ArrayList<>();
//                //如果实际查询出来的长度小于应查询的，那么则代表当月（查询月）可能没有计划的单价，那么就需要获取前面月份的最新计划单价
//                //生成年份集合
//                for (int i = 0 ; i < size ; i++){
//                    yearList.add((start + i)+"");
//                }
//                //map转实体类
//                List<QueryPrice> priceList = JSONObject.parseArray(JSONObject.toJSONString(result), QueryPrice.class);
//                //只要年份这一属性
////                List<String> resultYearList = priceList.stream().map(Costbgprice::getYear).collect(Collectors.toList());
//                //比较两个年份，把没有的过滤出来，然后再去查当月（查询月）之前的最新单价
//                Map<String , String> yearMap = priceList.stream().collect(Collectors.toMap(QueryPrice::getYear,QueryPrice::getYear));
//                //过滤得到没有查询出来的数据
//                List<String> fileterYear = yearList.stream().filter(m -> StringUtil.isEmpty(yearMap.get(m))).collect(Collectors.toList());
//                //查询数据
//                List<Map> fileterPrice = baseMapper.selectPriceMonthByYear("TF_YWPN_COSTRLPRICE_W" , fileterYear , startMonthStr);
////                if (result.getRecords().size()==0){
////                    result.setRecords(fileterPrice);
////                    result.setTotal(fileterPrice.size());
////                }else {
////                    result.getRecords().addAll(fileterPrice);
////                    result.setTotal(result.getTotal()+fileterPrice.size());
////                }
//
//
//            }
        } else {
            return null;
        }
        //如果传的是 1，则代表导出Excel数据
        if ("1".equals(search.getTemplateFlag())) {
            // 根据templateServiceType,templateFlag获取对应模板数据
            ExcelExportFileTypeEnum excelExportFileTypeEnum = ExcelExportFileTypeEnum.getExcelExportFileTypeEnum("targetPriceRealityServiceImpl", search.getTemplateFlag());
            if (null == excelExportFileTypeEnum) {
                return null;
            }
            //将查询的结果转json字符串的格式，因为导出的时候只能传一个字符串
            String resultListToString = JSONArray.toJSONString(result);
            // 从模型类型枚举根据templateServiceType获取策略对应模板数据
            List<Map<String, Object>> dataList = excelStrategyContext.getExportData("targetPriceRealityServiceImpl", search.getTemplateFlag(), resultListToString);
            ExcelUtil.export(dataList.get(0), excelExportFileTypeEnum, Constant.FILE_PATH_TEST_EXPORT_EXCEL, response);
        }
        return result;
    }
}
