package com.skua.modules.threedimensional.controller;

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import com.google.common.collect.MapDifference;
import com.google.common.collect.Maps;
import com.skua.core.util.DoubleOperaUtils;
import com.skua.modules.alarmtmp.entity.SysFactoryDevice;
import com.skua.modules.alarmtmp.service.ISysFactoryDeviceService;
import com.skua.core.api.vo.Result;
import com.skua.core.aspect.annotation.AutoLog;
import com.skua.core.context.BaseContextHandler;
import com.skua.core.context.SpringContextUtils;
import com.skua.core.service.IFactoryInfoService;
import com.skua.core.util.ConvertUtils;
import com.skua.core.util.DateUtils;
import com.skua.modules.algorithm.handle.IAlarmLimitCustomService;
import com.skua.modules.algorithm.service.ISysAlgorithmLibraryService;
import com.skua.modules.algorithm.service.ISysAlgorithmStatisticsLibraryService;
import com.skua.modules.algorithm.vo.SysAlgorithmStatisticsLibraryVO;
import com.skua.modules.algorithm.vo.SysAlgorithmStatisticsResultChartsVO;
import com.skua.modules.algorithm.vo.SysAlgorithmStatisticsResultNumberVO;
import com.skua.modules.algorithm.vo.SysAlgorithmStatisticsResultVO;
import com.skua.modules.flow.utils.ObjectUtil;
import com.skua.modules.flow.utils.StringUtil;
import com.skua.modules.system.datestandard.service.ISysMonitorMetricInfoService;
import com.skua.modules.system.entity.SysDepart;
import com.skua.modules.system.entity.SysFactoryInfo;
import com.skua.modules.system.service.ISysDepartService;
import com.skua.modules.system.service.ISysFactoryInfoService;
import com.skua.modules.system.vo.SysFactoryInfo.SysFactoryInfoVO;
import com.skua.modules.threedimensional.service.IDataCountDayService;
import com.skua.modules.threedimensional.service.IScreenDataService;
import com.skua.modules.threedimensional.vo.DataParams;
import com.skua.modules.threedimensional.vo.RealTimeDataVO;
import com.skua.modules.threedimensional.vo.StatisticsParams;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.text.NumberFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author sunjy
 * @date 2021/10/20 9:34
 * 大屏借口
 */
@Slf4j
@Api(tags = "大屏接口")
@RestController
@RequestMapping("/screendata")
public class ScreenDataController {

    @Autowired
    private IScreenDataService screenDataService;
    @Autowired
    private ISysAlgorithmStatisticsLibraryService sysAlgorithmStatisticsLibraryService;
    @Autowired
    private ISysDepartService sysDepartService;
    @Autowired
    private ISysFactoryInfoService sysFactoryInfoService;
    @Autowired
    public ISysAlgorithmLibraryService sysAlgorithmLibraryService;
    @Autowired
    private IDataCountDayService dataCountDayService;
    @Autowired
    private ISysFactoryDeviceService sysFactoryDeviceService;
    @Autowired
    private IAlarmLimitCustomService alarmLimitCustomService;
    @Autowired
    private IFactoryInfoService factoryInfoService;

    /**
     * 获取累计流量
     *
     * @param departId
     * @return
     */
    @AutoLog(value = "污水处理情况")
    @ApiOperation(value = "污水处理情况", notes = "污水处理情况")
    @GetMapping(value = "/getWsclqk")
    public Result<Map<String, Object>> getWsclqk(String departId) {
        Result<Map<String, Object>> result = new Result<Map<String, Object>>();
        Map<String, Object> resultMap = new HashMap<String, Object>();
        JdbcTemplate masterDB = (JdbcTemplate) SpringContextUtils.getBean("master");
        if (!StringUtils.hasText(departId)) {//如果厂站为空，查询曹县厂
            departId = "f2df9193c8bc4e7a9cef0e4b98dd9e95";
        }
        String startDate = DateUtils.getTodayOrMonthDate("day") + " 00:00:00";
        Map<String, Object> map = screenDataService.getDifferData(startDate, "JSLL,CSLL", departId, "differ", masterDB);
        Calendar calendar = Calendar.getInstance();
        int hours = calendar.get(calendar.HOUR_OF_DAY);
        //获取设计处理规模
        List<Map<String, Object>> factoryList = new ArrayList<Map<String, Object>>();
        factoryList.addAll(masterDB.queryForList("select pro_scale from sys_factory_info f where f.depart_id = '" + departId + "'"));
        if (factoryList.size() > 0) {
            String sjgm = factoryList.get(0).get("pro_scale").toString();
            Double sjgmDouble = Double.parseDouble(sjgm) * 10000;
            resultMap.put("设计规模", sjgmDouble.toString());
            NumberFormat numberFormat = NumberFormat.getInstance();
            // 设置精确到小数点后1位
            numberFormat.setMaximumFractionDigits(2);
            numberFormat.setGroupingUsed(false);
            if (!ObjectUtil.isEmpty(map.get("CSLL"))) {
                Double csljll = Double.parseDouble(map.get("CSLL").toString());
                String fhl = numberFormat.format(((csljll / hours) * 24) / sjgmDouble);
                resultMap.put("负荷率", fhl);
            }
        }

        resultMap.put("今日累计进水量", map.get("JSLL"));
        resultMap.put("今日累计出水量", map.get("CSLL"));

        result.setSuccess(true);
        result.setResult(resultMap);
        return result;
    }

    /**
     * app水量情况
     *
     * @param departId
     * @param req
     * @return
     */
    @AutoLog(value = "app水量情况")
    @ApiOperation(value = "app水量情况", notes = "app水量情况")
    @GetMapping(value = "/getAppSlqk")
    public Result<Map<String, Object>> getAppSlqk(String departId,
                                                  HttpServletRequest req) {

        Result<Map<String, Object>> result = new Result<Map<String, Object>>();
        Map<String, Object> resultMap = new HashMap<String, Object>();
        NumberFormat numberFormat = NumberFormat.getInstance();
        // 设置精确到小数点后1位
        numberFormat.setMaximumFractionDigits(2);
        numberFormat.setGroupingUsed(false);
        JdbcTemplate masterDB = (JdbcTemplate) SpringContextUtils.getBean("master");
        if (!StringUtils.hasText(departId)) {//如果厂站为空，查询曹县厂
            departId = "f2df9193c8bc4e7a9cef0e4b98dd9e95";
        }
        String startDate = DateUtils.getTodayOrMonthDate("day") + " 00:00:00";
        //获取今日累计水量
        Map<String, Object> map = screenDataService.getDifferData(startDate, "JSLJLL", departId, "differ", masterDB);
        //获取昨日累计水量
        String yestDate = DateUtils.getYesterday();
        Map<String, Object> yestMap = screenDataService.getHistoryData(yestDate, yestDate, "JSLL", departId, masterDB);
        if (StringUtils.hasText(yestMap.get("JSLL").toString())) {
            //昨日水量
            Double yestSl = Double.parseDouble(yestMap.get("JSLL").toString());
            resultMap.put("昨日累计水量", numberFormat.format(yestSl / 10000));
            //今日水量
            if (StringUtils.hasText(map.get("JSLL").toString())) {
                Double todaySl = Double.parseDouble(map.get("JSLL").toString());
                //环比昨日
                //String hb = numberFormat.format(((todaySl - yestSl) / yestSl) / 10000);
                String hb = numberFormat.format((todaySl - yestSl) / 10000);
                resultMap.put("环比昨日", hb);
            }

        }
        //今日水量
        if (StringUtils.hasText(map.get("JSLL").toString())) {
            Double todaySl = Double.parseDouble(map.get("JSLL").toString());
            resultMap.put("今日累计水量", numberFormat.format(todaySl / 10000));
        }

        //本月累计水量
        String monthStartDate = DateUtils.getMonthFirstOrLastDay(startDate, "start");
        Map<String, Object> monthMap = screenDataService.getDifferData(monthStartDate, "JSLL", departId, "differ", masterDB);
        if (StringUtils.hasText(monthMap.get("JSLL").toString())) {
            Double monthSl = Double.parseDouble(monthMap.get("JSLL").toString());
            resultMap.put("本月累计水量", numberFormat.format(monthSl / 10000));
        }

        //上月累计水量
        String lastMonthStartDate = DateUtils.getLastMonthOfMonth(DateUtils.getTodayOrMonthDate("month")) + "-01";
        String lastMonthEndDate = DateUtils.getLastDayOfMonth(DateUtils.getLastMonthOfMonth(DateUtils.getTodayOrMonthDate("month")));
        Map<String, Object> lastMonthMap = screenDataService.getHistoryData(lastMonthStartDate, lastMonthEndDate, "JSLJLL", departId, masterDB);
        if (StringUtils.hasText(lastMonthMap.get("JSLL").toString())) {
            //上月水量
            Double lastMonthSl = Double.parseDouble(lastMonthMap.get("JSLL").toString());
            resultMap.put("上月累计水量", numberFormat.format(lastMonthSl / 10000));
            //本月水量
            if (StringUtils.hasText(monthMap.get("JSLL").toString())) {
                Double monthSl = Double.parseDouble(monthMap.get("JSLL").toString());
                //环比上月
                String hb = numberFormat.format((monthSl - lastMonthSl) / 10000);
                resultMap.put("环比上月", hb);
            }

        }
        result.setSuccess(true);
        result.setResult(resultMap);
        return result;
    }

