package com.iailab.module.data.indexdata.common;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.iailab.dto.*;
import com.iailab.module.data.common.enums.CommonConstant;
import com.iailab.api.IFeignProddispApi;
import com.iailab.framework.common.util.date.DateUtils;
import com.iailab.module.data.point.dto.DaPointDTO;
import com.iailab.module.data.point.service.DaPointService;
import com.iailab.module.data.indexdata.entity.IndexDataItemEntity;
import com.iailab.module.data.indexdata.entity.IndexDataValueEntity;
import com.iailab.module.data.indexdata.service.IndexDataItemService;
import com.iailab.module.data.indexdata.service.IndexDataValueService;
import com.iailab.module.data.influxdb.pojo.InfluxPointValuePOJO;
import com.iailab.module.data.influxdb.service.InfluxDBService;
import com.iailab.module.infra.api.config.ConfigApi;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.LocalDate;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author PanZhibao
 * @Description
 * @createTime 2022年09月11日 14:11:00
 */
@Slf4j
@Component
public class IndexDataUtils {

    private BigDecimal hourMins = new BigDecimal("60");

    private String DATA_TYPE_BOOLEAN = "boolean";

    private final int granularity = 5;

    @Resource
    private InfluxDBService influxDBService;

    @Resource
    private IndexDataValueService indexDataValueService;

    @Resource
    private IFeignProddispApi feignProddispApi;

    @Resource
    private ConfigApi configApi;

    @Resource
    private DaPointService daPointService;

    @Resource
    private IndexDataItemService indexDataItemService;

    public void doCal(Date startTime, Date endTime, String CLOCK_CODE, String DICT_DC) throws Exception {
        log.info("startTime=" + DateUtils.format(startTime, DateUtils.FORMAT_YEAR_MONTH_DAY));
        log.info("endTime=" + DateUtils.format(endTime, DateUtils.FORMAT_YEAR_MONTH_DAY));
        // 获取数据项
        List<IndexDataItemEntity> indexDataItemList = indexDataItemService.getListByClockConfig(CLOCK_CODE);
        if (CollectionUtils.isEmpty(indexDataItemList)) {
            log.warn("indexDataItemEntityList为空， clockCode=" + CLOCK_CODE);
            throw new Exception("indexDataItemEntityList为空， clockCode=" + CLOCK_CODE);
        }
        indexDataItemList.forEach(dataItem -> {
            switch (dataItem.getItemType()) {
                case IndexDataConstant.RUN_TIME:
                    // 运行时长
                    this.createRunTime(CLOCK_CODE, dataItem, "all" ,startTime, endTime);
                    break;
                case IndexDataConstant.RUN_TIME_ZC:
                    // 运行时长正常
                    this.createRunTime(CLOCK_CODE, dataItem, "zc",startTime, endTime);
                    break;
                case IndexDataConstant.RUN_TIME_KZ:
                    // 运行时长空载
                    this.createRunTime(CLOCK_CODE, dataItem, "kz",startTime, endTime);
                    break;
                case IndexDataConstant.POWER_CONSUME:
                    // 电耗
                    this.createPowerConsume(CLOCK_CODE, dataItem, startTime, endTime);
                    break;
                case IndexDataConstant.WASH_TRANSFER_IN:
                    // 调入量
                    this.createWashTransferIn(CLOCK_CODE, dataItem, startTime, endTime);
                    break;
                case IndexDataConstant.WASH_TO_WASH:
                    // 入洗量
                    this.createWashToWash(CLOCK_CODE, dataItem, startTime, endTime);
                    break;
                case IndexDataConstant.WASH_PROD_VOLUME:
                    // 生产量
                    this.createWashProdVolume(CLOCK_CODE, dataItem, startTime, endTime);
                    break;
                case IndexDataConstant.WAREHOUSE_POSITION:
                    // 仓位
                    this.createWarehousePosition(CLOCK_CODE, dataItem, startTime, endTime);
                    break;
                default:
                    break;
            }
        });

        // 统计库存
        this.createWarehouseStock(DateUtils.format(startTime), DICT_DC);

        // 统计总电量
        FeignConsumeTargetDTO dto = new FeignConsumeTargetDTO();
        Map param = new HashMap();
        param.put("rq",new LocalDate());
        param.put("bc",DICT_DC);
        BigDecimal hdl = feignProddispApi.sumData(param);
        dto.setRq(DateUtils.format(startTime));
        dto.setBc(DICT_DC);
        dto.setXhzb("hdl");
        dto.setDw("kw.h");
        dto.setNbdrl(hdl);
        dto.setNbtzl(new BigDecimal(0));
        dto.setWbdrl(new BigDecimal(0));
        dto.setWbtzl(new BigDecimal(0));
        dto.setCjr(CommonConstant.CJS_SYS);
        dto.setCjsj(new Date());
        dto.setXgsj(new Date());
        feignProddispApi.createConsumeTarget(dto);

    }

