package com.gunshi.project.hsz.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.gunshi.project.hsz.entity.so.DataQueryCommonSo;
import com.gunshi.project.hsz.entity.vo.*;
import com.gunshi.project.hsz.mapper.AttResBaseMapper;
import com.gunshi.project.hsz.mapper.StZqrlBMapper;
import com.gunshi.project.hsz.model.*;
import com.gunshi.project.hsz.util.DataHandleUtil;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Description:
 * Created by wanyan on 2024/2/21
 *
 * @author wanyan
 * @version 1.0
 */
@Service
@Slf4j
@Transactional(rollbackFor = Exception.class)
public class RiverWaterService {

    @Resource
    private AttResBaseMapper attRvBaseMapper;

    @Resource
    private StZqrlBMapper stZqrlBMapper;

    @Resource
    private RainBasinDivisionService rainBasinDivisionService;

    @Resource
    private AlarmSetService alarmSetService;

    @Resource
    private StRiverRRealService stRiverRRealService;

    public List<AttRvBaseVo> list() {
        List<AttRvBaseVo> attRvBaseVos = attRvBaseMapper.queryWaterListUpAndLow();
        if(CollectionUtils.isEmpty(attRvBaseVos)){
            return attRvBaseVos;
        }
        return attRvBaseVos;
    }

    public List<AttRvBaseVo> get(String stcd) {
        List<AttRvBaseVo> attRvBaseVos = attRvBaseMapper.queryWaterListByStcd(stcd);
        if(CollectionUtils.isEmpty(attRvBaseVos)){
            return attRvBaseVos;
        }
        return attRvBaseVos;
    }

    public List<StZqrlB> zqrl(String stcd) {
        LambdaQueryWrapper<StZqrlB> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(StZqrlB::getStcd, stcd).orderByAsc(StZqrlB::getPtno);
        return stZqrlBMapper.selectList(queryWrapper);
    }


    public List<AttRvMonitorVo> monitorData(DataQueryCommonSo dataQueryCommonSo) {
        String stcd = dataQueryCommonSo.getStcd();
        //雨量数据
        List<AttRvMonitorVo> drpData = attRvBaseMapper.drp(dataQueryCommonSo);
        //水位数据
        List<AttRvMonitorVo> rzData = attRvBaseMapper.rz(dataQueryCommonSo);
        //获取水位流量关系，算出转换流量
        List<StZqrlB> zqrl = zqrl(stcd);
        if(CollectionUtils.isNotEmpty(zqrl)){
            calcTqData(rzData,zqrl);
        }
        //根据监测时间合并雨量和水位数据
        return bindData(stcd,drpData,rzData);
    }

    private List<AttRvMonitorVo> bindData(String stcd, List<AttRvMonitorVo> drpData, List<AttRvMonitorVo> rzData) {
        HashSet<Date> strings = new HashSet<>();
        drpData.stream().forEach(v1 -> strings.add(v1.getTm()));
        rzData.stream().forEach(v1 -> strings.add(v1.getTm()));

        ArrayList<AttRvMonitorVo> result = new ArrayList<>();
        strings.stream().forEach(v1 -> result.add(AttRvMonitorVo.builder().stcd(stcd).tm(v1).build()));

        List<AttRvMonitorVo> list = result.stream().map(v1 -> {
            drpData.stream().filter(v2 -> v1.getTm().equals(v2.getTm())).forEach(v2 -> {
                v1.setDrp(v2.getDrp());
            });

            rzData.stream().filter(v2 -> v1.getTm().equals(v2.getTm())).forEach(v2 -> {
                v1.setZ(v2.getZ());
                v1.setQ(v2.getQ());
                v1.setTq(v2.getTq());
            });

            return v1;
        }).collect(Collectors.toList());
        return list.stream().sorted(Comparator.comparing(AttRvMonitorVo::getTm).reversed()).collect(Collectors.toList());
    }