    /**
     * 今日水量情况
     *
     * @param departId
     * @param req
     * @return
     */
    @AutoLog(value = "今日水量情况")
    @ApiOperation(value = "今日水量情况", notes = "今日水量情况")
    @GetMapping(value = "/getTodaySl")
    public Result<Map<String, Object>> getTodaySl(String departId,
                                                  HttpServletRequest req) {

        Result<Map<String, Object>> result = new Result<Map<String, Object>>();
        Map<String, Object> resultMap = new HashMap<String, Object>();
        JdbcTemplate masterDB = (JdbcTemplate) SpringContextUtils.getBean("master");
        if (!StringUtils.hasText(departId)) {//如果厂站为空，查询曹县厂
            departId = "f2df9193c8bc4e7a9cef0e4b98dd9e95";
        }
        String startDate = DateUtils.getTodayOrMonthDate("day") + " 00:00:00";
        //累计进水、累计出水
        Map<String, Object> map = screenDataService.getDifferData(startDate, "JSLL,CSLL", departId, "differ", masterDB);
        //瞬时进水、瞬时出水
        Map<String, Object> mapss = screenDataService.getDifferData(startDate, "JSLL,CSLL", departId, "avg", masterDB);

        resultMap.put("今日累计进水量", map.get("JSLL"));
        resultMap.put("今日累计出水量", map.get("CSLL"));
        resultMap.put("今日瞬时进水量", mapss.get("JSLL"));
        resultMap.put("今日瞬时出水量", mapss.get("CSLL"));

        result.setSuccess(true);
        result.setResult(resultMap);
        return result;
    }


    /**
     * 今日水量情况
     *
     * @param req GZGSDH
     * @return
     */

    @AutoLog(value = "各子公司电耗")
    @ApiOperation(value = "各子公司电耗", notes = "各子公司电耗")
    @PostMapping(value = "/getFactoryDH")
    public Result<Map<String, Object>> getFactoryDH(@RequestBody JSONObject jsonObject,
                                                    HttpServletRequest req) {

        Result<Map<String, Object>> result = new Result<Map<String, Object>>();
        Map<String, Object> resultMap = new LinkedHashMap<String, Object>();
        //将jsonObject转sysAlgorithmStatisticsLibraryVO对象
        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        QueryWrapper<SysDepart> sysDepartQueryWrapper = new QueryWrapper<>();
        sysDepartQueryWrapper.eq("del_flag", 1).eq("depart_type", 1)
                .select("id,depart_name");
        List<Map<String, Object>> departMapList = sysDepartService.listMaps(sysDepartQueryWrapper);
        String departIds = departMapList.stream().map(map ->
                String.valueOf(map.get("id"))
        ).collect(Collectors.joining(","));
        Map departs = departMapList.stream().collect(Collectors.toMap(s -> s.get("id"), s -> s.get("depart_name")));
        if (StringUtils.isEmpty(sysAlgorithmStatisticsLibraryVO.getDepartIds())) {
            sysAlgorithmStatisticsLibraryVO.setDepartIds(departIds);
        }
        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO sysAlgorithmStatisticsResultVO = null;
        try {
            sysAlgorithmStatisticsResultVO = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, new HashMap<>());
            SysAlgorithmStatisticsResultChartsVO charts = sysAlgorithmStatisticsResultVO.getCharts();
            List<String> xLine = charts.getXLine();
            Map<String, List<Double>> dataMap = null;//charts.getDataMap();


            List<Double> DSDHList = dataMap.get("DSDH");
            List<Double> HDLList = dataMap.get("HDL");
            List<Double> inWaterList = dataMap.get("进水");
            if (DSDHList.size() > 0) {

                List dList = new ArrayList();
                List zList = new ArrayList();
                List gList = new ArrayList();
                List pgList = new ArrayList();
                for (int i = 0; i < DSDHList.size(); i++) {
                    Double dsdh = DSDHList.get(i);
                    Double HDL = HDLList.get(i);
                    Double inWater = inWaterList.get(i);
                    String departName = String.valueOf(departs.get(xLine.get(i)));

                    HashMap<String, Object> dataResultMap = new HashMap<>();
                    dataResultMap.put("HDL", HDL);
                    dataResultMap.put("DSDH", dsdh);
                    dataResultMap.put("进水", inWater);
                    dataResultMap.put("departName", departName);
                    dataResultMap.put("departId", xLine.get(i));

                    if (dsdh < 0.4) {
                        dataResultMap.put("status", "低电耗");
                        dList.add(dataResultMap);
                    } else if (0.4 <= dsdh && dsdh <= 0.5) {
                        dataResultMap.put("status", "正常电耗");
                        zList.add(dataResultMap);
                    } else if (0.5 < dsdh && dsdh <= 0.7) {
                        dataResultMap.put("status", "偏高电耗");
                        pgList.add(dataResultMap);
                    } else if (0.7 < dsdh) {
                        dataResultMap.put("status", "高电耗");
                        gList.add(dataResultMap);
                    }

                }

                resultMap.put("d", dList.size());
                resultMap.put("z", zList.size());
                resultMap.put("g", gList.size());
                resultMap.put("pg", pgList.size());
                resultMap.put("total", pgList.size() + gList.size() + zList.size() + dList.size());
                resultMap.put("dList", dList);
                resultMap.put("zList", zList);
                resultMap.put("gList", gList);
                resultMap.put("pgList", pgList);
                result.setSuccess(true);
                result.setResult(resultMap);
            }


        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }


    /**
     * 今日水量情况
     *
     * @param req GZGSYH
     * @param req GLDSYH
     * @return
     */

    @AutoLog(value = "各子公司吨水药耗")
    @ApiOperation(value = "各子公司吨水药耗", notes = "各子公司吨水药耗")
    @PostMapping(value = "/getFactoryYH")
    public Result getFactoryYH(@RequestBody JSONObject jsonObject,
                               HttpServletRequest req) {

        Result result = new Result();

        //将jsonObject转sysAlgorithmStatisticsLibraryVO对象
        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        QueryWrapper<SysDepart> sysDepartQueryWrapper = new QueryWrapper<>();
        sysDepartQueryWrapper.eq("del_flag", 1).eq("depart_type", 1)
                .select("id,depart_name");
        List<SysDepart> departMapList = sysDepartService.list(sysDepartQueryWrapper);
        String departIds = departMapList.stream().map(map ->
                String.valueOf(map.getId())
        ).collect(Collectors.joining(","));

        Map<String, String> departMaps = departMapList.stream().collect(Collectors.toMap(SysDepart::getId, SysDepart::getDepartName));
        if (StringUtils.isEmpty(sysAlgorithmStatisticsLibraryVO.getDepartIds())) {
            sysAlgorithmStatisticsLibraryVO.setDepartIds(departIds);
        }


        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO sysAlgorithmStatisticsResultVO = null;

        try {

            List<Map<String, Object>> resultList = new ArrayList();
            for (Map.Entry<String, String> entry : departMaps.entrySet()) {
                Map<String, Object> resultMap = new LinkedHashMap<String, Object>();
                String departId = entry.getKey();
                //todo 多厂循环调配置接口速度问题，后期优化
                if (!"f2df9193c8bc4e7a9cef0e4b98dd9e95".equals(departId)) {
                    continue;
                }
                sysAlgorithmStatisticsLibraryVO.setDepartIds(departId);
                sysAlgorithmStatisticsResultVO = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, new HashMap<>());
                Map<String, SysAlgorithmStatisticsResultNumberVO> number = sysAlgorithmStatisticsResultVO.getNumber();
                resultMap.put("departId", departId);
                resultMap.put("departName", entry.getValue());
                SysAlgorithmStatisticsResultNumberVO jsVo = number.get("进水");
                Double jsVovalue = getDouble(jsVo.getValue() + "");
                Double jsVovalueHb = getDouble(jsVo.getValueHb() + "");
                Double jsVovalueTb = getDouble(jsVo.getValueTb() + "");
                for (Map.Entry<String, SysAlgorithmStatisticsResultNumberVO> resultNumberVOEntry : number.entrySet()) {
                    String key = resultNumberVOEntry.getKey();
                    if (key.contains("YYLB")) {
                        SysAlgorithmStatisticsResultNumberVO vo = resultNumberVOEntry.getValue();
                        Double value = getDouble(vo.getValue() + "");
                        Double valueHb = getDouble(vo.getValueHb() + "");
                        Double valueTb = getDouble(vo.getValueTb() + "");
                        String unit = vo.getUnit();
                        double dsYh = ConvertUtils.getDouble(value / jsVovalue, 0.0, 2);
                        double dsYhHb = ConvertUtils.getDouble(valueHb / jsVovalueHb, 0.0, 2);
                        double dsYhTb = ConvertUtils.getDouble(valueTb / jsVovalueTb, 0.0, 2);
                        String replace = key.replace("YYLB", "DSYH");
                        SysAlgorithmStatisticsResultNumberVO newVo = new SysAlgorithmStatisticsResultNumberVO();
                        newVo.setValue(dsYh);
                        newVo.setValueHb(dsYhHb);
                        newVo.setValueTb(dsYhTb);
                        newVo.setUnit(unit);
                        number.put(replace, newVo);
                    }

                }
                resultMap.put("number", number);
                resultList.add(resultMap);
            }


            result.setResult(resultList);


        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }


