gunshi-project-ss/src/main/java/com/gunshi/project/ss/service/WaterCountAnalysisService.java

package com.gunshi.project.ss.service;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.gunshi.db.dto.DateRangeSo;
import com.gunshi.project.ss.common.model.StRsvrR;
import com.gunshi.project.ss.entity.vo.WaterAnalysisVo;
import com.gunshi.project.ss.entity.vo.WaterCapacityAnalysisVo;
import com.gunshi.project.ss.model.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
@Transactional(rollbackFor = Exception.class)
public class WaterCountAnalysisService {

    @Autowired
    private XlPlanService xlPlanService;//兴利计划

    @Autowired
    private StWaterRReorganizeService stWaterRReorganizeService;//供水量整编

    @Autowired
    private WaterDispatchService waterDispatchService;//水量调度

    @Autowired
    private StZvarlBService stZvarlBService;//水位-库容

    @Autowired
    private StRsvrRService stRsvrRService;//水库历史水位

    @Autowired
    private AttResBaseService attResBaseService;


    public List<WaterAnalysisVo> waterSupplyAnalysis(Serializable id) {
        XlPlan byId = xlPlanService.getById(id);
        List<WaterAnalysisVo> res = new ArrayList<>();
        WaterAnalysisVo waterAnalysisGGVo = new WaterAnalysisVo();
        waterAnalysisGGVo.setType(0);
        WaterAnalysisVo waterAnalysisSTVo = new WaterAnalysisVo();
        waterAnalysisSTVo.setType(1);
        res.add(waterAnalysisGGVo);
        res.add(waterAnalysisSTVo);
        //判断该兴利计划是年度月度
        if(byId == null){
            throw new IllegalArgumentException("对不起，该计划不存在");
        }
        //如果是月度
        //计划灌溉供水量
        BigDecimal ggWater = byId.getGgWater();
        waterAnalysisGGVo.setPlanSupply(ggWater);
        //计划生态供水量
        BigDecimal stWater = byId.getStWater();
        waterAnalysisSTVo.setPlanSupply(stWater);
        Map<String,BigDecimal> map;
        if(byId.getPlanType().equals(byId.MONTH)){
            map =  stWaterRReorganizeService.getWaterSupplyerYeaarOrMonth(byId.MONTH,byId.getPlanDate());
        }else{
            //年度
            map =  stWaterRReorganizeService.getWaterSupplyerYeaarOrMonth(byId.YEAR,byId.getPlanDate());
        }
        waterAnalysisGGVo.setRealSupply(map.get("gg"));
        if(waterAnalysisGGVo.getRealSupply() == null){
            waterAnalysisGGVo.setGapSupply(null);
        }else{
            waterAnalysisGGVo.setGapSupply(waterAnalysisGGVo.getRealSupply().subtract(waterAnalysisGGVo.getPlanSupply()));
        }
        waterAnalysisSTVo.setRealSupply(map.get("st"));
        if(waterAnalysisSTVo.getRealSupply() == null){
            waterAnalysisSTVo.setGapSupply(null);
        }else{
            waterAnalysisSTVo.setGapSupply(waterAnalysisSTVo.getRealSupply().subtract(waterAnalysisSTVo.getPlanSupply()));
        }
        return res;
    }

    public List<WaterDispatch> waterDispatchAnalysis(Serializable year) {
        return waterDispatchService.lambdaQuery().apply("EXTRACT(YEAR FROM dis_start) = {0}", year)
                .in(WaterDispatch::getExeStatus, 0, 2)
                .list();
    }

    public List<WaterCapacityAnalysisVo> waterCapacityAnalysis(DateRangeSo dateRangeSo){
        List<WaterCapacityAnalysisVo> res = new ArrayList<>();
        List<StZvarlB> stZvarlBList = stZvarlBService.list();//获取水位-蓄水量
        stZvarlBList.sort(Comparator.comparing(StZvarlB::getRz));
        //查询时间段的
        List<AttResBase> list = attResBaseService.list();
        AttResBase attResBase = list.get(0);
        LambdaQueryWrapper<StRsvrR> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.apply("date_part('hour',tm) = 8") // 获取每天早上八点的数据
                .ge(StRsvrR::getTm,dateRangeSo.getStart())
                .le(StRsvrR::getTm, dateRangeSo.getEnd())
                .eq(StRsvrR::getStcd,attResBase.getStcd());
        queryWrapper.orderByDesc(StRsvrR::getTm);//根据时间降序
        List<StRsvrR> stRsvrRS = stRsvrRService.getBaseMapper().selectList(queryWrapper);//获取水库的历史时间段的水位

        for (int i = 0; i < stRsvrRS.size(); i++) {
            WaterCapacityAnalysisVo vo = new WaterCapacityAnalysisVo();
            vo.setTm(stRsvrRS.get(i).getTm());
            String rz = stRsvrRS.get(i).getRz();//历史水位
            BigDecimal currentCap = BigDecimal.ZERO;
            if(rz != null){
                currentCap = stZvarlBService.getWByZvarl(stZvarlBList,new BigDecimal(rz));//根据水位计算出库容
                vo.setCap(currentCap);
            }else{
                currentCap = BigDecimal.ZERO;
                vo.setCap(currentCap);
            }

            if(i < stRsvrRS.size() - 1){
                //获取前一天的库容（由于是降序排列，前一天的索引是i+1）
                BigDecimal prevDayCap = null;
                String prevRz = stRsvrRS.get(i + 1).getRz();
                if(prevRz != null){
                    prevDayCap = stZvarlBService.getWByZvarl(stZvarlBList, new BigDecimal(prevRz));
                }

                if (prevDayCap == null || BigDecimal.ZERO.compareTo(prevDayCap) == 0) {
                    vo.setRate(BigDecimal.ZERO.setScale(2, RoundingMode.DOWN));
                } else {
                    //计算变化率: (当天 - 前一天) / 前一天 * 100
                    BigDecimal diff = currentCap.subtract(prevDayCap);
                    BigDecimal rate = diff.divide(prevDayCap, 4, RoundingMode.HALF_UP)
                            .multiply(new BigDecimal(100));
                    vo.setRate(rate.setScale(2, RoundingMode.HALF_UP));
                }
            }else{
                //最后一天（时间上最早的一天）没有前一天数据，变化率为0
                vo.setRate(BigDecimal.ZERO.setScale(2, RoundingMode.DOWN));
            }
            res.add(vo);
        }
        return res;
    }
}