package com.dy.pipIrrStatistics.intake;

import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrGlobal.daoRm.RmOnHourReportHistoryMapper;
import com.dy.pipIrrGlobal.daoRm.RmOpenCloseValveHistoryMapper;
import com.dy.pipIrrGlobal.daoRm.RmOnHourReportLastMapper;
import com.dy.pipIrrGlobal.daoRm.RmOpenCloseValveLastMapper;
import com.dy.pipIrrGlobal.voSt.*;
import com.dy.pipIrrStatistics.intake.qo.*;
import com.dy.pipIrrGlobal.voSt.VoBatteryVolt;
import com.dy.pipIrrGlobal.voSt.VoCumulativeFlow;
import com.dy.pipIrrGlobal.voSt.VoIntake;
import com.dy.pipIrrGlobal.voSt.VoIntakeOpenCount;
import com.dy.pipIrrGlobal.voSt.VoSignalIntensity;
import com.dy.pipIrrStatistics.intake.qo.BatteryVoltQO;
import com.dy.pipIrrStatistics.intake.qo.CumulativeFlowQO;
import com.dy.pipIrrStatistics.intake.qo.IntakeCountValueQO;
import com.dy.pipIrrStatistics.intake.qo.CommonQO;
import com.dy.pipIrrStatistics.intake.qo.SignalIntensityQO;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.common.utils.PojoUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.text.DecimalFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * @author ZhuBaoMin
 * @date 2024-08-01 13:58
 * @LastEditTime 2024-08-01 13:58
 * @Description
 */

@Slf4j
@Service
public class IntakeSv {
    @Autowired
    private RmOnHourReportHistoryMapper rmOnHourReportHistoryMapper;
    @Autowired
    private RmOpenCloseValveHistoryMapper rmOpenCloseValveHistoryMapper;
    @Autowired
    private RmOnHourReportLastMapper rmOnHourReportLastMapper;

    @Autowired
    private RmOpenCloseValveLastMapper rmOpenCloseValveLastMapper;

    @Value("${rtu.batteryVolt}")
    private Double batteryVolt;

    @Value("${rtu.signalIntensity.weak}")
    private Integer weak;

    @Value("${rtu.signalIntensity.ordinary}")
    private Integer ordinary;

    /**
     * 获取指定时间段内未上线的取水口
     * @param qo
     * @return
     */
    public QueryResultVo<List<VoIntake>> getNotOnlineIntakes(CommonQO qo) {
        DecimalFormat df = new DecimalFormat("0.00");
        /**
         * 补齐起止时间，如果开始时间为空，则默认为当前日期
         */
        String timeStart = qo.getTimeStart();
        String timeStop = qo.getTimeStop();
        if(timeStart != null) {
            timeStart = timeStart + " 00:00:00";
        }else {
            timeStart = LocalDate.now() + " 00:00:00";
        }
        if(timeStop != null) {
            timeStop = timeStop + " 23:59:59";
        }
        qo.setTimeStart(timeStart);
        qo.setTimeStop(timeStop);

        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        // 获取符合条件的记录数
        Long itemTotal = Optional.ofNullable(rmOnHourReportHistoryMapper.getNotOnlineIntakesCount(params)).orElse(0L);

        QueryResultVo<List<VoIntake>> rsVo = new QueryResultVo<>() ;

        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOnHourReportHistoryMapper.getNotOnlineIntakes(params);
        return rsVo ;
    }

    /**
     * 获取累计流量超过指定值的取水口
     * @param qo
     * @return
     */
    public QueryResultVo<List<VoCumulativeFlow>> getLargeFlowIntakes(CumulativeFlowQO qo) {
        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        // 获取符合条件的记录数
        Long itemTotal = Optional.ofNullable(rmOnHourReportLastMapper.getLargeFlowIntakesCount(params)).orElse(0L);

        QueryResultVo<List<VoCumulativeFlow>> rsVo = new QueryResultVo<>() ;

        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOnHourReportLastMapper.getLargeFlowIntakes(params);
        return rsVo ;
    }

    /**
     * 获取累计流量低于指定值的取水口
     * @param qo
     * @return
     */
    public QueryResultVo<List<VoCumulativeFlow>> getSmallFlowIntakes(CumulativeFlowQO qo) {
        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        // 获取符合条件的记录数
        Long itemTotal = Optional.ofNullable(rmOnHourReportLastMapper.getSmallFlowIntakesCount(params)).orElse(0L);

        QueryResultVo<List<VoCumulativeFlow>> rsVo = new QueryResultVo<>() ;

        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOnHourReportLastMapper.getSmallFlowIntakes(params);
        return rsVo ;
    }