    /**
     * @param departId
     * @param req
     * @return
     */
    @AutoLog(value = "数字指挥中心-运行负荷率分析")
    @ApiOperation(value = "数字指挥中心-运行负荷率分析", notes = "数字指挥中心-运行负荷率分析")
    @GetMapping(value = "/factoryFhl")
    public Result<Map<String, Object>> factoryFhl(String departId, String month,
                                                  HttpServletRequest req) {

        Result<Map<String, Object>> result = new Result<Map<String, Object>>();
        Map<String, Object> resultMap = new HashMap<String, Object>();
        JdbcTemplate masterDB = (JdbcTemplate) SpringContextUtils.getBean("master");
        if (org.apache.commons.lang3.StringUtils.isEmpty(departId)) {
            departId = BaseContextHandler.getDeparts();
            QueryWrapper<SysDepart> sysDepartQueryWrapper = new QueryWrapper<>();
            sysDepartQueryWrapper.eq("del_flag", 1).eq("depart_type", 1).in("id", Lists.newArrayList(departId.split(",")))
                    .select("id,depart_name");
            List<Map<String, Object>> departMapList = sysDepartService.listMaps(sysDepartQueryWrapper);
            departId = departMapList.stream().map(map ->
                    String.valueOf(map.get("id"))
            ).collect(Collectors.joining(","));
        }
        String thisMonth = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM"));
        String startDate = DateUtils.getTodayOrMonthDate("day") + " 00:00:00";
        List<Map<String, Object>> fhlMaps = screenDataService.beforeTodayAvgFhl(departId, month, masterDB);
        //如果是当月,处理水量加上当天小时数据和实时数据
        if (!CollectionUtil.isEmpty(fhlMaps)) {
            int zcfhNum = 0;
            int dfhNum = 0;
            int cfhNum = 0;
            for (Map<String, Object> fhlMap : fhlMaps) {
                double fhl = Double.parseDouble(String.valueOf(fhlMap.getOrDefault("fhl", "0")));
                if (0.6 <= fhl && fhl <= 1.2) {
                    zcfhNum++;
                    fhlMap.put("status", "zcfh");
                } else if (0.6 > fhl) {
                    dfhNum++;
                    fhlMap.put("status", "dfh");
                } else if (1.2 < fhl) {
                    cfhNum++;
                    fhlMap.put("status", "cfh");
                }
            }
            resultMap.put("fhlMaps", fhlMaps);
            resultMap.put("zcfhNum", zcfhNum);
            resultMap.put("dfhNum", dfhNum);
            resultMap.put("cfhNum", cfhNum);
        }
        result.setSuccess(true);
        result.setResult(resultMap);
        return result;
    }
    /**
     * 今日水量情况
     *
     * @param departId
     * @param req
     * @return
     */
    @AutoLog(value = "厂区数字指挥中心-处理水量趋势")
    @ApiOperation(value = "厂区数字指挥中心-处理水量趋势", notes = "厂区数字指挥中心-处理水量趋势")
    @GetMapping(value = "/factorySLQS")
    public Result<Map<String, Object>> factorySLQS(String departId, String startTime, String endTime, String timeType,
                                                   HttpServletRequest req) {

        Result<Map<String, Object>> result = new Result<Map<String, Object>>();
        Map<String, Object> resultMap = new HashMap<String, Object>();
        JdbcTemplate masterDB = (JdbcTemplate) SpringContextUtils.getBean("master");
        if (!StringUtils.hasText(departId)) {//如果厂站为空，查询曹县厂
            departId = "f2df9193c8bc4e7a9cef0e4b98dd9e95";
        }
        String thisYear = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy"));
        String lastYear = LocalDate.now().minusYears(1).format(DateTimeFormatter.ofPattern("yyyy"));
        try {
            String formatStartTime = DateUtils.formatAddTime(startTime, "yyyy-MM-dd", Calendar.YEAR, -1);
            String formatEndTime = DateUtils.formatAddTime(endTime, "yyyy-MM-dd", Calendar.YEAR, -1);
            List<Map<String, Object>> fhlMaps = screenDataService.factorySLQS(departId, startTime, endTime, formatStartTime, formatEndTime, timeType);
            List<Object> dataList = new ArrayList<>();

            if (!CollectionUtil.isEmpty(fhlMaps)) {
                LinkedHashMap<String, Map<String, Object>> linkedHashMap = new LinkedHashMap<>();
                for (Map<String, Object> fhlMap : fhlMaps) {
                    String ts = String.valueOf(fhlMap.get("time"));
                    linkedHashMap.put(ts, fhlMap);
                }
                for (Map.Entry<String, Map<String, Object>> stringMapEntry : linkedHashMap.entrySet()) {
                    String time = stringMapEntry.getKey();
                    if (thisYear.equals(time.substring(0, 4))) {
                        Map<String, Object> lastYearmap = null;
                        if ("day".equals(timeType)) {
                            lastYearmap = linkedHashMap.getOrDefault(DateUtils.formatAddTime(time, "yyyy-MM-dd", Calendar.YEAR, -1), new HashMap<>());
                        } else if ("month".equals(timeType)) {
                            lastYearmap = linkedHashMap.getOrDefault(DateUtils.formatAddTime(time, "yyyy-MM", Calendar.YEAR, -1), new HashMap<>());

                        }
                        HashMap<String, Object> resultdata = new HashMap<>();
                        resultdata.put("time", time);
                        resultdata.put("CLSL", stringMapEntry.getValue().getOrDefault("clsl", "0"));
                        resultdata.put("TBCLSL", lastYearmap.getOrDefault("clsl", "0"));
                        resultdata.put("FHL", stringMapEntry.getValue().getOrDefault("fhl", "0"));
                        resultdata.put("TBFHL", lastYearmap.getOrDefault("fhl", "0"));
                        dataList.add(resultdata);
                    }

                }
            }
            resultMap.put("fhlMaps", dataList);
        } catch (Exception e) {
            e.printStackTrace();
        }

        result.setSuccess(true);
        result.setResult(resultMap);
        return result;
    }


    /**
     * 今日水量情况
     *
     * @param req GZGSYH
     * @return
     */