    public void doHourVolume(Date startTime, Date endTime, String CLOCK_CODE, String DICT_DC) throws Exception {
        log.info("startTime=" + DateUtils.format(startTime, DateUtils.FORMAT_YEAR_MONTH_DAY));
        log.info("endTime=" + DateUtils.format(endTime, DateUtils.FORMAT_YEAR_MONTH_DAY));
        // 获取数据项
        List<IndexDataItemEntity> indexDataItemList = indexDataItemService.getListByClockConfig(CLOCK_CODE);
        if (CollectionUtils.isEmpty(indexDataItemList)) {
            log.warn("indexDataItemEntityList为空， clockCode=" + CLOCK_CODE);
            throw new Exception("indexDataItemEntityList为空， clockCode=" + CLOCK_CODE);
        }
        indexDataItemList.forEach(dataItem -> {this.createHourVolume(CLOCK_CODE, dataItem, startTime, endTime);});

    }
    public void createRunTime(String clockCode, IndexDataItemEntity dataItem, String runTimeType,Date startTime, Date endTime) {
        try{
            log.info("计算运行时长开始，itemCode=" + dataItem.getPointCode());
            InfluxPointValuePOJO pojo = new InfluxPointValuePOJO();
            pojo.setPoint(dataItem.getPointCode());
            pojo.setType(DATA_TYPE_BOOLEAN);
            List<Map<String, Object>> pointData = influxDBService.queryPointValues(pojo, startTime, endTime);
            if (CollectionUtils.isEmpty(pointData)) {
                log.warn("历史值为空，PointCode=" + dataItem.getPointCode());
                return;
            }
            int mins = this.getRunMins(pointData);
            int times = this.getStartUpTimes(pointData);

            Map<String, BigDecimal> valueMap = new HashMap<>(2);
            valueMap.put("sumValue", new BigDecimal(mins));
            valueMap.put("startUpTimes", new BigDecimal(times));
            IndexDataValueEntity indexDataValue = this.buildIndexDataValueEntity(dataItem, clockCode, valueMap);
            indexDataValueService.add(indexDataValue);

            FeignRunTimeDTO dto = new FeignRunTimeDTO();
            dto.setRq(DateUtils.format(startTime));
            dto.setBc(dataItem.getBc());
            dto.setScxm(dataItem.getXtCode());
            dto.setRunTimeType(runTimeType);
            dto.setXss(Long.valueOf((mins / 60)));
            dto.setFzs(Long.valueOf((mins % 60)));
            dto.setZsc(Long.valueOf(mins));
            dto.setCjr(CommonConstant.CJS_SYS);
            dto.setCjsj(new Date());
            dto.setXgsj(new Date());
            feignProddispApi.createRunTime(dto);
            log.info("计算运行时长结束，itemCode=" + dataItem.getPointCode());
        } catch (Exception ex) {
            log.info("计算运行时长异常，itemCode=" + dataItem.getPointCode());
            ex.printStackTrace();
        }
    }

    public void createConsumeTarget(String clockCode, IndexDataItemEntity dataItem, Date startTime, Date endTime) {
        try{
            log.info("计算消耗指标开始，itemCode=" + dataItem.getPointCode());

            // 插入指标数据表
            Map<String, BigDecimal> valueMap = new HashMap<>(2);
            valueMap.put("sumValue", new BigDecimal(0));
            IndexDataValueEntity indexDataValue = this.buildIndexDataValueEntity(dataItem, clockCode, valueMap);
            indexDataValueService.add(indexDataValue);

            FeignConsumeTargetDTO dto = new FeignConsumeTargetDTO();
            dto.setRq(DateUtils.format(startTime));
            dto.setBc(dataItem.getBc());
            dto.setXhzb(dataItem.getExt1());
            dto.setDw(dataItem.getUnit());
            dto.setNbdrl(new BigDecimal(0));
            dto.setNbtzl(new BigDecimal(0));
            dto.setWbdrl(new BigDecimal(0));
            dto.setWbtzl(new BigDecimal(0));
            dto.setCjr(CommonConstant.CJS_SYS);
            dto.setCjsj(new Date());
            dto.setXgsj(new Date());
            feignProddispApi.createConsumeTarget(dto);
            log.info("计算消耗指标结束，itemCode=" + dataItem.getPointCode());
        } catch (Exception ex) {
            log.info("计算消耗指标异常，itemCode=" + dataItem.getPointCode());
            ex.printStackTrace();
        }
    }