    /**
     * 获取欠压取水口
     * @param qo
     * @return
     */
    public QueryResultVo<List<VoBatteryVolt>> getUnderVoltIntakes(BatteryVoltQO qo) {
        qo.setBatteryVolt(batteryVolt);
        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        // 获取符合条件的记录数
        Long itemTotal = Optional.ofNullable(rmOnHourReportLastMapper.getUnderVoltIntakesCount(params)).orElse(0L);

        QueryResultVo<List<VoBatteryVolt>> rsVo = new QueryResultVo<>() ;

        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOnHourReportLastMapper.getUnderVoltIntakes(params);
        return rsVo ;
    }

    /**
     * 获取指定信号强度的取水口
     * @param qo
     * @return
     */
    public QueryResultVo<List<VoSignalIntensity>> getSpecifiedSignalIntakes(SignalIntensityQO qo) {
        qo.setWeak(weak);
        qo.setOrdinary(ordinary);

        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        // 获取符合条件的记录数
        Long itemTotal = Optional.ofNullable(rmOnHourReportLastMapper.getSpecifiedSignalIntakesCount(params)).orElse(0L);

        QueryResultVo<List<VoSignalIntensity>> rsVo = new QueryResultVo<>() ;

        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOnHourReportLastMapper.getSpecifiedSignalIntakes(params);
        return rsVo ;
    }

    /**
     * 获取从未开过阀的取水口
     * @return
     */
    public QueryResultVo<List<VoIntake>> getNeverOpenValveIntakes(CommonQO qo) {

        String timeStart = qo.getTimeStart();
        String timeStop = qo.getTimeStop();
        if(timeStart != null) {
            timeStart = timeStart + " 00:00:00";
        }else {
            timeStart = LocalDate.now() + " 00:00:00";
        }
        qo.setTimeStart(timeStart);
        if(timeStop != null) {
            timeStop = timeStop + " 23:59:59";
        }else {
            timeStop = LocalDate.now() + " 23:59:59";
        }
        qo.setTimeStop(timeStop);

        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        // 获取符合条件的记录数
        Long itemTotal = Optional.ofNullable(rmOpenCloseValveHistoryMapper.getNeverOpenValveIntakesCount(params)).orElse(0L);

        QueryResultVo<List<VoIntake>> rsVo = new QueryResultVo<>() ;

        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOpenCloseValveHistoryMapper.getNeverOpenValveIntakes(params);
        return rsVo ;
    }

    /**
     * 获取指定时间段内开阀次数超过指定值的取水口
     * @param qo
     * @return
     */
    public QueryResultVo<List<VoIntakeOpenCount>> getOpenValveGtIntakes(IntakeCountValueQO qo) {

        String timeStart = qo.getTimeStart();
        String timeStop = qo.getTimeStop();
        if(timeStart != null) {
            timeStart = timeStart + " 00:00:00";
        }else {
            timeStart = LocalDate.now() + " 00:00:00";
        }
        qo.setTimeStart(timeStart);
        if(timeStop != null) {
            timeStop = timeStop + " 23:59:59";
        }else {
            timeStop = LocalDate.now() + " 23:59:59";
        }
        qo.setTimeStop(timeStop);

        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        // 获取符合条件的记录数
        Long itemTotal = Optional.ofNullable(rmOpenCloseValveHistoryMapper.getOpenValveGtIntakesCount(params)).orElse(0L);

        QueryResultVo<List<VoIntakeOpenCount>> rsVo = new QueryResultVo<>() ;

        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOpenCloseValveHistoryMapper.getOpenValveGtIntakes(params);
        return rsVo ;
    }

    /**
     * 获取指定时间段内开阀次数低于指定值的取水口
     * @param qo
     * @return
     */
    public QueryResultVo<List<VoIntakeOpenCount>> getOpenValveLtIntakes(IntakeCountValueQO qo) {

        String timeStart = qo.getTimeStart();
        String timeStop = qo.getTimeStop();
        if(timeStart != null) {
            timeStart = timeStart + " 00:00:00";
        }else {
            timeStart = LocalDate.now() + " 00:00:00";
        }
        qo.setTimeStart(timeStart);
        if(timeStop != null) {
            timeStop = timeStop + " 23:59:59";
        }else {
            timeStop = LocalDate.now() + " 23:59:59";
        }
        qo.setTimeStop(timeStop);

        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        // 获取符合条件的记录数
        Long itemTotal = Optional.ofNullable(rmOpenCloseValveHistoryMapper.getOpenValveLtIntakesCount(params)).orElse(0L);

        QueryResultVo<List<VoIntakeOpenCount>> rsVo = new QueryResultVo<>() ;

        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOpenCloseValveHistoryMapper.getOpenValveLtIntakes(params);
        return rsVo ;
    }