    @AutoLog(value = "数字指挥中心削减量、削减率")
    @ApiOperation(value = "数字指挥中心削减量、削减率", notes = "数字指挥中心削减量、削减率")
    @PostMapping(value = "/getXJL")
    public Result getXJL(@RequestBody JSONObject jsonObject,
                         HttpServletRequest req) {

        Result result = new Result();

        //将jsonObject转sysAlgorithmStatisticsLibraryVO对象
        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        QueryWrapper<SysDepart> sysDepartQueryWrapper = new QueryWrapper<>();
        sysDepartQueryWrapper.eq("del_flag", 1).eq("depart_type", 1)
                .select("id,depart_name");
        List<SysDepart> departMapList = sysDepartService.list(sysDepartQueryWrapper);
        String departIds = departMapList.stream().map(map ->
                String.valueOf(map.getId())
        ).collect(Collectors.joining(","));
        Map<String, String> departMaps = departMapList.stream().collect(Collectors.toMap(SysDepart::getId, SysDepart::getDepartName));
        if (StringUtils.isEmpty(sysAlgorithmStatisticsLibraryVO.getDepartIds())) {
            sysAlgorithmStatisticsLibraryVO.setDepartIds(departIds);
        }
        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO sysAlgorithmStatisticsResultVO = null;
        SysAlgorithmStatisticsResultVO sysAlgorithmStatisticsResultVOTB = null;
        SysAlgorithmStatisticsResultVO sysAlgorithmStatisticsResultVOHB = null;

        try {
            //本期
            JdbcTemplate masterDB = (JdbcTemplate) SpringContextUtils.getBean("master");
            //获取统计配置
            String statisticsCode = sysAlgorithmStatisticsLibraryVO.getStatisticsCode();
            Map<String, Object> statisticsMap = masterDB.queryForMap("select * from sys_algorithm_statistics_library where statistics_code='" + statisticsCode + "'");
            if (StringUtil.isNotBlank(sysAlgorithmStatisticsLibraryVO.getStatisticsGranularity())) {
                statisticsMap.put("statistics_granularity", sysAlgorithmStatisticsLibraryVO.getStatisticsGranularity());
            }
            // statistics_type` '统计类型0数字、1统计图 趋势',
            String statisticsType = sysAlgorithmStatisticsLibraryVO.getStatisticsType();
            if (StringUtil.isNotBlank(statisticsType)) {
                statisticsMap.put("statistics_type", statisticsType);

            }
            sysAlgorithmStatisticsResultVO = null;
            //同比
            if ("1".equals(statisticsType)) {
                String startDate = sysAlgorithmStatisticsLibraryVO.getStartDate();
                String endDate = sysAlgorithmStatisticsLibraryVO.getEndDate();
                sysAlgorithmStatisticsLibraryVO.setStartDate(DateUtils.formatAddTime(startDate, "yyyy-MM-dd", Calendar.YEAR, -1));
                sysAlgorithmStatisticsLibraryVO.setEndDate(DateUtils.formatAddTime(endDate, "yyyy-MM-dd", Calendar.YEAR, -1));
                sysAlgorithmStatisticsResultVOTB = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, new HashMap<>());
            }
            result.setResult(sysAlgorithmStatisticsResultVO);


        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 厂区信息自定义查询
     *
     * @return
     */
    @AutoLog(value = "厂区详细信息-厂区信息自定义查询")
    @ApiOperation(value = "厂区详细信息-厂区信息自定义查询", notes = "厂区详细信息-厂区信息自定义查询")
    @RequestMapping(value = "/getFactoryListByWrapper", method = RequestMethod.GET)
    public Result<List<SysFactoryInfoVO>> getFactoryListByWrapper(SysFactoryInfoVO sysFactoryInfoVO) {
        Result<List<SysFactoryInfoVO>> result = new Result<>();
        QueryWrapper<SysFactoryInfoVO> queryWrapper = new QueryWrapper<>();
        String departType = sysFactoryInfoVO.getDepartType();
        if (ConvertUtils.isNotEmpty(departType)) {
            queryWrapper.in("d.depart_type", departType.split(","));
        }
        if (ConvertUtils.isNotEmpty(sysFactoryInfoVO.getDepartId())) {
            queryWrapper.in("d.id", sysFactoryInfoVO.getDepartId().split(","));
        } else{
            queryWrapper.in("d.id", BaseContextHandler.getDeparts().split(","));
        }
        queryWrapper.orderByAsc("d.depart_order");
        List<SysFactoryInfoVO> factoryInfoVOS = sysFactoryInfoService.getFactoryListByWrapper(queryWrapper);
        //查询厂站设备通道名
        List<SysFactoryDevice> sysFactoryDevices = sysFactoryDeviceService.list();
        Map<String, SysFactoryDevice> sysFactoryDeviceMap = Maps.newHashMap();
        ArrayList<String> iotIds = new ArrayList<>();
        for (SysFactoryDevice sysFactoryDevice : sysFactoryDevices) {
            String factoryId = sysFactoryDevice.getDepartId();
            sysFactoryDeviceMap.put(factoryId, sysFactoryDevice);
            iotIds.add(sysFactoryDevice.getDeviceId());
        }
        try {
            JdbcTemplate master = (JdbcTemplate) SpringContextUtils.getBean("master");
            String sql = "SELECT\n" +
                    "c.video_root_name AS area_name,\n" +
                    "d.depart_name AS depart_name,\n" +
                    "a.*\n" +
                    "FROM\n" +
                    "t_video a\n" +
                    "left JOIN t_video_relate_root b ON a.id = b.video_id\n" +
                    "left JOIN t_video_root c ON b.video_root_id = c.id\n" +
                    "left JOIN sys_depart d ON c.depart_id = d.id";
            List<Map<String, Object>> videos = master.queryForList(sql);
            Map<String, Map<String, Object>> videoData = Maps.newHashMap();
            for (Map<String, Object> video : videos) {
                String depart_id = ConvertUtils.getString(video.get("struct_dic_id"));
                videoData.put(depart_id, video);
            }
            Map<String, String> statusMap = new HashMap<>();
            Map<String, String> aiStatusMap = new HashMap<>();
            for (SysFactoryInfoVO factoryInfoVO : factoryInfoVOS) {
                String departId = factoryInfoVO.getDepartId();
                Map<String, Object> videoDataOrDefault = videoData.getOrDefault(departId, new HashMap<>());
                String ip = ConvertUtils.getString(videoDataOrDefault.get("video_ip"));
                SysFactoryDevice devices = sysFactoryDeviceMap.getOrDefault(departId, new SysFactoryDevice());
                String iotDeviceId = devices.getDeviceId();
                String ioStatus = "1";
                //流量站/水质站/雨量站的在线状态
                if ("1000".equals(factoryInfoVO.getDepartType()) || "2000".equals(factoryInfoVO.getDepartType()) || "3000".equals(factoryInfoVO.getDepartType())|| "9000".equals(factoryInfoVO.getDepartType())) {
                    {
                        ioStatus = statusMap.getOrDefault(iotDeviceId, "OFFLINE");
                        if (!"OFFLINE".equals(ioStatus)) {
                            ioStatus = "1";
                        } else {
                            ioStatus = "0";
                        }
                    }
                    //摄像头的在线状态
                } else if ("4000".equals(factoryInfoVO.getDepartType())) {
                    if (org.apache.commons.lang3.StringUtils.isNotBlank(ip)) {
                        ioStatus = aiStatusMap.getOrDefault(ip, "0");
                    }

                } else {
                    ioStatus = "1";
                }
                factoryInfoVO.setState(ioStatus);
            }
        } catch (
                Exception e) {
            e.printStackTrace();
        }
        result.success("200");
        result.setResult(factoryInfoVOS);
        return result;

    }

    /**
     * 今日水量情况
     * @param jsonObject
     * @return
     */
    @AutoLog(value = "厂区数字指挥中心费用统计")
    @ApiOperation(value = "厂区数字指挥中心费用统计", notes = "厂区数字指挥中心费用统计")
    @PostMapping(value = "/getFYTJ")
    public Result getFYTJ(@RequestBody JSONObject jsonObject) {
        Result result = new Result();
        //将jsonObject转sysAlgorithmStatisticsLibraryVO对象
        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        QueryWrapper<SysDepart> sysDepartQueryWrapper = new QueryWrapper<>();
        sysDepartQueryWrapper.eq("del_flag", 1).eq("depart_type", 1)
                .select("id,depart_name");
        List<SysDepart> departMapList = sysDepartService.list(sysDepartQueryWrapper);
        String departIds = departMapList.stream().map(map ->
                String.valueOf(map.getId())
        ).collect(Collectors.joining(","));
        Map<String, String> departMaps = departMapList.stream().collect(Collectors.toMap(SysDepart::getId, SysDepart::getDepartName));
        if (StringUtils.isEmpty(sysAlgorithmStatisticsLibraryVO.getDepartIds())) {
            sysAlgorithmStatisticsLibraryVO.setDepartIds(departIds);
        }
        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO sysAlgorithmStatisticsResultVO = null;
        SysAlgorithmStatisticsResultVO sysAlgorithmStatisticsResultVOTB = null;
        SysAlgorithmStatisticsResultVO sysAlgorithmStatisticsResultVOHB = null;

        try {
            //本期
            JdbcTemplate masterDB = (JdbcTemplate) SpringContextUtils.getBean("master");
            //获取统计配置
            String statisticsCode = sysAlgorithmStatisticsLibraryVO.getStatisticsCode();
            Map<String, Object> statisticsMap = masterDB.queryForMap("select * from sys_algorithm_statistics_library where statistics_code='" + statisticsCode + "'");
            //"统计粒度day、month、year
            if (StringUtil.isNotBlank(sysAlgorithmStatisticsLibraryVO.getStatisticsGranularity())) {
                statisticsMap.put("statistics_granularity", sysAlgorithmStatisticsLibraryVO.getStatisticsGranularity());
            }
            // statistics_type` '统计类型0数字、1统计图 趋势',
            String statisticsType = sysAlgorithmStatisticsLibraryVO.getStatisticsType();
            if (StringUtil.isNotBlank(statisticsType)) {
                statisticsMap.put("statistics_type", statisticsType);
            }
            String startDate = sysAlgorithmStatisticsLibraryVO.getStartDate();
            String endDate = sysAlgorithmStatisticsLibraryVO.getEndDate();
            String startDateormat = DateUtils.dateformat(startDate, "yyyy-MM");
            String endDateformat = DateUtils.dateformat(endDate, "yyyy-MM");
            sysAlgorithmStatisticsResultVO = null;//sysAlgorithmStatisticsLibraryService.statisticsDayAndFill(sysAlgorithmStatisticsLibraryVO, paramMap, statisticsMap, masterDB);
            String appendSql = "";
            if (StringUtil.isNotBlank(departIds)) {
                String[] factory = departIds.split(",");
                StringBuilder sb = new StringBuilder();
                for (String departId : factory) {
                    sb.append(",'").append(departId).append("'");
                }
                if (StringUtil.isNotBlank(sb.toString())) {
                    appendSql = "and b.depart_id in (" + sb.substring(1) + ")";
                }

            }
            String queryDFsql = "select b.depart_id,a.id itemId , a.item_code,a.item_alias,b.data_time,sum(b.item_value)item_value  from f_report_item a left join f_report_itemv b on a.id= b.reit_id where item_code = 'bydfdaca' and report_id = '0019c63fbf21dae37870d72037c01bf9' \n" +
                    "and data_time>='" + startDateormat + "' and data_time<='" + endDateformat + "'\n" + appendSql +
                    "GROUP BY b.data_time order by data_time ";
            //电费
            List<Map<String, Object>> dF = masterDB.queryForList(queryDFsql);
            LinkedHashMap<String, Object> dFMap = new LinkedHashMap<>();
            for (Map<String, Object> map : dF) {
                dFMap.put("" + map.get("data_time"), map.getOrDefault("item_value", 0));
            }
            SysAlgorithmStatisticsResultChartsVO charts = sysAlgorithmStatisticsResultVO.getCharts();
            Map<String, List<Double>> dataMap = null;//charts.getDataMap();
            List<String> xLine = charts.getXLine();
            List<Double> inWaterList = dataMap.get("进水");
            List<Double> dSDFList = new ArrayList<>();
            List<Double> dFList = new ArrayList<>();
            for (int i = 0; i < xLine.size(); i++) {
                double dfValue = ConvertUtils.getDouble(dFMap.getOrDefault(xLine.get(i), "0") + "", 0.0, 2);
                dFList.add(dfValue);
                //吨水电费
                double dSDF = ConvertUtils.getDouble(dfValue / inWaterList.get(i), 0.0, 2);
                dSDFList.add(dSDF);
            }
            dataMap.put("DF", dFList);
            dataMap.put("DSDF", dSDFList);
            result.setResult(sysAlgorithmStatisticsResultVO);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return result;
    }

    @AutoLog(value = "能耗统计详情")
    @ApiOperation(value = "能耗统计详情", notes = "能耗统计详情")
    @PostMapping(value = "/getNHTJXQ")
    public Result<List<Map<String, Object>>> getNHTJXQ(@RequestBody JSONObject jsonObject,
                                                       HttpServletRequest req) throws Exception {
        Result<List<Map<String, Object>>> result = new Result<>();
        jsonObject.put("statisticsCode", "YJFYPZ");
        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO yjVO = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, paramMap);
        jsonObject.put("statisticsCode", "DFPZ");
        sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        //将jsonObject转Map对象
        paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO dfVO = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, paramMap);

        List<Map<String, Object>> yjVONumberList = yjVO.getNumberList();
        List<Map<String, Object>> dfVONumberList = dfVO.getNumberList();
        for (Map<String, Object> yjVONumberMap : yjVONumberList) {
            for (Map<String, Object> dfVONumberMap : dfVONumberList) {
                if (yjVONumberMap.get("groupField").equals(dfVONumberMap.get("groupField"))) {
                    yjVONumberMap.putAll(dfVONumberMap);
                }
            }
        }
        yjVONumberList = yjVONumberList.stream().sorted((j, i) -> {
            Double k1 = 0.0;
            Double k2 = 0.0;
            try {
                k1 = Double.parseDouble(ConvertUtils.getString(((SysAlgorithmStatisticsResultNumberVO) j.get("YJDSFY")).getValue()).replace("-", "0"));
            } catch (Exception e) {

            }
            try {
                k2 = Double.parseDouble(ConvertUtils.getString(((SysAlgorithmStatisticsResultNumberVO) i.get("YJDSFY")).getValue()).replace("-", "0"));
            } catch (Exception e) {

            }
            return k2.compareTo(k1);
        }).collect(Collectors.toList());
        int count = 1;
        for (Map<String, Object> map : yjVONumberList) {
            map.put("YJDSFYPM", count);
            count++;
        }
        yjVONumberList = yjVONumberList.stream().sorted((j, i) -> {
            Double k1 = 0.0;
            Double k2 = 0.0;
            try {
                k1 = Double.parseDouble(ConvertUtils.getString(((SysAlgorithmStatisticsResultNumberVO) j.get("DSDF")).getValue()).replace("-", "0"));
            } catch (Exception e) {

            }
            try {
                k2 = Double.parseDouble(ConvertUtils.getString(((SysAlgorithmStatisticsResultNumberVO) i.get("DSDF")).getValue()).replace("-", "0"));
            } catch (Exception e) {

            }
            return k2.compareTo(k1);
        }).collect(Collectors.toList());
        count = 1;
        for (Map<String, Object> map : yjVONumberList) {
            map.put("DSDFPM", count);
            count++;
        }
        result.setSuccess(true);
        result.setResult(yjVONumberList);
        return result;
    }