    public void createPowerConsume(String clockCode, IndexDataItemEntity dataItem, Date startTime, Date endTime) {
        try{
            DaPointDTO daPoint = daPointService.getByNo(dataItem.getPointCode());

            if (daPoint == null) {
                log.info("daPoint is null");
                return;
            }
            InfluxPointValuePOJO pojo = new InfluxPointValuePOJO();
            pojo.setPoint(daPoint.getPointNo());
            pojo.setType(daPoint.getPointType());
            // 取10min内最大值
            Object startPointValue = influxDBService.queryPointMaxValue(pojo, new Date(startTime.getTime() - 1000 * 60 * 10));
            Object endPointValue = influxDBService.queryPointMaxValue(pojo, new Date(endTime.getTime() - 1000 * 60 * 10));
            BigDecimal startValue = startPointValue == null ? BigDecimal.ZERO : new BigDecimal(startPointValue.toString());
            BigDecimal endValue = endPointValue == null ? BigDecimal.ZERO : new BigDecimal(endPointValue.toString());
            BigDecimal value = new BigDecimal(0);
            if(endValue.compareTo(startValue) == 1){
                value = endValue.subtract(startValue);
            }
            // 插入指标数据表
            Map<String, BigDecimal> valueMap = new HashMap<>(1);
            valueMap.put("sumValue", value);
            IndexDataValueEntity indexDataValue = this.buildIndexDataValueEntity(dataItem, clockCode, valueMap);
            indexDataValueService.add(indexDataValue);

            String xt = configApi.queryConfigByCode(dataItem.getExt1());
            // 插入统计表
            FeignPowerConsumeDTO dto = new FeignPowerConsumeDTO();
            dto.setRq(DateUtils.format(startTime));
            dto.setBc(dataItem.getBc());
            dto.setXt(xt);
            dto.setNbdrl(value);
            dto.setNbtzl(new BigDecimal(0));
            dto.setWbdrl(value);
            dto.setWbtzl(new BigDecimal(0));
            dto.setCjr(CommonConstant.CJS_SYS);
            dto.setCjsj(new Date());
            dto.setXgsj(new Date());
            feignProddispApi.createPowerConsume(dto);
            log.info("计算电耗结束，itemCode=" + dataItem.getPointCode());
        } catch (Exception ex) {
            log.info("计算电耗异常，itemCode=" + dataItem.getPointCode());
            ex.printStackTrace();
        }
    }
    public void createHourVolume(String clockCode, IndexDataItemEntity dataItem, Date startTime, Date endTime) {
        try{
            /**
             * 861 精煤
             * 862 混煤
             * 903 矸石
             * 603ABC 煤泥板数
             */
            log.info("计算小时量开始，itemCode=" + dataItem.getPointCode());
            List<String> pointNos = new ArrayList<>();
            pointNos.add(dataItem.getPointCode());
            if(StringUtils.isNotBlank(dataItem.getExt1())) {
                pointNos.add(dataItem.getExt1());
            }
            if(StringUtils.isNotBlank(dataItem.getExt2())) {
                pointNos.add(dataItem.getExt2());
            }
            if(StringUtils.isNotBlank(dataItem.getExt3())) {
                pointNos.add(dataItem.getExt3());
            }
            if(StringUtils.isNotBlank(dataItem.getExt4())) {
                pointNos.add(dataItem.getExt4());
            }
            if(StringUtils.isNotBlank(dataItem.getExt5())) {
                pointNos.add(dataItem.getExt5());
            }
            List<DaPointDTO> pointList = daPointService.getByNos(pointNos);
            if (CollectionUtils.isEmpty(pointList)) {
                log.warn("pointNos查询为空！");
                return;
            }
            List<InfluxPointValuePOJO> influxParams = pointList.stream().map(item -> {
                InfluxPointValuePOJO pojo = new InfluxPointValuePOJO();
                pojo.setPoint(item.getPointNo());
                pojo.setType(item.getDataType());
                return pojo;
            }).collect(Collectors.toList());
            Map<String, Object> data = influxDBService.queryPointsSpread(influxParams, startTime, endTime);
            log.info("查询完成！");

            log.info("插入统计表");
            FeignHourVolumeDTO dto = new FeignHourVolumeDTO();
            dto.setRq(DateUtils.format(startTime));
            dto.setBc(this.getBcByTime(endTime));
            dto.setSj(endTime);
            if (StringUtils.isNotBlank(dataItem.getPointCode()) && data.get(dataItem.getPointCode()) != null) {
                dto.setRxl(new BigDecimal(data.get(dataItem.getPointCode()).toString()));
                log.info(" 插入指标数据表");
                Map<String, BigDecimal> valueMap = new HashMap<>(1);
                valueMap.put("sumValue", new BigDecimal(data.get(dataItem.getPointCode()).toString()));
                IndexDataValueEntity indexDataValue = this.buildIndexDataValueEntity(dataItem, clockCode, valueMap);
                indexDataValueService.add(indexDataValue);
            }
            if (StringUtils.isNotBlank(dataItem.getExt1()) && data.get(dataItem.getExt1()) != null) {
                dto.setJml(new BigDecimal(data.get(dataItem.getExt1()).toString()));
            }
            if (StringUtils.isNotBlank(dataItem.getExt2()) && data.get(dataItem.getExt2()) != null) {
                dto.setHml(new BigDecimal(data.get(dataItem.getExt2()).toString()));
            }
            if (StringUtils.isNotBlank(dataItem.getExt3()) && data.get(dataItem.getExt3()) != null) {
                dto.setGsl(new BigDecimal(data.get(dataItem.getExt3()).toString()));
            }
            if (StringUtils.isNotBlank(dataItem.getExt4()) && data.get(dataItem.getExt4()) != null) {
                dto.setFjbs(new BigDecimal(data.get(dataItem.getExt4()).toString()));
            }
            if (StringUtils.isNotBlank(dataItem.getExt5()) && data.get(dataItem.getExt5()) != null) {
                dto.setMnbs(new BigDecimal(data.get(dataItem.getExt5()).toString()));
            }
            dto.setCjr(CommonConstant.CJS_SYS);
            dto.setCjsj(new Date());
            dto.setXgsj(new Date());
            feignProddispApi.createHourVolume(dto);
            log.info("计算小时量结束，itemCode=" + dataItem.getPointCode());
        } catch (Exception ex) {
            log.info("计算小时量异常，itemCode=" + dataItem.getPointCode());
            ex.printStackTrace();
        }
    }