    private void calcTqData(List<AttRvMonitorVo> rzData, List<StZqrlB> zqrl) {
        BigDecimal maxRz = zqrl.stream().max(Comparator.comparing(StZqrlB::getZ)).get().getZ();
        BigDecimal minRz = zqrl.stream().min(Comparator.comparing(StZqrlB::getZ)).get().getZ();
        Map<BigDecimal, BigDecimal> map = zqrl.stream().collect(Collectors.toMap(StZqrlB::getZ, StZqrlB::getQ));
        List<BigDecimal> list = zqrl.stream().map(StZqrlB::getZ).collect(Collectors.toList());
        for(AttRvMonitorVo vo : rzData){
            BigDecimal rz = vo.getZ();
            if(rz.compareTo(minRz) < 0 || rz.compareTo(maxRz) > 0){
                continue;
            }
            vo.setTq(DataHandleUtil.calcData(rz,map,list));
        }
    }


    public AttRvMonitorDetailVo detail(String stcd) {
        AttRvMonitorDetailVo vo = new AttRvMonitorDetailVo();
        StPptnDetailsVo stPptnDetailsVo = rainBasinDivisionService.queryStPptnDetailsByStcd(stcd);
        BeanUtils.copyProperties(stPptnDetailsVo,vo,AttRvMonitorDetailVo.class);

        //最新水位
        AttRvMonitorVo monitorVo = attRvBaseMapper.newRz(stcd);
        if(monitorVo == null){
            return vo;
        }
        Date tm = monitorVo.getTm();
        BigDecimal rz = monitorVo.getZ();

        //最新水位时间往前推24小时水位
        LocalDateTime now = LocalDateTime.ofInstant(tm.toInstant(), ZoneId.systemDefault());
        LocalDateTime dateTime = now.minusDays(1);
        BigDecimal oldRz = attRvBaseMapper.oldRz(stcd,1,Date.from(dateTime.atZone(ZoneId.systemDefault()).toInstant()));

        if(oldRz != null){
            vo.setRzDiff(rz.subtract(oldRz));
        }
        //本年最高水位
        BigDecimal maxYearRz = queryYearRzByStcdAndTime(stcd);
        vo.setMaxRz(maxYearRz);
        return vo;
    }

    private BigDecimal queryYearRzByStcdAndTime(String stcd) {
        LocalDateTime now = LocalDateTime.ofInstant(new Date().toInstant(), ZoneId.systemDefault());
        LocalDateTime startTime;
        LocalDateTime endTime;
        if (now.getHour() >= 8 || (now.getHour() < 8 && now.getMonthValue() > 1) || (now.getHour() < 8 && now.getMonthValue() == 1 && now.getDayOfMonth() >= 1)){
            startTime = LocalDateTime.of(
                    now.getYear(),
                    1,
                    1,
                    8,
                    0,
                    0
            );
            endTime = now;
            return attRvBaseMapper.queryRiverMaxRz(stcd,Date.from(startTime.atZone(ZoneId.systemDefault()).toInstant()), Date.from(endTime.atZone(ZoneId.systemDefault()).toInstant()));
        }
        return new BigDecimal(0);
    }

    public AttRiverNowDataVo nowData(String stcd) {
        AttRiverNowDataVo vo  = new AttRiverNowDataVo();
        LambdaQueryWrapper<AlarmSet> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AlarmSet::getStcd,stcd);
        AlarmSet alarmSet = alarmSetService.getBaseMapper().selectOne(queryWrapper);//查询该站点的警告水位配置信息
        if(alarmSet == null){
            vo.setWaterAlarm(BigDecimal.ZERO);
            vo.setWaterPromise(BigDecimal.ZERO);
        }else{
            vo.setWaterAlarm(alarmSet.getWarnWaterLevel());
            vo.setWaterPromise(alarmSet.getPromiseWaterLevel());
        }

        StPptnRReal stPptnRReal = rainBasinDivisionService.queryStPptnRealByStcd(stcd);//查询该站点的实时降雨
        BeanUtils.copyProperties(stPptnRReal,vo);

        //查询该站点实时水位
        StRiverRReal stRiverRReal = stRiverRRealService.getBaseMapper().queryQByStcd(stcd);
        if(stRiverRReal == null){
            return vo;
        }
        BigDecimal z = stRiverRReal.getZ() == null ? BigDecimal.ZERO : stRiverRReal.getZ();
        vo.setWaterVal(z);
        vo.setWaterAlarmGap(z.subtract(vo.getWaterAlarm()));
        vo.setWaterPromiseGap(z.subtract(vo.getWaterPromise()));
        return vo;
    }
}