    @AutoLog(value = "各子公司吨水药耗")
    @ApiOperation(value = "各子公司吨水药耗", notes = "各子公司吨水药耗")
    @PostMapping(value = "/getFactoryYHB")
    public Result getFactoryYHB(@RequestBody JSONObject jsonObject,
                                HttpServletRequest req) throws Exception {

        Result result = new Result();
        List<SysDepart> sysDeparts = sysDepartService.list();
        Map<String, String> factoryMap = Maps.newHashMap();
        for (SysDepart sysDepart : sysDeparts) {
            factoryMap.put(sysDepart.getId(), sysDepart.getDepartName());
        }
        // Result<List<Map<String, Object>>> result = new Result<>();
        jsonObject.put("statisticsCode", "GLYHB");

        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO yjVO = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, paramMap);
        List<Map<String, Object>> numberList = yjVO.getNumberList();
        List<Map<String, Object>> newNumberList = Lists.newArrayList();
        try {
            for (Map<String, Object> map : numberList) {
                SysAlgorithmStatisticsResultNumberVO jsVo = (SysAlgorithmStatisticsResultNumberVO) map.get("JSLJLLZ");
                Double jsVovalue = getDouble(jsVo.getValue() + "");
                Double jsVovalueHb = getDouble(jsVo.getValueHb() + "");
                Double jsVovalueTb = getDouble(jsVo.getValueTb() + "");
                Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
                Map<String, Object> newMap = Maps.newTreeMap();
                newMap.putAll(map);
                newMap.put("departName", factoryMap.get(map.get("groupField")));
                while (iterator.hasNext()) {
                    Map.Entry<String, Object> resultNumberVOEntry = iterator.next();
                    String key = resultNumberVOEntry.getKey();
                    if (key.contains("YYLB")) {
                        SysAlgorithmStatisticsResultNumberVO vo = (SysAlgorithmStatisticsResultNumberVO) resultNumberVOEntry.getValue();
                        Double value = getDouble(vo.getValue() + "");
                        Double valueHb = getDouble(vo.getValueHb() + "");
                        Double valueTb = getDouble(vo.getValueTb() + "");
                        double dsYh = ConvertUtils.getDouble(value / jsVovalue, 0.0, 2);
                        double dsYhHb = ConvertUtils.getDouble(valueHb / jsVovalueHb, 0.0, 2);
                        double dsYhTb = ConvertUtils.getDouble(valueTb / jsVovalueTb, 0.0, 2);
                        String replace = key.replace("YYLB", "DSYH");
                        SysAlgorithmStatisticsResultNumberVO newVo = new SysAlgorithmStatisticsResultNumberVO();

                        //同比
                        String valueHbProportion = ("0.0".equals(dsYhHb) || isNumeric(String.valueOf((dsYh - dsYhHb) / dsYhHb))) ? "-" : String.valueOf((dsYh - dsYhHb) * 100 / dsYhHb);
                        //环比
                        String valueTbProportion = ("0.0".equals(dsYhTb) || isNumeric(String.valueOf((dsYh - dsYhTb) / dsYhTb))) ? "-" : String.valueOf((dsYh - dsYhTb) * 100 / dsYhTb);
                        valueHbProportion = valueHbProportion.replace("NaN", "-").replace("Infinity", "-");
                        valueTbProportion = valueTbProportion.replace("NaN", "-").replace("Infinity", "-");
                        newVo.setValue(dsYh);
                        newVo.setValueHb(dsYhHb);
                        newVo.setValueTb(dsYhTb);
                        newVo.setUnit("kg/吨水");
                        newVo.setValueHbProportion(valueTbProportion);
                        newVo.setValueTbProportion(valueHbProportion);
                        newMap.put(replace, newVo);
                    }
                }
                newNumberList.add(newMap);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        result.setResult(newNumberList);
        return result;
    }

    @AutoLog(value = "处理水量详情")
    @ApiOperation(value = "处理水量详情", notes = "处理水量详情")
    @PostMapping(value = "/getCLSLXQ")
    public Result<List<Map<String, Object>>> getCLSLXQ(@RequestBody JSONObject jsonObject,
                                                       HttpServletRequest req) throws Exception {
        Result<List<Map<String, Object>>> result = new Result<>();
        QueryWrapper<SysFactoryInfo> sysFactoryInfoQueryWrapper = new QueryWrapper<>();
        String departIds = ConvertUtils.getString(jsonObject.get("departIds"));
        if (!org.apache.commons.lang3.StringUtils.isBlank(departIds)) {
            sysFactoryInfoQueryWrapper.in("depart_id", Arrays.asList(departIds.split(",")));
        }
        sysFactoryInfoQueryWrapper.eq("factory_type", "1");
        sysFactoryInfoQueryWrapper.select("pro_scale*10000 as proScale", "depart_id as departId");
        List<Map<String, Object>> maps = sysFactoryInfoService.listMaps(sysFactoryInfoQueryWrapper);
        StringBuilder departIdStringBuilder = new StringBuilder();
        StringBuilder proScaleStringBuilder = new StringBuilder();
        for (Map<String, Object> map : maps) {
            departIdStringBuilder.append(",");
            departIdStringBuilder.append(map.get("departId"));
            proScaleStringBuilder.append(",");
            proScaleStringBuilder.append(map.get("proScale"));
        }
        jsonObject.put("departIds", ConvertUtils.getString(departIdStringBuilder).replaceFirst(",", ""));
        jsonObject.put("SJGM", ConvertUtils.getString(proScaleStringBuilder).replaceFirst(",", ""));
        jsonObject.put("statisticsCode", "CLSLXQ");
        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO vo = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, paramMap);
        List<Map<String, Object>> numberList = vo.getNumberList();
        numberList = numberList.stream().sorted((j, i) -> {
            Double k1 = 0.0;
            Double k2 = 0.0;
            try {
                k1 = Double.parseDouble(ConvertUtils.getString(((SysAlgorithmStatisticsResultNumberVO) j.get("FHL")).getValue()).replace("-", "0"));
            } catch (Exception e) {

            }
            try {
                k2 = Double.parseDouble(ConvertUtils.getString(((SysAlgorithmStatisticsResultNumberVO) i.get("FHL")).getValue()).replace("-", "0"));
            } catch (Exception e) {

            }
            return k2.compareTo(k1);
        }).collect(Collectors.toList());
        int count = 1;
        for (Map<String, Object> map : numberList) {
            map.put("FHLPM", count);
            count++;
        }
        result.setSuccess(true);
        result.setResult(numberList);
        return result;
    }

    @AutoLog(value = "产泥详情")
    @ApiOperation(value = "产泥详情", notes = "产泥详情")
    @PostMapping(value = "/getCNXQ")
    public Result<List<Map<String, Object>>> getCNXQ(@RequestBody JSONObject jsonObject,
                                                     HttpServletRequest req) throws Exception {
        Result<List<Map<String, Object>>> result = new Result<>();
        jsonObject.put("statisticsCode", "CNXQ");
        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO vo = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, paramMap);
        List<Map<String, Object>> numberList = vo.getNumberList();
        result.setSuccess(true);
        result.setResult(numberList);
        return result;
    }

    @AutoLog(value = "电耗详情")
    @ApiOperation(value = "电耗详情", notes = "电耗详情")
    @PostMapping(value = "/getDHXQ")
    public Result<List<Map<String, Object>>> getDHXQ(@RequestBody JSONObject jsonObject,
                                                     HttpServletRequest req) throws Exception {
        Result<List<Map<String, Object>>> result = new Result<>();
        jsonObject.put("statisticsCode", "DHXQ");
        SysAlgorithmStatisticsLibraryVO sysAlgorithmStatisticsLibraryVO = JSONObject.toJavaObject(jsonObject, SysAlgorithmStatisticsLibraryVO.class);
        //将jsonObject转Map对象
        Map<String, Object> paramMap = JSONObject.toJavaObject(jsonObject, Map.class);
        //将paramMap集合去掉SysAlgorithmStatisticsLibraryVO对象内容
        Map<String, Object> sysAlgorithmStatisticsLibraryVOMap = JSON.parseObject(JSON.toJSONString(sysAlgorithmStatisticsLibraryVO), new TypeReference<Map<String, Object>>() {
        });
        //Maps.difference(Map, Map)用来比较两个Map以获取所有不同点
        MapDifference<String, Object> difference = Maps.difference(paramMap, sysAlgorithmStatisticsLibraryVOMap);
        // 键只存在于左边Map的映射项
        paramMap = difference.entriesOnlyOnLeft();
        SysAlgorithmStatisticsResultVO vo = sysAlgorithmStatisticsLibraryService.statistics(sysAlgorithmStatisticsLibraryVO, paramMap);
        List<Map<String, Object>> numberList = vo.getNumberList();
        numberList = numberList.stream().sorted((j, i) -> {
            Double k1 = 0.0;
            Double k2 = 0.0;
            try {
                k1 = Double.parseDouble(ConvertUtils.getString(((SysAlgorithmStatisticsResultNumberVO) j.get("DSDHTB")).getValue()).replace("-", "0"));
            } catch (Exception e) {

            }
            try {
                k2 = Double.parseDouble(ConvertUtils.getString(((SysAlgorithmStatisticsResultNumberVO) i.get("DSDHTB")).getValue()).replace("-", "0"));
            } catch (Exception e) {

            }
            return k2.compareTo(k1);
        }).collect(Collectors.toList());
        int count = 1;
        for (Map<String, Object> map : numberList) {
            map.put("DSDHTBPM", count);
            count++;
        }
        result.setSuccess(true);
        result.setResult(numberList);
        return result;
    }