    private String getBcByTime(Date dateTime) {
        String bc = "bb";
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(dateTime);
        if (calendar.get(Calendar.HOUR_OF_DAY) >= 21 || calendar.get(Calendar.HOUR_OF_DAY) <= 8) {
            bc = "yb";
        }
        return bc;
    }

    public void createWashTransferIn(String clockCode, IndexDataItemEntity dataItem, Date startTime, Date endTime) {
        try{
            log.info("计算调入量开始，itemCode=" + dataItem.getPointCode());
            // 查询测点里的累计产量
            DaPointDTO daPoint = daPointService.getByNo(dataItem.getPointCode());

            if (daPoint == null) {
                log.info("daPoint is null");
                return;
            }
            InfluxPointValuePOJO pojo = new InfluxPointValuePOJO();
            pojo.setPoint(daPoint.getPointNo());
            pojo.setType(daPoint.getDataType());
            // 取10min内最大值
            Object pointValue = influxDBService.queryPointMaxValue(pojo, new Date(endTime.getTime() - 1000 * 60 * 10));
            BigDecimal sumValue = pointValue == null ? BigDecimal.ZERO : new BigDecimal(pointValue.toString());

            // 插入指标数据表
            Map<String, BigDecimal> valueMap = new HashMap<>(1);
            valueMap.put("sumValue", sumValue);
            IndexDataValueEntity indexDataValue = this.buildIndexDataValueEntity(dataItem, clockCode, valueMap);
            indexDataValueService.add(indexDataValue);

            String mz = configApi.queryConfigByCode(dataItem.getExt1());
            // 插入统计表
            FeignWashTransferInDTO dto = new FeignWashTransferInDTO();
            dto.setRq(DateUtils.format(startTime));
            dto.setBc(dataItem.getBc());
            dto.setDrly(mz);
            dto.setNbdrl(sumValue);
            dto.setNbtzl(new BigDecimal(0));
            dto.setWbdrl(sumValue);
            dto.setWbtzl(new BigDecimal(0));
            dto.setCjr(CommonConstant.CJS_SYS);
            dto.setCjsj(new Date());
            dto.setXgsj(new Date());
            feignProddispApi.createWashTransferIn(dto);
            log.info("计算调入量结束，itemCode=" + dataItem.getPointCode());
        } catch (Exception ex) {
            log.info("计算调入量异常，itemCode=" + dataItem.getPointCode());
            ex.printStackTrace();
        }
    }