    /**
     * 根据开阀类型获取操作次数
     * @param qo
     * @return
     */
    public VoCountOfOpenType getCountByOpenType(OpenTypeQO qo) {
        /**
         * 补齐起止时间，如果开始时间为空，则默认为当前日期
         */
        String timeStart = qo.getTimeStart();
        String timeStop = qo.getTimeStop();
        if(timeStart != null) {
            timeStart = timeStart + " 00:00:00";
        }else {
            timeStart = LocalDate.now() + " 00:00:00";
        }
        if(timeStop != null) {
            timeStop = timeStop + " 23:59:59";
        }
        qo.setTimeStart(timeStart);
        qo.setTimeStop(timeStop);

        Integer openType = qo.getOpenType();
        String openTypeName = "";
        switch (openType) {
            case 1:
                openTypeName = "刷卡开阀";
                break;
            case 3:
                openTypeName = "中心站开阀";
                break;
            case 8:
                openTypeName = "用户远程开阀";
                break;
            case 11:
                openTypeName = "开关阀卡开阀";
                break;
            case 13:
                openTypeName = "开关阀卡开阀";
                break;
        }

        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;

        Integer openTypeCount = Optional.ofNullable(rmOpenCloseValveLastMapper.getCountByOpenType(params)).orElse(0);

        VoCountOfOpenType vo = new VoCountOfOpenType();
        vo.setOpenTypeName(openTypeName);
        vo.setOpenTypeCount(openTypeCount);
        return vo;
    }

    /**
     * 根据关阀类型获取操作次数
     * @param qo
     * @return
     */
    public VoCountOfCloseType getCountByCloseType(CloseTypeQo qo) {
        /**
         * 补齐起止时间，如果开始时间为空，则默认为当前日期
         */
        String timeStart = qo.getTimeStart();
        String timeStop = qo.getTimeStop();
        if(timeStart != null) {
            timeStart = timeStart + " 00:00:00";
        }else {
            timeStart = LocalDate.now() + " 00:00:00";
        }
        if(timeStop != null) {
            timeStop = timeStop + " 23:59:59";
        }
        qo.setTimeStart(timeStart);
        qo.setTimeStop(timeStop);

        Integer closeType = qo.getCloseType();
        String closeTypeName = "";
        switch (closeType) {
            case 2:
                closeTypeName = "刷卡关阀";
                break;
            case 4:
                closeTypeName = "中心站关阀";
                break;
            case 5:
                closeTypeName = "欠费关阀";
                break;
            case 6:
                closeTypeName = "流量计故障关阀";
                break;
            case 7:
                closeTypeName = "紧急关阀";
                break;
            case 9:
                closeTypeName = "用户远程关阀";
                break;
            case 10:
                closeTypeName = "开关阀卡关阀";
                break;
            case 12:
                closeTypeName = "黑名单命令关阀";
                break;
            case 13:
                closeTypeName = "远程定时关阀";
                break;
            case 14:
                closeTypeName = "远程定量关阀";
                break;
        }

        // 生成查询参数
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo) ;
        Integer closeTypeCount = Optional.ofNullable(rmOpenCloseValveLastMapper.getCountByCloseType(params)).orElse(0);

        VoCountOfCloseType vo = new VoCountOfCloseType();
        vo.setCloseTypeName(closeTypeName);
        vo.setCloseTypeCount(closeTypeCount);
        return vo;
    }

    /**
     * 指定时间段内用水量超过指定值的取水口
     * @param qo
     * @return
     */
    public QueryResultVo<List<VoIntakeAccumulateAmount>> getUseWaterGtValueIntakes(IntakeAmountValueQO qo) {
        String timeStart = qo.getTimeStart();
        String timeStop = qo.getTimeStop();
        if(timeStart != null && timeStart != "") {
            timeStart = timeStart + " 00:00:00";
        } else {
            timeStart = LocalDateTime.of(2024, 1, 1, 0, 0, 0).toString();
        }
        qo.setTimeStart(timeStart);

        if(timeStop != null && timeStop != "") {
            timeStop = timeStop + " 23:59:59";
        }else {
            timeStop = LocalDate.now() + " 23:59:59";
        }
        qo.setTimeStop(timeStop);

        if (qo.getValue() == null){
            qo.setValue(0.0);
        }


        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(qo);
        Long itemTotal = rmOnHourReportHistoryMapper.getUseWaterGtValueIntakesCount(params);

        QueryResultVo<List<VoIntakeAccumulateAmount>> rsVo = new QueryResultVo<>() ;
        rsVo.pageSize = qo.pageSize ;
        rsVo.pageCurr = qo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = rmOnHourReportHistoryMapper.getUseWaterGtValueIntakes(params);
        return rsVo ;
    }
}