/**
 * 功能描述: <br>运营日报进出水初始化
 * @Param:
        * @Return:
        * @Author: [Gao Ran]
        * @Date: 2022/1/19 17:57
 */
    @AutoLog(value = "//运营日报进出水初始化")
    @ApiOperation(value = "//运营日报进出水初始化", notes = "//运营日报进出水初始化")
    @GetMapping(value = "/test")
    public Result test(String startTime, String endTime,
                       HttpServletRequest req) throws Exception {
        log.info(String.format("定时日报表服务开始:" + DateUtils.getTimestamp()));
        List<String> dateList = DateUtils.sliceUpDateRange(startTime, endTime, "month");
        // String startTime = DateUtils.getMonthFirstOrLastDay(DateUtils.formatDateTime(),"start");
        //10 * * * * ?
        // 0 0 2 * * ?
        Map<String, String> code2ItemCodeMap = Maps.newHashMap();
        code2ItemCodeMap.put("JSLJLL", "jsl12e8");
        code2ItemCodeMap.put("CSLJLL", "clsle111");
        code2ItemCodeMap.put("HSSL", "hssl1081");
        String codes = "JSLJLL,CSLJLL";
        String codeIds = "";
        for (String code : codes.split(",")) {
            codeIds += ",'" + code + "'";
        }
        JdbcTemplate masterDB = (JdbcTemplate) SpringContextUtils.getBean("master");
        for (String date : dateList) {
            List<Map<String, Object>> dataList = masterDB.queryForList("select * from sys_data_calculation where index_tag in (" + codeIds.replaceFirst(",", "") + ") and ts >='" + date + "'and ts<='" + date + "'");
            if (CollectionUtil.isEmpty(dataList)) {
                continue;
            }
            List<SysFactoryDevice> factoryDevices = sysFactoryDeviceService.list();
            Map<String, Map<String, String>> factoryDataMap = Maps.newHashMap();
            for (SysFactoryDevice factoryDevice : factoryDevices) {
                Map<String, String> dataMap = Maps.newHashMap();
                String departId = factoryDevice.getDepartId();
                for (Map<String, Object> data : dataList) {
                    String code = data.get("index_tag") + "";
                    String ts = data.get("ts") + "";
                    String itemCode = code2ItemCodeMap.get(code);
                    String value = data.getOrDefault("index_value", "0.0") + "";
                    String depart_id = data.get("depart_id") + "";
                    if (departId.equals(depart_id)) {
                        dataMap.put(itemCode, value);
                    }
                }
                factoryDataMap.put(departId, dataMap);
            }

            for (Map.Entry<String, Map<String, String>> entry : factoryDataMap.entrySet()) {
                dataCountDayService.insertOrUpdateReportData(entry.getKey(), date, entry.getValue(), "7675958885b94b8df41b7cade8b12e23");
            }
        }
        log.info(String.format("定时日报表服务结束:" + DateUtils.getTimestamp()));
        return Result.ok("初始化完成");
    }


    private static Double getDouble(String value) {
        if (StringUtil.isNotBlank(value) && !"null".equals(value) && !"-".equals(value)) {
            return ConvertUtils.getDouble(value, 0.0, 2);
        }
        return 0.0;
    }

    public static boolean isNumeric(String str) {
        String bigStr;
        try {
            bigStr = new BigDecimal(str).toString();
        } catch (Exception e) {
            return false;//异常 说明包含非数字。
        }
        return true;
    }

    public static List<String> getBetweenDate(String start, String end) {
        List<String> list = new ArrayList<>();
        // LocalDate默认的时间格式为2020-02-02
        LocalDate startDate = LocalDate.parse(start);
        LocalDate endDate = LocalDate.parse(end);
        long distance = ChronoUnit.DAYS.between(startDate, endDate);
        if (distance < 1) {
            return list;
        }
        Stream.iterate(startDate, d -> d.plusDays(1)).limit(distance + 1).forEach(f -> list.add(f.toString()));
        return list;
    }

    @AutoLog(value = "获取实时数据")
    @ApiOperation(value = "获取实时数据", notes = "获取实时数据")
    @PostMapping(value = "/getRealTimeSz")
    public Result<Map<String, Object>> getRealTimeSz(@RequestBody DataParams dataParams) {
        Result<Map<String, Object>> result = new Result<>();
        Map<String, Object> map = new HashMap<>();








        result.setResult(map);
        return result;
    }

    @AutoLog(value = "获取污水用电情况")
    @ApiOperation(value = "获取污水用电情况", notes = "获取污水用电情况")
    @PostMapping(value = "/getYhdlqs")
    public Result<List<Map<String, Object>>> getYhdlqs(@RequestBody StatisticsParams statisticsParams) {
        Result<List<Map<String, Object>>> result = new Result<>();
        List<Map<String, Object>> list = new ArrayList<>();
        list = screenDataService.getYhdlqs(statisticsParams);
        result.setResult(list);
        return result;
    }

    @AutoLog(value = "污水用药情况")
    @ApiOperation(value = "污水用药情况", notes = "污水用药情况")
    @PostMapping(value = "/getYhylqs")
    public Result<List<Map<String, Object>>> getYhylqs(@RequestBody StatisticsParams statisticsParams) {
        Result<List<Map<String, Object>>> result = new Result<>();
        List<Map<String, Object>> list = new ArrayList<>();
        list = screenDataService.getYhylqs(statisticsParams);
        result.setResult(list);
        return result;
    }


    /**
     * app工艺段实时数据分组查询
     *
     * @param departId
     * @param req
     * @return
     */
    @AutoLog(value = "工艺段实时数据分组查询")
    @ApiOperation(value = "工艺段实时数据分组查询", notes = "工艺段实时数据分组查询")
    @GetMapping(value = "/getRealData")
    public Result getRealTimeData(String statics, String departId, HttpServletRequest req, String  startTime, String  endTime, String departType, String structCode, String isApp, String tag, String pgId) {
        Result result = new Result();
//        if (!org.springframework.util.StringUtils.hasText(departId)) {
//            //如果厂站为空
//            departId = BaseContextHandler.getDeparts();
//        }
        String order = req.getParameter("order");
        String groupName = req.getParameter("groupName");
        String pattern = "yyyy-MM-dd HH:mm:ss";
        String timePeriod = "mm";
        if (org.apache.commons.lang3.StringUtils.isNotBlank(statics)) {
            if (statics.equals("mm")) {
                pattern = "yyyy-MM-dd HH:mm:ss";
                timePeriod = "mm";
            } else if (statics.equals("day")) {
                pattern = "yyyy-MM-dd HH:mm:ss";
                timePeriod = "mm";
            } else if (statics.equals("month")) {
                pattern = "yyyy-MM-dd";
                timePeriod = "d";
            } else if (statics.equals("year")) {
                pattern = "yyyy-MM";
                timePeriod = "m";
            }
        }
        List<Map<String, Object>> dictGroupData = getDictGroup(departType, departId, tag, pgId, structCode, groupName);
        //点表id
        String fields = dictGroupData.stream().map(data -> ConvertUtils.getString(data.get("id"))).collect(Collectors.joining(","));
        //指标标准化编码
        String codeId = dictGroupData.stream().map(data -> ConvertUtils.getString(data.get("metric_uid_tag"))).distinct().collect(Collectors.joining(","));
        Map<String, String> id2Name = dictGroupData.stream().collect(Collectors.toMap(data -> ConvertUtils.getString(data.get("id")), data -> ConvertUtils.getString(data.get("metric_name")), (o1, o2) -> o1));

        //查询指标的实时pg值
        List<Map<String, Object>> maps = new ArrayList<>();
        List<Map<String, Object>> pgList = new ArrayList<>();
        try {
            if (org.apache.commons.lang3.StringUtils.isEmpty(startTime) && org.apache.commons.lang3.StringUtils.isEmpty(endTime)) {
                JdbcTemplate pgdb = (JdbcTemplate) SpringContextUtils.getBean("pg-db");
                String fieldsCollect = Arrays.stream(fields.split(",")).map(data -> "'" + data + "'").collect(Collectors.joining(","));
                String yyyyMMdd = DateUtils.format(new Date(), "yyyyMMdd");
                String sql = "select * from realtimedata where nm in (" + fieldsCollect + ")";
//                String sql = "SELECT t2.* FROM" +
//                        "( SELECT nm, MAX ( ts ) ts FROM xsinsert" + yyyyMMdd + "  where nm in (" + fieldsCollect + ") GROUP BY nm ,ts ) t1, " +
//                        "xsinsert" + yyyyMMdd + "  t2 WHERE t1.nm = t2.nm  AND t1.ts = t2.ts and t2.nm in (" + fieldsCollect + ")";
                pgList = pgdb.queryForList(sql);
                maps = new ArrayList<>();
                for (Map<String, Object> pgMap : pgList) {
                    Map<String, Object> pgTimeValMap = Maps.newHashMap();
                    String nm = ConvertUtils.getString(pgMap.get("nm"));
                    pgTimeValMap.put(nm, ConvertUtils.getString(pgMap.get("v")));
                    pgTimeValMap.put("time", ConvertUtils.getString(pgMap.get("ts")));
                    maps.add(pgTimeValMap);

                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        //如果起止时间不为空,查询小时表趋势的数据
        if (org.apache.commons.lang3.StringUtils.isNotBlank(startTime) && org.apache.commons.lang3.StringUtils.isNotBlank(endTime)) {
            maps = factoryInfoService.queryFactoryInfos(departId, fields, startTime, endTime, "1");
            if (org.apache.commons.lang3.StringUtils.isNotBlank(statics)) {
                maps = factoryInfoService.handleResult(maps, timePeriod, fields);
                for (Map<String, Object> map : maps) {
                    //除time字段外，求平均值
                    for (String field : fields.split(",")) {
                        Object value = map.get(field);
                        Object valueSumCount = map.get(field + "_tag");
                        if (field.contains("LJ")) {
                            //求和则使用原来求和的值
                            map.put(field, DoubleOperaUtils.bigDecimalRound(ConvertUtils.getDouble(value, 0.00), 2));
                        } else {
                            //用平均值改写原来合计值
                            map.put(field, DoubleOperaUtils.bigDecimalRound(ConvertUtils.getDouble(value, 0.00) / ConvertUtils.getDouble(valueSumCount, 1.00), 2));
                        }
                    }
                }
            }
        }
        //如果起止时间不为空,特殊处理测压点的趋势的数据
//        if (org.apache.commons.lang3.StringUtils.isNotBlank(startTime) && org.apache.commons.lang3.StringUtils.isNotBlank(endTime) && "6".equals(departType)) {
//            try {
//                JdbcTemplate pgdb = (JdbcTemplate) SpringContextUtils.getBean("pg-db");
//                String fieldsCollect = Arrays.stream(fields.split(",")).map(data -> "'" + data + "'").distinct().collect(Collectors.joining(","));
//                String sql = "select ts as time,nm as monitorId,v as monitorValue from yl_day where nm in (" + fieldsCollect + ") and ts>='" + DateUtils.getMillis(DateUtils.parse(startTime, "yyyy-MM-dd HH:mm:ss")) / 1000 + "' and ts<='" + DateUtils.getMillis(DateUtils.parse(endTime, "yyyy-MM-dd HH:mm:ss")) / 1000 + "'";
//                maps = pgdb.queryForList(sql);
//                maps = dataRowToCellByTime(new ArrayList<Map<String, Object>>(), maps);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//
//        }
        //校验数据判断组装
        List<RealTimeDataVO> res;
        //实时数据按厂站格式分组组装数据
        if (org.apache.commons.lang3.StringUtils.isNotBlank(departType) && org.apache.commons.lang3.StringUtils.isEmpty(startTime) && org.apache.commons.lang3.StringUtils.isEmpty(endTime)) {
            res = alarmPgVal(departId, maps, dictGroupData, pattern);
            List<Map<String, Object>> resList;
            resList = staticsForDepart(departType, res, departId);
            result.setResult(resList);
        }
        //如果是趋势图以时间分组格式组装
        else if (org.apache.commons.lang3.StringUtils.isNotBlank(startTime) && org.apache.commons.lang3.StringUtils.isNotBlank(endTime)) {
            res = alarmPgVal(departId, maps, dictGroupData, pattern);

            Map<String, List<RealTimeDataVO>> collect = res.stream().sorted(Comparator.comparing(RealTimeDataVO::getTime).reversed()).collect(Collectors.groupingBy(data -> data.getTime()));
            List<String> timeList;
            if (org.apache.commons.lang3.StringUtils.isNotBlank(statics)) {
                timeList = DateUtils.sliceUpDateRange(startTime, endTime, statics);
            } else {
                timeList = DateUtils.sliceUpDateRange(startTime, endTime, "day");
            }
            //补充默认字段
            if ("6".equals(departType)) {
            } else {
                for (String time : timeList) {
                    if (CollectionUtil.isEmpty(collect.get(time))) {
                        collect.put(time, new ArrayList<>());
                    }
                }
            }
            //排序
            TreeMap<String, Object> treeMap = new TreeMap<>();
            treeMap.putAll(collect);
            result.setResult(treeMap);
            //数据格式组装

            List<String> codeList = Arrays.asList(codeId.split(","));
            collect = res.stream().sorted(Comparator.comparing(RealTimeDataVO::getTime)).collect(Collectors.groupingBy(data -> data.getDictId()));
            List<Object> list = new ArrayList<>();
            Map<String, Object> finalRes = new HashMap<String, Object>() {{
                put("code", codeList);
                put("time", timeList);
                put("data", list);
            }};
            //为空数据的时间段塞值
            //为空数据的时间段塞值
            if (!org.apache.commons.lang3.StringUtils.isEmpty(codeId)) {
                for (String key : codeList) {
                    Map<String, Object> map = Maps.newHashMap();
                    Map<String, RealTimeDataVO> time2ValMap = Maps.newHashMap();
                    map.put("code", key);
                    List<RealTimeDataVO> realTimeDataVOS = collect.getOrDefault(key, new ArrayList<>());
                    for (RealTimeDataVO realTimeDataVO : realTimeDataVOS) {
                        time2ValMap.put(realTimeDataVO.getTime(), realTimeDataVO);
                    }
                    //如果是测压点,十分钟采集的一条数据无序,对应不上切割的时间,不填充数据了

                    for (String time : timeList) {
                        //String format = localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                        RealTimeDataVO realTimeDataVO = time2ValMap.get(time);
                        if (ObjectUtil.isEmpty(realTimeDataVO)) {
                            realTimeDataVO = new RealTimeDataVO();
                            realTimeDataVO.setTime(time);
                            realTimeDataVO.setDictId(key);
                            realTimeDataVO.setPgId(key);
                            realTimeDataVO.setMetricRealName(id2Name.get(key));
                            realTimeDataVO.setPgVal("");
                            realTimeDataVO.setAlarmStatus("0");
                            realTimeDataVOS.add(realTimeDataVO);
                        }
                    }
                    if (org.apache.commons.lang3.StringUtils.isEmpty(order) || order.equals("asc")) {
                        realTimeDataVOS = realTimeDataVOS.stream().sorted(Comparator.comparing(RealTimeDataVO::getTime)).collect(Collectors.toList());
                    } else {
                        realTimeDataVOS = realTimeDataVOS.stream().sorted(Comparator.comparing(RealTimeDataVO::getTime).reversed()).collect(Collectors.toList());
                    }
                    map.put("data", realTimeDataVOS);
                    list.add(map);
                }
            }
            result.setResult(finalRes);
        }

        //实时数据格式
        else {
            res = alarmPgVal(departId, maps, dictGroupData, pattern);
            result.setResult(res);
        }
        return result;

    }

    /**
     * <pre>
     * <请输入描述信息> //工艺段分组,查询工艺段下的指标
     * </pre>
     *
     * @param departId
     * @param tag
     * @author Gao Ran,
     * @Description: TODO(这里描述这个方法的需求变更情况)
     */
    public List<Map<String, Object>> getDictGroup(String departType, String departId, String tag, String
            pgId, String structCode, String groupName) {
        //工艺段分组,查询工艺段下的指标
        QueryWrapper dictGroupQueryWrapper = new QueryWrapper();
        if (!org.apache.commons.lang3.StringUtils.isEmpty(departId)) {
            dictGroupQueryWrapper.in("sd.id", Arrays.asList(departId.split(",")));
        }
        if (!org.apache.commons.lang3.StringUtils.isEmpty(departType)) {
            dictGroupQueryWrapper.in("sd.depart_type", Arrays.asList(departType.split(",")));
        }
        if (!org.apache.commons.lang3.StringUtils.isEmpty(pgId)) {
            dictGroupQueryWrapper.in("smmi.id", Arrays.asList(pgId.split(",")));
        }
        if (!org.apache.commons.lang3.StringUtils.isEmpty(tag)) {
            dictGroupQueryWrapper.in("smmi.metric_uid_tag", Arrays.asList(tag.split(",")));
        }

        if (!org.apache.commons.lang3.StringUtils.isEmpty(structCode)) {
            dictGroupQueryWrapper.in("smmi.struct_code", Arrays.asList(structCode.split(",")));
        }

        if (!org.apache.commons.lang3.StringUtils.isEmpty(groupName)) {
            dictGroupQueryWrapper.in("g.group_name", Arrays.asList(groupName.split(",")));
        }
        List<Map<String, Object>> dictGroupData = screenDataService.getDictGroupData(dictGroupQueryWrapper);
        return dictGroupData;
    }
    private List<RealTimeDataVO> alarmPgVal(String  departId, List<Map<String, Object>> maps, List<Map<String, Object>> dictGroupData, String pattern) {
        List<RealTimeDataVO> res = new ArrayList<>();
        //点id与点信息映射
        Map<String, Map<String, Object>> pgId2Map = Maps.newHashMap();
        for (Map<String, Object> dictGroupDatum : dictGroupData) {
            pgId2Map.put(ConvertUtils.getString(dictGroupDatum.get("id")), dictGroupDatum);
        }
        // Map<String, Map<String, Double>> alarmLimitData = alarmLimitCustomService.riverAlarmAllMap("DBSSW,DBSSL");
        Map<String, Map<String, Map<String, Double>>> riverAlarmMap = alarmLimitCustomService.riverAlarmMap("DBSSIL,DBSSL,DBSWL");
        Map<String, Map<String, Double>> alarmLimitData = alarmLimitCustomService.getAlarmLimitData(departId);


        for (Map<String, Object> realTimeData : maps) {
            //查询所属厂站的报警阈值
            //获取时间
            //String time = DateUtils.formatTime(Long.parseLong(realTimeData.get("time") + "000"));
            NumberFormat numberFormat = NumberFormat.getInstance();
            numberFormat.setMaximumFractionDigits(2);
            String time = DateUtils.format(DateUtils.getDate(Long.parseLong(realTimeData.get("time") + "000")), pattern);
            for (String pgId : realTimeData.keySet()) {
                if ("time".equals(pgId) || pgId.contains("tag")) {
                    continue;
                }
                RealTimeDataVO realTimeDataVO = new RealTimeDataVO();
                String pgVal = ConvertUtils.getString(realTimeData.get(pgId));
                BigDecimal b1 = new BigDecimal((org.apache.commons.lang3.StringUtils.isEmpty(pgVal) ? "0" : pgVal)).setScale(2, BigDecimal.ROUND_HALF_UP);
                double v = b1.doubleValue();
                Map<String, Object> pgId2MapOrDefault = pgId2Map.getOrDefault(pgId, new HashMap<>());
                String depart = ConvertUtils.getString(pgId2MapOrDefault.get("depart_id"));
                String metric_type = ConvertUtils.getString(pgId2MapOrDefault.get("metric_type"));
                String uidTag = ConvertUtils.getString(pgId2MapOrDefault.get("metric_uid_tag"));
                String sort_num = ConvertUtils.getString(pgId2MapOrDefault.get("sort_num"));
                String metricd_name = ConvertUtils.getString(pgId2MapOrDefault.get("metricd_name"));
                String depart_name = ConvertUtils.getString(pgId2MapOrDefault.get("depart_name"));
                String parent_depart_name = ConvertUtils.getString(pgId2MapOrDefault.get("parent_depart_name"));
                String metric_name = ConvertUtils.getString(pgId2MapOrDefault.get("metric_name"));
                String metric_unit = ConvertUtils.getString(pgId2MapOrDefault.get("metric_unit"));
                String groupName = ConvertUtils.getString(pgId2MapOrDefault.get("groupName"));
                String groupType = ConvertUtils.getString(pgId2MapOrDefault.get("groupType"));
                Map<String, Double> limitMap = alarmLimitData.get(depart + "_" + uidTag);
                // Map<String, Double> limitMap = alarmLimitData.get(uidTag);
                //查询报警上下限比较状态
                String alarmValue = "0";
                Double riverAlarm = 0d;
                if (ObjectUtil.isNotEmpty(limitMap)) {
                    alarmValue = alarmLimitCustomService.alarmValue(v, limitMap);

                    if ("SZBOD,SZCOD,SZDDL,SZDO,SZGMSY,SZNH3N,SZPH,SZTN,SZTP".contains(uidTag)) {
                        riverAlarm = alarmLimitCustomService.riverAlarm(riverAlarmMap, uidTag, v);
                    } else {
                        riverAlarm = ConvertUtils.getDouble(alarmLimitCustomService.alarmValueLimit(v, limitMap), 0);
                    }
                    String alarmUpperLimit = ConvertUtils.getString(limitMap.get("alarmUpperLimit"), "");
                    String alarmLowerLimit = ConvertUtils.getString(limitMap.get("alarmLowerLimit"), "");
                    String warnUpperLimit = ConvertUtils.getString(limitMap.get("warnUpperLimit"), "");
                    String warnLowerLimit = ConvertUtils.getString(limitMap.get("warnLowerLimit"), "");
                    realTimeDataVO.setAlarmLimit(alarmLowerLimit + "-" + alarmUpperLimit);
                    realTimeDataVO.setWarnLimit(warnLowerLimit + "-" + warnUpperLimit);
                    realTimeDataVO.setRiverAlarm(ConvertUtils.getString(riverAlarm));
                }
                realTimeDataVO.setDepartId(depart);
                realTimeDataVO.setDepartName(depart_name);
                realTimeDataVO.setParentDepartName(parent_depart_name);
                realTimeDataVO.setTime(time);
                realTimeDataVO.setMetricdName(metricd_name);
                realTimeDataVO.setMetricRealName(metric_name);
                realTimeDataVO.setMetricUnit(metric_unit);
                realTimeDataVO.setGroupType(groupType);
                realTimeDataVO.setGroupName(groupName);
                realTimeDataVO.setAlarmStatus(alarmValue);
                realTimeDataVO.setDictId(uidTag);
                realTimeDataVO.setPgId(pgId);
                realTimeDataVO.setSortNum(sort_num);
                realTimeDataVO.setPgVal(ConvertUtils.getString(b1));
                //判端指标进出水分类
                if (!org.springframework.util.StringUtils.isEmpty(uidTag)) {
                    if (uidTag.contains("JS")) {
                        realTimeDataVO.setWaterType("JS");
                    } else if (uidTag.contains("CS")) {
                        realTimeDataVO.setWaterType("CS");
                    }
                }
//                if ("1".equals(metric_type)||uidTag.contains("YXZT")){
//                    if (0d==v){
//                        realTimeDataVO.setPgVal("开启") ;
//                    }else {
//                        realTimeDataVO.setPgVal("关闭") ;
//                    }
//                }

                if ("YWJZT".equals(uidTag)) {
                    if (0 == v) {
                        realTimeDataVO.setPgVal("正常");
                    } else if (1 == v) {
                        realTimeDataVO.setPgVal("预警");
                    } else if (2 == v) {
                        realTimeDataVO.setPgVal("告警");
                    } else if (3 == v) {
                        realTimeDataVO.setPgVal("溢流");
                    }
                }
                res.add(realTimeDataVO);
            }
        }

        //排序
        res = res.stream().map(data -> {
            if (org.apache.commons.lang3.StringUtils.isEmpty(data.getSortNum())) {
                data.setSortNum("0");
            }
            return data;
        }).sorted(Comparator.comparing(RealTimeDataVO::getMetricRealName)).
                sorted(Comparator.comparingInt(o -> ConvertUtils.getInt(o.getSortNum())))
                .collect(Collectors.toList()
                );
        return res;
    }

    /**
     * <pre>
     * <请输入描述信息> 按厂站分组统计指标数据
     * </pre>
     *
     * @param departType
     * @param res
     * @param departId
     * @author Gao Ran,
     * @Description: TODO(这里描述这个方法的需求变更情况)
     */
    private List<Map<String, Object>> staticsForDepart(String departType, List<RealTimeDataVO> res, String  departId) {
        List<Map<String, Object>> resList = Lists.newArrayList();
        QueryWrapper<Object> queryWrapper = new QueryWrapper<>();

        if (org.apache.commons.lang3.StringUtils.isNotBlank(departType)) {
            queryWrapper.in(org.apache.commons.lang3.StringUtils.isNotBlank(departType), "depart_type", Arrays.asList(departType.split(",")));
        }
        if (org.apache.commons.lang3.StringUtils.isNotBlank(departId)) {
            queryWrapper.in(org.apache.commons.lang3.StringUtils.isNotBlank(departId), "sd.id", Arrays.asList(departId.split(",")));
        }
        queryWrapper.orderByAsc("sd.depart_order");
        //分类统计厂站类型
        List<Map<String, Object>> factoryDesign = screenDataService.factoryDesign(queryWrapper);
        Map<String, List<RealTimeDataVO>> dataListGroup = res.stream().collect(Collectors.groupingBy(realTimeDataVO -> realTimeDataVO.getDepartId()));
        //計算累计流量的差值
        for (Map<String, Object> depart : factoryDesign) {
            Map<String, Object> resMap = new HashMap<>();
            String sysDepartId = ConvertUtils.getString(depart.get("depart_id"));
            String factoryType = ConvertUtils.getString(depart.get("depart_type"));
            String departName = ConvertUtils.getString(depart.get("depart_name"));
            String parent_depart_name = ConvertUtils.getString(depart.get("parent_depart_name"));
            String proLongitude = ConvertUtils.getString(depart.get("pro_longitude"));
            String proLatitude = ConvertUtils.getString(depart.get("pro_latitude"));
            //获取厂站所有的实时数据list
            List<RealTimeDataVO> timeDataVOS = dataListGroup.getOrDefault(sysDepartId, new ArrayList<>());
            String time = DateUtils.getDate("yyyy-MM-dd HH:mm:ss");
            if (CollectionUtil.isNotEmpty(timeDataVOS)) {
                time = timeDataVOS.get(0).getTime();
            }
            //如果alarmCollect的size大于0则有报警
            List<RealTimeDataVO> alarmCollect = timeDataVOS.stream().filter(data -> "2".equals(data.getAlarmStatus())).collect(Collectors.toList());
            List<RealTimeDataVO> warnCollect = timeDataVOS.stream().filter(data -> "1".equals(data.getAlarmStatus())).collect(Collectors.toList());

            String alarmStatus = "0";
            if (!CollectionUtil.isEmpty(alarmCollect)) {
                alarmStatus = "2";
            } else if (!CollectionUtil.isEmpty(warnCollect)) {
                alarmStatus = "1";
            }
            Double riverAlarm = timeDataVOS.stream().mapToDouble(data -> ConvertUtils.getDouble(data.getRiverAlarm(), 0)).summaryStatistics().getMax();
            //排序
            timeDataVOS = timeDataVOS.stream().map(data -> {
                if (org.apache.commons.lang3.StringUtils.isEmpty(data.getSortNum())) {
                    data.setSortNum("0");
                }
                return data;
            }).sorted(Comparator.comparing(RealTimeDataVO::getMetricRealName)).
                    sorted(Comparator.comparingInt(o -> ConvertUtils.getInt(o.getSortNum())))
                    .collect(Collectors.toList()
                    );
            resMap.put("departId", sysDepartId);
            resMap.put("departName", departName);
            resMap.put("parentDepartName", parent_depart_name);
            resMap.put("departType", factoryType);
            resMap.put("marsLatitude", proLatitude);
            resMap.put("marsLongitude", proLongitude);
            resMap.put("dataVOS", timeDataVOS);
            resMap.put("time", time);
            resMap.put("riverAlarm", riverAlarm);
            resMap.put("alarmStatus", alarmStatus);
            resList.add(resMap);
        }
        return resList;
    }

    @AutoLog(value = "设备相关组件")
    @ApiOperation(value = "设备相关组件", notes = "设备相关组件")
    @PostMapping(value = "/getEquipData")
    public Result<Map<String, Object>> getEquipData(@RequestBody StatisticsParams statisticsParams) {
        Result<Map<String, Object>> result = new Result<>();
        Map<String, Object> map = screenDataService.getEquipData(statisticsParams);
        result.setResult(map);
        return result;
    }

    @AutoLog(value = "招采组件")
    @ApiOperation(value = "招采组件", notes = "招采组件")
    @PostMapping(value = "/getErpData")
    public Result<Map<String, Object>> getErpData(@RequestBody StatisticsParams statisticsParams) {
        Result<Map<String, Object>> result = new Result<>();
        Map<String, Object> map = screenDataService.getErpData(statisticsParams);
        result.setResult(map);
        return result;
    }
}