    public void createWashToWash(String clockCode, IndexDataItemEntity dataItem, Date startTime, Date endTime) {
        try{
            log.info("计算入洗量开始，itemCode=" + dataItem.getPointCode());
            // 查询测点里的累计产量
            DaPointDTO daPoint = daPointService.getByNo(dataItem.getPointCode());
            if (daPoint == null) {
                log.info("daPoint is null");
                return;
            }
            InfluxPointValuePOJO pojo = new InfluxPointValuePOJO();
            pojo.setPoint(daPoint.getPointNo());
            pojo.setType(daPoint.getDataType());
            // 取10min内最大值
            Object pointValue = influxDBService.queryPointMaxValue(pojo, new Date(endTime.getTime() - 1000 * 60 * 10));
            BigDecimal sumValue = pointValue == null ? BigDecimal.ZERO : new BigDecimal(pointValue.toString());
            log.info("插入指标数据表");
            Map<String, BigDecimal> valueMap = new HashMap<>(1);
            log.info("sumValue"+sumValue);
            valueMap.put("sumValue", sumValue);
            IndexDataValueEntity indexDataValue = this.buildIndexDataValueEntity(dataItem, clockCode, valueMap);
            indexDataValueService.add(indexDataValue);
            List<FeignMcMzDTO> mzList = feignProddispApi.selectMcMzByMc(dataItem.getExt1());
            log.info("dataItem.getExt1()"+dataItem.getExt1());

            //获取总入洗量
            pojo.setPoint(dataItem.getExt2());
            pojo.setType("float");
            Object rxlPointValue = influxDBService.queryPointMaxValue(pojo, new Date(endTime.getTime() - 1000 * 60 * 10));
            BigDecimal sumRXL = rxlPointValue == null ? BigDecimal.ZERO : new BigDecimal(rxlPointValue.toString());

            mzList.stream().forEach(
                    mz->{
                        log.info("插入统计表,mc:"+mz.getMc()+";mz:"+mz.getMz());
                        FeignWashToWashDTO dto = new FeignWashToWashDTO();
                        dto.setRq(DateUtils.format(startTime));
                        dto.setBc(dataItem.getBc());
                        dto.setXxjm(mz.getMz());
                        dto.setNbdrl(sumValue.multiply(BigDecimal.valueOf(mz.getProportion())).divide(BigDecimal.valueOf(mz.getDen())) );
                        dto.setRxbl(dto.getNbdrl().divide(sumRXL, 2, RoundingMode.HALF_UP));
                        dto.setRxly(dataItem.getExt1());
                        dto.setNbtzl(new BigDecimal(0));
                        dto.setWbdrl(dto.getNbdrl());
                        dto.setWbtzl(new BigDecimal(0));
                        dto.setCjr(CommonConstant.CJS_SYS);
                        dto.setCjsj(new Date());
                        dto.setXgsj(new Date());
                        feignProddispApi.createWashToWash(dto);
                    }
            );


            log.info("计算入洗量结束，itemCode=" + dataItem.getPointCode());
        } catch (Exception ex) {
            log.info("计算入洗量异常，itemCode=" + dataItem.getPointCode());
            ex.printStackTrace();
        }
    }

    public void createWashProdVolume(String clockCode, IndexDataItemEntity dataItem, Date startTime, Date endTime) {
        try{
            log.info("计算生产量开始，itemCode=" + dataItem.getPointCode());
            // 查询测点里的累计产量
            DaPointDTO daPoint = daPointService.getByNo(dataItem.getPointCode());
            if (daPoint == null) {
                log.info("daPoint is null");
                return;
            }
            InfluxPointValuePOJO pojo = new InfluxPointValuePOJO();
            pojo.setPoint(daPoint.getPointNo());
            pojo.setType(daPoint.getDataType());
            // 取10min内最大值
            Object pointValue = influxDBService.queryPointMaxValue(pojo, new Date(endTime.getTime() - 1000 * 60 * 10));
            BigDecimal sumValue = pointValue == null ? BigDecimal.ZERO : new BigDecimal(pointValue.toString());

            log.info("插入指标数据表");
            Map<String, BigDecimal> valueMap = new HashMap<>(1);
            valueMap.put("sumValue", sumValue);
            IndexDataValueEntity indexDataValue = this.buildIndexDataValueEntity(dataItem, clockCode, valueMap);
            indexDataValueService.add(indexDataValue);

            log.info("插入统计表");
            FeignWashProdVolumeDTO dto = new FeignWashProdVolumeDTO();
            dto.setRq(DateUtils.format(startTime));
            dto.setBc(dataItem.getBc());
            dto.setClmz(dataItem.getExt1());
            dto.setNbdrl(sumValue);
            dto.setNbtzl(new BigDecimal(0));
            dto.setWbdrl(sumValue);
            dto.setWbtzl(new BigDecimal(0));
            dto.setCjr(CommonConstant.CJS_SYS);
            dto.setCjsj(new Date());
            dto.setXgsj(new Date());
            feignProddispApi.createWashProdVolume(dto);
            log.info("计算生产量结束，itemCode=" + dataItem.getPointCode());
        } catch (Exception ex) {
            log.info("计算生产量异常，itemCode=" + dataItem.getPointCode());
            ex.printStackTrace();
        }
    }

    public void createWarehousePosition(String clockCode, IndexDataItemEntity dataItem, Date startTime, Date endTime) {
        try{
            log.info("计算仓位开始，itemCode=" + dataItem.getPointCode());
            DaPointDTO daPoint = daPointService.getByNo(dataItem.getPointCode());
            if (daPoint == null) {
                log.info("daPoint is null");
                return;
            }
            InfluxPointValuePOJO pojo = new InfluxPointValuePOJO();
            pojo.setPoint(daPoint.getPointNo());
            pojo.setType(daPoint.getDataType());
            List<Map<String, Object>> pointValues = influxDBService.queryPointValues(pojo, new Date(endTime.getTime() - 1000 * 30), endTime);
            String point = JSON.toJSONString(pointValues);
            log.info("pointValues ："+point);
            if (CollectionUtils.isEmpty(pointValues)) {
                log.info("pointValues is null");
                return;
            }

            Map<String, Object> pointValue = pointValues.get(pointValues.size() - 1);
            JSONObject json = new JSONObject(pointValue);
            log.info("插入指标数据表:"+json);
            Map<String, BigDecimal> valueMap = new HashMap<>(1);
            BigDecimal sumValue =  new BigDecimal(pointValue.get("value").toString());
            valueMap.put("sumValue",sumValue);
            IndexDataValueEntity indexDataValue = this.buildIndexDataValueEntity(dataItem, clockCode, valueMap);
            indexDataValueService.add(indexDataValue);
            log.info("mc:"+dataItem.getExt1());
            FeignWarehouseItemDTO warehouseItem = feignProddispApi.selectWarehouseItemByMc(dataItem.getExt1());
            log.info("插入仓位统计表开始");
            FeignWarehousePositionDTO dto = new FeignWarehousePositionDTO();
            dto.setRq(DateUtils.format(startTime));
            dto.setBc(dataItem.getBc());
            dto.setMc(dataItem.getExt1());
            dto.setMclx(dataItem.getExt2());
            log.info(Integer.toString(warehouseItem.getCapacity()));
            dto.setCrl(Integer.toString(warehouseItem.getCapacity()));
            BigDecimal dqcc = sumValue.multiply(new BigDecimal(dto.getCrl())).divide(new BigDecimal(100), 1, BigDecimal.ROUND_HALF_UP);
            dto.setNbgl(dqcc);
            dto.setWbgl(dqcc);
            dto.setCjr(CommonConstant.CJS_SYS);
            dto.setCjsj(new Date());
            dto.setXgsj(new Date());
            feignProddispApi.createWarehousePosition(dto);
            log.info("计算仓位结束，itemCode=" + dataItem.getPointCode());
        } catch (Exception ex) {
            log.info("计算仓位异常，itemCode=" + dataItem.getPointCode());
            ex.printStackTrace();
        }
    }

    public void createWarehouseStock(String rq, String bc) {
        try{
            log.info("计算库存开始，rq=" + rq);

            Map<String, Object> params = new HashMap<>();
            params.put("rq", rq);
            params.put("bc", bc);
            List<FeignWarehousePositionDTO> list = feignProddispApi.selectWarehouseGroupByCp(params);
            list.forEach(item -> {
                log.info("遍历" + item.getMc()+"煤仓煤种");
                List<FeignMcMzDTO> mzList = feignProddispApi.selectMcMzByMc(item.getMc());
                mzList.stream().forEach(
                        mz->{
                            log.info("插入" + mz.getMz()+"库存");
                            FeignWarehouseStockDTO dto = new FeignWarehouseStockDTO();
                            dto.setRq(rq);
                            dto.setBc(bc);
                            dto.setLsh(new SimpleDateFormat("yyyyMMddhhmmssSSS").format(new Date()));
                            dto.setBs(item.getMclx());
                            dto.setKcmz(mz.getMz());
                            dto.setNbzrkc(new BigDecimal(0));
                            dto.setNbjrrk(new BigDecimal(0));
                            log.info(mz.getProportion().toString());
                            log.info(mz.getDen().toString());
                            BigDecimal math = item.getNbgl().multiply(BigDecimal.valueOf(mz.getProportion()).divide(BigDecimal.valueOf(mz.getDen())));
                            BigDecimal nbjrkc = math.setScale(2, RoundingMode.HALF_UP);
                            dto.setNbjrkc(nbjrkc);
                            dto.setNbtzl(new BigDecimal(0));
                            dto.setWbzrkc(new BigDecimal(0));
                            dto.setWbjrrk(new BigDecimal(0));
                            dto.setWbjrkc(dto.getNbjrkc());
                            dto.setWbtzl(new BigDecimal(0));
                            dto.setCjr(CommonConstant.CJS_SYS);
                            dto.setCjsj(new Date());
                            dto.setXgsj(new Date());
                            feignProddispApi.createWarehouseStock(dto);
                        }
                );
            });
            log.info("计算库存结束，rq=" + rq);
        } catch (Exception ex) {
            log.info("计算库存异常，rq=" + rq);
            ex.printStackTrace();
        }
    }

    public int getRunMins(List<Map<String, Object>> pointData) {
        int seconds = 0;
        for (Map<String, Object> item:
                pointData) {
            if (Boolean.parseBoolean(item.get("value").toString())) {
                seconds = seconds + granularity;
            }
        }
        return (seconds / 60);
    }

    /**
     * getAvgOutput
     *
     * @param indexDataItemEntity
     * @param output
     * @param hours
     * @return
     */
    public BigDecimal getAvgOutput(IndexDataItemEntity indexDataItemEntity, BigDecimal output, BigDecimal hours) {
        BigDecimal result = BigDecimal.ZERO;
        if (hours.compareTo(BigDecimal.ZERO) > 0) {
            result = output.divide(hours, 0, BigDecimal.ROUND_HALF_UP);
        }
        return result;
    }

    /**
     * buildIndexDataValueEntity
     *
     * @param indexDataItemEntity
     * @param clock
     * @param valueMap
     * @return
     */
    public IndexDataValueEntity buildIndexDataValueEntity(IndexDataItemEntity indexDataItemEntity, String clock,
                                                          Map<String, BigDecimal> valueMap) {
        IndexDataValueEntity entity = new IndexDataValueEntity();
        entity.setId(UUID.randomUUID().toString().replace("-",""));
        entity.setConfigId(indexDataItemEntity.getId());
        entity.setUnit2(indexDataItemEntity.getUnit2());
        entity.setSsdw(indexDataItemEntity.getSsdw());
        entity.setItemCode(indexDataItemEntity.getItemCode());
        entity.setItemName(indexDataItemEntity.getItemName());
        entity.setUnit(indexDataItemEntity.getUnit());
        entity.setClock(clock);
        entity.setSumValue(valueMap.get("sumValue"));
        entity.setAvgValue(valueMap.get("avgValue"));
        entity.setReportValue(valueMap.get("reportValue"));
        entity.setReportHourValue(valueMap.get("reportHourValue"));
        entity.setCollectValue(valueMap.get("collectValue"));
        entity.setCollectHourValue(valueMap.get("collectHourValue"));
        entity.setStartUpTimes(valueMap.get("startUpTimes"));
        entity.setCreateTime(new Date());
        return entity;
    }

    /**
     * getAvgValue
     *
     * @param dataMap
     * @return
     */
    public BigDecimal getAvgValue (LinkedHashMap<String, BigDecimal> dataMap) {
        BigDecimal avgValue = BigDecimal.ZERO;
        double sumValue = 0d;
        if (!CollectionUtils.isEmpty(dataMap)) {
            int size = dataMap.size();
            for (Map.Entry<String, BigDecimal> item : dataMap.entrySet()) {
                if (item.getValue() != null && item.getValue().compareTo(BigDecimal.ZERO) > 0) {
                    sumValue = sumValue + item.getValue().doubleValue();
                }
            }
            avgValue = new BigDecimal(sumValue).divide(new BigDecimal(size), 2, BigDecimal.ROUND_HALF_UP);
        }
        return avgValue;
    }

    /**
     * getRunHours
     *
     * @param dataMap
     * @return
     */
    public BigDecimal getRunHours (LinkedHashMap<String, BigDecimal> dataMap) {
        BigDecimal result = BigDecimal.ZERO;
        if (!CollectionUtils.isEmpty(dataMap)) {
            int mins = 0;
            for (Map.Entry<String, BigDecimal> item : dataMap.entrySet()) {
                if (item.getValue() != null && item.getValue().compareTo(BigDecimal.ZERO) > 0) {
                    mins++;
                }
            }
            result = new BigDecimal(mins).divide(hourMins, 2, BigDecimal.ROUND_HALF_UP);
        }
        return result;
    }

    /**
     * getStartUpTimes
     *
     * @param pointData
     * @return
     */
    public int getStartUpTimes (List<Map<String, Object>> pointData) {
        int times = 0;
        Boolean lastValue = Boolean.FALSE;
        for (Map<String, Object> item:
                pointData) {
            Boolean itemValue = Boolean.parseBoolean(item.get("value").toString());
            if (itemValue.compareTo(lastValue) != 0) {
                times++;
            }
            lastValue = itemValue;
        }
        return times;
    }

    /**
     * 完善数据
     *
     * @param length
     * @param sourceDataMap
     * @param startTime
     * @param endTime
     * @return
     */
    public LinkedHashMap<String, BigDecimal> completionData(int length, LinkedHashMap<String, BigDecimal> sourceDataMap, Date startTime, Date endTime) {
        if (CollectionUtils.isEmpty(sourceDataMap) || length <= sourceDataMap.size()) {
            return sourceDataMap;
        }
        log.info("补全数据, length =" + length + "; size = " + sourceDataMap.size() + "; startTime = " + startTime.getTime() + "; endTime = " + endTime.getTime());

        //找出缺少项
        long oneMin = 1000 * 60;
        long start = startTime.getTime();
        long end = endTime.getTime();
        long mins = ((end - start) / oneMin);
        LinkedHashMap<String, BigDecimal> dataMap = new LinkedHashMap<>();
        for (int i = 0; i < mins; i ++) {
            String key = DateUtils.format(new Date(start + oneMin * i), "");
            dataMap.put(key, sourceDataMap.get(key));
        }

        //补充缺少项
        int k = 0;
        Map.Entry<String, BigDecimal> lastItem = null;
        for (Map.Entry<String, BigDecimal> item : dataMap.entrySet()) {
            if (k == 0 && item.getValue() == null) {
                item.setValue(getFirstValue(dataMap));
            } else if (item.getValue() == null) {
                item.setValue(lastItem.getValue());
            }
            k ++;
            lastItem = item;
        }
        log.info("补全完成");
        return dataMap;
    }

    /**
     * getFirstValue
     *
     * @param dataMap
     * @return
     */
    private BigDecimal getFirstValue(LinkedHashMap<String, BigDecimal> dataMap) {
        for (Map.Entry<String, BigDecimal> item : dataMap.entrySet()) {
            if (item.getValue() != null) {
                return item.getValue();
            }
        }
        return null;
    }
}