package com.finance.web.controller.service;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.finance.common.basic.PageDTO;
import com.finance.common.core.domain.entity.SysUser;
import com.finance.common.enums.AreaLevelEnum;
import com.finance.common.enums.DataScreenConfigEnum;
import com.finance.common.enums.ReportingStatusEnum;
import com.finance.common.enums.RiskLevelEnum;
import com.finance.common.enums.ShowStatusEnum;
import com.finance.common.enums.SubTypeEnum;
import com.finance.common.enums.UserTypeEnum;
import com.finance.common.utils.BeanUtils;
import com.finance.common.utils.CollUtils;
import com.finance.common.utils.DateUtils;
import com.finance.common.utils.StringUtils;
import com.finance.system.constants.QuarterConstant;
import com.finance.system.domain.TbBasicData;
import com.finance.system.domain.TbBasicDataCategory;
import com.finance.system.domain.TbQuestion;
import com.finance.system.query.CalculateDetailQuery;
import com.finance.system.query.DeptCalculateDetailQuery;
import com.finance.system.query.TransferPaymentScaleQuery;
import com.finance.system.service.ISysUserService;
import com.finance.system.service.TbBasicDataCategoryService;
import com.finance.system.service.TbBasicDataConfigService;
import com.finance.system.service.TbBasicDataService;
import com.finance.system.service.TbDataScreenConfigService;
import com.finance.system.service.TbDataScreenScoreService;
import com.finance.system.service.TbQuestionService;
import com.finance.system.service.TbScoreService;
import com.finance.system.vo.BasicDataVO;
import com.finance.system.vo.CurrentFieldsDetailVO;
import com.finance.system.vo.DataAnalysisVO;
import com.finance.system.vo.DataScreenConfigVO;
import com.finance.system.vo.DataScreenScoreVO;
import com.finance.system.vo.DeptCalculateDetailVO;
import com.finance.system.vo.FieldAndScoreDataVO;
import com.finance.system.vo.ProvinceStaticsVO;
import com.finance.system.vo.QuestionVO;
import com.finance.system.vo.RiskAndTransferVO;
import com.finance.system.vo.RiskCountVO;
import com.finance.system.vo.RiskLevelVO;
import com.finance.system.vo.RiskMapVO;
import com.finance.system.vo.RiskRankingVO;
import com.finance.system.vo.ScoreCalculateDetailVO;
import com.finance.system.vo.ScoreDataVO;
import com.finance.system.vo.ScoreRankVO;
import com.finance.system.vo.ScoreRateDataVO;
import com.finance.system.vo.TransferPaymentScaleVO;
import com.google.common.collect.Lists;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * @author mitao
 * @date 2024/4/16
 */
@Service
@Slf4j
@RequiredArgsConstructor
public class ScreenService {

    private final ISysUserService sysUserService;
    private final TbBasicDataService tbBasicDataService;
    private final TbDataScreenScoreService tbDataScreenScoreService;
    private final TbDataScreenConfigService tbDataScreenConfigService;
    private final TbQuestionService tbQuestionService;
    private final TbScoreService tbScoreService;
    private final TbBasicDataConfigService tbBasicDataConfigService;
    private final TbBasicDataCategoryService tbBasicDataCategoryService;

    public ProvinceStaticsVO provinceStatics() {
        ProvinceStaticsVO vo = new ProvinceStaticsVO();
        int provinceCount = getCount(AreaLevelEnum.PROVINCE);
        int cityCount = getCount(AreaLevelEnum.CITY);
        int developmentZonesCount = getCount(AreaLevelEnum.DEVELOPMENT_ZONES);
        int countyCount = getCount(AreaLevelEnum.COUNTY);

        vo.setProvinceCount(provinceCount);
        vo.setCityCount(cityCount);
        vo.setDevelopmentZonesCount(developmentZonesCount);
        vo.setCountyCount(countyCount);
        return vo;
    }

    private int getCount(AreaLevelEnum level) {
        return (int) sysUserService.count(
                Wrappers.<SysUser>lambdaQuery().eq(SysUser::getUserType, UserTypeEnum.DEPARTMENT)
                        .eq(SysUser::getAreaLevel, level));
    }

    public PageDTO<TransferPaymentScaleVO> transferPaymentScalePage(
            TransferPaymentScaleQuery query) {
        Page<TransferPaymentScaleVO> pageVO = tbBasicDataService.transferPaymentScalePage(
                new Page<TransferPaymentScaleVO>(query.getPageNum(), query.getPageSize()),
                query.getQuarter());
        return PageDTO.of(pageVO);
    }

    public List<BasicDataVO> quarterList() {
        List<TbBasicData> list = tbBasicDataService.lambdaQuery().select(TbBasicData::getQuarter)
                .groupBy(TbBasicData::getQuarter)
                .eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED).list();
        return BeanUtils.copyList(list, BasicDataVO.class);
    }

    public RiskAndTransferVO getRiskAndTransfer() throws Exception {
        RiskAndTransferVO riskAndTransferVO = new RiskAndTransferVO();
        // 查询省本级得分排名
        ScoreRankVO scoreRankVO = tbScoreService.queryRankAndScoreByAreaCode("510000");
        riskAndTransferVO.setScoreRankVO(scoreRankVO);
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        // 查询转移支付规模总额
        List<TbBasicData> list = tbBasicDataService.lambdaQuery()
                .select(TbBasicData::getTransferPaymentScale)
                .eq(TbBasicData::getQuarter, previousQuarter)
                // .eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
                .list();
        Optional<Double> reduce = list.stream()
                .map(tbBasicData -> Double.parseDouble(tbBasicData.getTransferPaymentScale()))
                .reduce(Double::sum);
        riskAndTransferVO.setTransferPaymentScale(reduce.orElse(0D));
        // 查询风险等级设置
        DataScreenConfigVO riskLevel = tbDataScreenConfigService.getRiskLevel();
        List<RiskLevelVO> riskLevelVOList = formatRiskLevel(riskLevel);
        riskAndTransferVO.setRiskLevelVOList(riskLevelVOList);
        RiskCountVO riskCountVO = new RiskCountVO();
        // 地图市域得分
        List<RiskMapVO> riskMapVOList = tbScoreService.getCityScore(previousQuarter,
                riskLevel);
        // List<RiskMapVO> riskMapVOList = tbScoreService.getCurrentScoreList(previousQuarter, null);
        String[] noRiskArr = riskLevel.getNoRisk().split("_");
        String[] lowRiskArr = riskLevel.getLowRisk().split("_");
        String[] mediumRiskArr = riskLevel.getMediumRisk().split("_");
        String[] highRiskArr = riskLevel.getHighRisk().split("_");
        List<RiskMapVO> cityRiskVO = riskMapVOList.stream()
                .filter(r -> r.getAreaLevel().equals(AreaLevelEnum.CITY))
                .collect(Collectors.toList());
        long noRiskCount = cityRiskVO.stream()
                .filter(item -> item.getScore() >= Double.parseDouble(noRiskArr[0])
                        && item.getScore() <= Double.parseDouble(noRiskArr[1])).count();
        riskCountVO.setNoRiskCount((int) noRiskCount);
        long lowRiskCount = cityRiskVO.stream()
                .filter(item -> item.getScore() >= Double.parseDouble(lowRiskArr[0])
                        && item.getScore() <= Double.parseDouble(lowRiskArr[1])).count();
        riskCountVO.setLowRiskCount((int) lowRiskCount);
        long mediumRiskCount = cityRiskVO.stream()
                .filter(item -> item.getScore() >= Double.parseDouble(mediumRiskArr[0])
                        && item.getScore() <= Double.parseDouble(mediumRiskArr[1])).count();
        riskCountVO.setMediumRiskCount((int) mediumRiskCount);
        long highRiskCount = cityRiskVO.stream()
                .filter(item -> item.getScore() >= Double.parseDouble(highRiskArr[0])
                        && item.getScore() <= Double.parseDouble(highRiskArr[1])).count();
        riskCountVO.setHighRiskCount((int) highRiskCount);

        /*for (RiskLevelVO vo : riskLevelVOList) {
            long count = riskMapVOList.stream()
                    .filter(r -> r.getAreaLevel().equals(AreaLevelEnum.CITY))
                    .filter(item -> item.getScore() >= vo.getMin()
                            && item.getScore() <= vo.getMax()).count();

            if (vo.getRiskLevel().equals(RiskLevelEnum.L1)) {
                riskCountVO.setNoRiskCount((int) count);
            } else if (vo.getRiskLevel().equals(RiskLevelEnum.L2)) {
                riskCountVO.setLowRiskCount((int) count);
            } else if (vo.getRiskLevel().equals(RiskLevelEnum.L3)) {
                riskCountVO.setMediumRiskCount((int) count);
            } else if (vo.getRiskLevel().equals(RiskLevelEnum.L4)) {
                riskCountVO.setHighRiskCount((int) count);
            }
        }*/
        // TODO
        // riskCountVO.setNoRiskCount(50);
        // riskCountVO.setLowRiskCount(45);
        // riskCountVO.setMediumRiskCount(30);
        // riskCountVO.setHighRiskCount(80);
        riskAndTransferVO.setRiskCountVO(riskCountVO);
        // 查询风险配置对应得分
        // List<RiskMapVO> riskMapVOList = tbDataScreenScoreService.queryScore4Map(nowQuarter,
        //         riskLevel.getId());

        riskAndTransferVO.setRiskMapVOList(riskMapVOList);
        return riskAndTransferVO;
    }

    private List<RiskLevelVO> formatRiskLevel(DataScreenConfigVO riskLevel) {
        String[] noRiskArr = riskLevel.getNoRisk().split("_");
        String[] lowRiskArr = riskLevel.getLowRisk().split("_");
        String[] mediumRiskArr = riskLevel.getMediumRisk().split("_");
        String[] highRiskArr = riskLevel.getHighRisk().split("_");
        return handleRiskLevel(noRiskArr, lowRiskArr, mediumRiskArr,
                highRiskArr);
    }

    private List<RiskLevelVO> handleRiskLevel(String[] noRiskArr, String[] lowRiskArr,
            String[] mediumRiskArr, String[] highRiskArr) {
        List<RiskLevelVO> list = new ArrayList<>();
        String min = noRiskArr[0];
        String max = noRiskArr[1];
        RiskLevelVO vo1 = new RiskLevelVO();
        vo1.setRiskLevel(RiskLevelEnum.L1);
        vo1.setMin(Double.parseDouble(min));
        vo1.setMax(Double.parseDouble(max));
        list.add(vo1);
        min = lowRiskArr[0];
        max = lowRiskArr[1];
        RiskLevelVO vo2 = new RiskLevelVO();
        vo2.setRiskLevel(RiskLevelEnum.L2);
        vo2.setMin(Double.parseDouble(min));
        vo2.setMax(Double.parseDouble(max));
        list.add(vo2);
        min = mediumRiskArr[0];
        max = mediumRiskArr[1];
        RiskLevelVO vo3 = new RiskLevelVO();
        vo3.setRiskLevel(RiskLevelEnum.L3);
        vo3.setMin(Double.parseDouble(min));
        vo3.setMax(Double.parseDouble(max));
        list.add(vo3);
        min = highRiskArr[0];
        max = highRiskArr[1];
        RiskLevelVO vo4 = new RiskLevelVO();
        vo4.setRiskLevel(RiskLevelEnum.L4);
        vo4.setMin(Double.parseDouble(min));
        vo4.setMax(Double.parseDouble(max));
        list.add(vo4);
        return list;
    }

    public List<RiskRankingVO> riskRanking() throws Exception {
        DataScreenConfigVO riskLevel = tbDataScreenConfigService.getRiskLevel();
        List<RiskLevelVO> riskLevelVOList = formatRiskLevel(riskLevel);
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        List<RiskRankingVO> voList = tbScoreService.queryRiskRanking(
                previousQuarter);
        int rank = 1;
        for (RiskRankingVO riskRankingVO : voList) {
            riskRankingVO.setRank(rank++);
            for (RiskLevelVO vo : riskLevelVOList) {
                // if (vo.getRiskLevel().equals(RiskLevelEnum.L1)
                //         && riskRankingVO.getScore() <= vo.getMin()) {
                //     riskRankingVO.setRiskLevel(vo.getRiskLevel().getCode());
                // }
                if (riskRankingVO.getScore() >= vo.getMin()
                        && riskRankingVO.getScore() <= vo.getMax()) {
                    riskRankingVO.setRiskLevel(vo.getRiskLevel().getCode());
                }
                // if (vo.getRiskLevel().equals(RiskLevelEnum.L4)
                //         && riskRankingVO.getScore() >= vo.getMax()) {
                //     riskRankingVO.setRiskLevel(vo.getRiskLevel().getCode());
                // }
            }
        }
        return voList;
    }

    public List<QuestionVO> queryQuestions() throws Exception {
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        List<TbQuestion> list = tbQuestionService.lambdaQuery()
                .eq(TbQuestion::getQuarter, previousQuarter).list();
        return BeanUtils.copyList(list, QuestionVO.class);
    }

    public DataAnalysisVO getDataAnalysis(String areaCode) throws Exception {
        DataAnalysisVO dataAnalysisVO = new DataAnalysisVO();
        // 查询得分排名
        ScoreRankVO scoreRankVO = tbScoreService.queryRankAndScoreByAreaCode(areaCode);
        if (Objects.isNull(scoreRankVO)) {
            return dataAnalysisVO;
        }
        dataAnalysisVO.setRank(scoreRankVO.getRank());
        dataAnalysisVO.setScore(scoreRankVO.getScore());
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        // 查询问题
        List<TbQuestion> list = tbQuestionService.lambdaQuery()
                .eq(TbQuestion::getQuarter, previousQuarter)
                .eq(TbQuestion::getDeptAreaCode, areaCode)
                .list();
        List<QuestionVO> questionVOS = BeanUtils.copyList(list, QuestionVO.class);
        dataAnalysisVO.setQuestions(questionVOS);
        SysUser user = sysUserService.lambdaQuery()
                .eq(SysUser::getUserType, UserTypeEnum.DEPARTMENT)
                .eq(SysUser::getAreaCode, areaCode).one();
        if (Objects.isNull(user)) {
            return dataAnalysisVO;
        }
        dataAnalysisVO.setAreaName(user.getDeptName());
        // 查询风险得分
        DataScreenConfigVO riskLevel = tbDataScreenConfigService.getRiskLevel();
        List<RiskLevelVO> riskLevelVOList = formatRiskLevel(riskLevel);

        dataAnalysisVO.setYearScore(getYearScore(areaCode, previousQuarter));
        String lastYearQuarter = DateUtils.getLastYearQuarter(previousQuarter);
        dataAnalysisVO.setLastYearScore(getYearScore(areaCode, lastYearQuarter));
        // 查询风险等级
        List<RiskMapVO> currentScoreList = tbScoreService.getCurrentScoreList(previousQuarter,
                areaCode);

        for (RiskMapVO tbDataScreenScore : currentScoreList) {
            for (RiskLevelVO vo : riskLevelVOList) {
                if (tbDataScreenScore.getScore() >= vo.getMin()
                        && tbDataScreenScore.getScore() <= vo.getMax()) {
                    dataAnalysisVO.setRiskLevel(vo.getRiskLevel().getCode());
                }
            }
        }
        // 查询四个指标下的三级指标
        List<FieldAndScoreDataVO> voList =
                tbBasicDataService.getFieldAndScoreData(areaCode, previousQuarter, 1, 2);
        List<FieldAndScoreDataVO> lastYearList =
                tbBasicDataService.getFieldAndScoreData(areaCode, lastYearQuarter, 2, 2);
        // 查询四个指标下的三级指标
        List<FieldAndScoreDataVO> allDeptVoList =
                tbBasicDataService.getFieldAndScoreData(areaCode, previousQuarter, 1, 1);
        // 查询形式指标得分
        dataAnalysisVO.setScoreDataList(handleDataIndicators(voList, lastYearList));
        // 查询数据指标得分
        dataAnalysisVO.setScoreRateDataList(handleDataIndicatorsRate(allDeptVoList, voList));
        // 查询大屏下方字段列表
        List<TbBasicDataCategory> categoryList = tbBasicDataCategoryService.lambdaQuery()
                .eq(TbBasicDataCategory::getParentId, -1)
                .eq(TbBasicDataCategory::getStatus, ShowStatusEnum.SHOW)
                .last("limit 4").list();

        if (categoryList.isEmpty()) {
            dataAnalysisVO.setScoreRateDataListOne(CollUtils.emptyList());
            dataAnalysisVO.setScoreRateDataListTwo(CollUtils.emptyList());
            dataAnalysisVO.setScoreRateDataListThree(CollUtils.emptyList());
            dataAnalysisVO.setScoreRateDataListFour(CollUtils.emptyList());
        } else {
            dataAnalysisVO.setScoreRateDataListOne(getLevelThreeIndicators(voList, "财政经济形势"));
            dataAnalysisVO.setScoreRateDataListTwo(getLevelThreeIndicators(voList, "预算管理方面"));
            dataAnalysisVO.setScoreRateDataListThree(
                    getLevelThreeIndicators(voList, "预算执行方面"));
            dataAnalysisVO.setScoreRateDataListFour(
                    getLevelThreeIndicators(voList, "风险防控方面"));
        }
        return dataAnalysisVO;
    }

    private List<ScoreRateDataVO> handleDataIndicatorsRate(List<FieldAndScoreDataVO> allDeptVoList,
            List<FieldAndScoreDataVO> voList) {
        List<ScoreRateDataVO> result = new ArrayList<>();

        List<String> indicatorList = Lists.newArrayList("财政经济形势", "预算管理方面",
                "预算执行方面", "风险防控方面");
        for (int i = 0; i < indicatorList.size(); i++) {
            ScoreRateDataVO scoreRateDataVO = new ScoreRateDataVO();
            if (CollUtils.isEmpty(voList)) {
                scoreRateDataVO.setRank(0);
                scoreRateDataVO.setScore(0D);
                scoreRateDataVO.setSubType(SubTypeEnum.getEnumByCode(i + 1));
                scoreRateDataVO.setScoreRate(0D);
                scoreRateDataVO.setMaxScore(0D);
            } else {
                List<FieldAndScoreDataVO> levelThreeIndicators = getLevelThreeIndicators(voList,
                        indicatorList.get(i));
                Double indicatorOne = levelThreeIndicators.stream()
                        .map(FieldAndScoreDataVO::getScore).reduce(Double::sum)
                        .map(BigDecimal::valueOf)
                        .orElse(BigDecimal.ZERO).setScale(2, RoundingMode.HALF_UP)
                        .doubleValue();
                List<Double> allIndicatorsScore = getAllIndicatorsScoreByName(allDeptVoList,
                        indicatorList.get(i));
                allIndicatorsScore.add(indicatorOne);
                allIndicatorsScore.sort(Comparator.comparing(Double::doubleValue).reversed());
                scoreRateDataVO.setRank(allIndicatorsScore.indexOf(indicatorOne) + 1);
                scoreRateDataVO.setScore(indicatorOne);
                scoreRateDataVO.setSubType(SubTypeEnum.getEnumByCode(i + 1));
                scoreRateDataVO.setScoreRate(BigDecimal.valueOf(indicatorOne)
                        .divide(BigDecimal.valueOf(
                                        levelThreeIndicators.get(0).getLevelOneIndicatorMaxScore()), 2,
                                RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100L))
                        .doubleValue());
                scoreRateDataVO.setMaxScore(
                        levelThreeIndicators.get(0)
                                .getLevelOneIndicatorMaxScore());
            }
            result.add(scoreRateDataVO);
        }
        return result;
    }

    private List<Double> getAllIndicatorsScoreByName(List<FieldAndScoreDataVO> allDeptVoList,
            String indicatorName) {
        Map<String, List<FieldAndScoreDataVO>> collect = allDeptVoList.stream()
                .collect(Collectors.groupingBy(FieldAndScoreDataVO::getDeptAreaCode));
        return collect.keySet().stream().map(key -> {
            Double score = getLevelThreeIndicators(collect.get(key), indicatorName).stream()
                    .map(FieldAndScoreDataVO::getScore).reduce(Double::sum).orElse(0D);
            return score;
        }).sorted(Comparator.comparing(Double::intValue).reversed()).collect(Collectors.toList());
    }

    private List<ScoreDataVO> handleDataIndicators(List<FieldAndScoreDataVO> voList,
            List<FieldAndScoreDataVO> lastYearList) {
        List<ScoreDataVO> scoreDataVOList = new ArrayList<>();
        List<String> indicatorList = Lists.newArrayList("财政经济形势", "预算管理方面",
                "预算执行方面", "风险防控方面");
        for (int i = 0; i < indicatorList.size(); i++) {
            ScoreDataVO scoreDataVO = new ScoreDataVO();
            if (CollUtils.isEmpty(voList)) {
                scoreDataVO.setLastScore(0D);
                scoreDataVO.setScore(0D);
                scoreDataVO.setMaxScore(0D);
                scoreDataVO.setSubType(SubTypeEnum.getEnumByCode(i + 1));
            } else {
                Double indicatorOne = getLevelThreeIndicators(voList,
                        indicatorList.get(i)).stream()
                        .map(FieldAndScoreDataVO::getScore).reduce(Double::sum)
                        .map(BigDecimal::valueOf)
                        .orElse(BigDecimal.ZERO).setScale(2, RoundingMode.HALF_UP)
                        .doubleValue();
                Double indicatorOneLastYear = getLevelThreeIndicators(lastYearList,
                        indicatorList.get(i)).stream()
                        .map(FieldAndScoreDataVO::getScore).reduce(Double::sum)
                        .map(BigDecimal::valueOf)
                        .orElse(BigDecimal.ZERO).setScale(2, RoundingMode.HALF_UP).doubleValue();
                scoreDataVO.setLastScore(indicatorOneLastYear);
                scoreDataVO.setScore(indicatorOne);
                scoreDataVO.setMaxScore(getLevelThreeIndicators(voList, indicatorList.get(i)).get(0)
                        .getLevelOneIndicatorMaxScore());
                scoreDataVO.setSubType(SubTypeEnum.getEnumByCode(i + 1));
            }
            scoreDataVOList.add(scoreDataVO);
        }
        return scoreDataVOList;
    }

    private List<FieldAndScoreDataVO> getLevelThreeIndicators(List<FieldAndScoreDataVO> voList,
            String indicatorName) {
        return voList.stream().map(vo -> {
            if (StringUtils.isNotBlank(vo.getLevelOneIndicator())) {
                if (StringUtils.trim(vo.getLevelOneIndicator()).equals(indicatorName)) {
                    return vo;
                } else {
                    if (StringUtils.isNotBlank(vo.getLevelTwoIndicator())
                            && StringUtils.trim(vo.getLevelTwoIndicator()).equals(indicatorName)) {
                        return vo;
                    }
                }
            }
            return null;
        }).filter(Objects::nonNull).collect(Collectors.toList());
    }

    private Double getYearScore(String areaCode, String previousQuarter) {
        List<RiskMapVO> thisYearScoreList = tbScoreService.getScoreByYearType(areaCode,
                previousQuarter);
        return thisYearScoreList.stream().map(RiskMapVO::getScore)
                .reduce(Double::sum).map(BigDecimal::valueOf).orElse(BigDecimal.ZERO)
                .setScale(2, RoundingMode.HALF_UP).doubleValue();
    }

    private void handleDataIndicators(String areaCode, List<ScoreDataVO> scoreDataVOList) {
        List<DataScreenScoreVO> formalIndicatorsYear = tbDataScreenScoreService.selectIndicators(
                areaCode, null, DataScreenConfigEnum.FORMAL_INDICATORS, 1);
        if (CollUtils.isNotEmpty(formalIndicatorsYear)) {
            // 形式指标一
            for (SubTypeEnum value : SubTypeEnum.values()) {
                ScoreDataVO scoreDataVO = new ScoreDataVO();
                scoreDataVO.setSubType(value);
                List<DataScreenScoreVO> formalIndicators = formalIndicatorsYear.stream()
                        .filter(item -> item.getSubType().equals(value)).collect(
                                Collectors.toList());
                scoreDataVO.setMaxScore(formalIndicators.get(0).getMaxScore());
                Optional<Double> formalIndicatorsYearScore = formalIndicators.stream()
                        .map(DataScreenScoreVO::getScore)
                        .reduce(Double::sum);
                scoreDataVO.setScore(formalIndicatorsYearScore.orElse(0D));
                List<DataScreenScoreVO> formalIndicatorsListYear = tbDataScreenScoreService.selectIndicators(
                        areaCode, null, DataScreenConfigEnum.FORMAL_INDICATORS, 2);
                List<DataScreenScoreVO> formalIndicatorsLastYear = formalIndicatorsListYear.stream()
                        .filter(item -> item.getSubType().equals(value)).collect(
                                Collectors.toList());
                Optional<Double> formalIndicatorsListYearScore = formalIndicatorsLastYear.stream()
                        .map(DataScreenScoreVO::getScore)
                        .reduce(Double::sum);
                scoreDataVO.setLastScore(formalIndicatorsListYearScore.orElse(0D));
                scoreDataVOList.add(scoreDataVO);
            }
        } else {
            for (SubTypeEnum value : SubTypeEnum.values()) {
                ScoreDataVO scoreDataVO = new ScoreDataVO();
                scoreDataVO.setScore(0D);
                scoreDataVO.setLastScore(0D);
                scoreDataVO.setSubType(value);
                scoreDataVOList.add(scoreDataVO);
            }
        }

    }

    private void handleDataIndicators(String areaCode, List<ScoreRateDataVO> scoreRateDataVOList,
            String nowQuarter) {
        List<DataScreenScoreVO> dataIndicatorsListYear = tbDataScreenScoreService.selectIndicators(
                areaCode, nowQuarter, DataScreenConfigEnum.DATA_INDICATORS, null);
        if (CollUtils.isNotEmpty(dataIndicatorsListYear)) {
            for (SubTypeEnum value : SubTypeEnum.values()) {
                ScoreRateDataVO scoreRateDataVO = new ScoreRateDataVO();
                List<DataScreenScoreVO> formalIndicators = dataIndicatorsListYear.stream()
                        .filter(item -> item.getSubType().equals(value)).collect(
                                Collectors.toList());
                if (CollUtils.isNotEmpty(formalIndicators)) {
                    DataScreenScoreVO dataScreenScoreVO = formalIndicators.get(0);
                    scoreRateDataVO.setScore(dataScreenScoreVO.getScore());
                    scoreRateDataVO.setScoreRate(dataScreenScoreVO.getScoreRate());
                    scoreRateDataVO.setSubType(value);
                    Integer rank = tbDataScreenScoreService.getRankByScore(
                            dataScreenScoreVO.getScore(),
                            dataScreenScoreVO.getSubType(), areaCode, nowQuarter,
                            DataScreenConfigEnum.DATA_INDICATORS);
                    scoreRateDataVO.setRank(rank);
                    scoreRateDataVOList.add(scoreRateDataVO);
                } else {
                    scoreRateDataVO.setScore(0D);
                    scoreRateDataVO.setScoreRate(0D);
                    scoreRateDataVO.setSubType(value);
                    scoreRateDataVO.setRank(0);
                    scoreRateDataVOList.add(scoreRateDataVO);
                }
            }
        } else {
            for (SubTypeEnum value : SubTypeEnum.values()) {
                ScoreRateDataVO scoreRateDataVO = new ScoreRateDataVO();
                scoreRateDataVO.setScore(0D);
                scoreRateDataVO.setScoreRate(0D);
                scoreRateDataVO.setSubType(value);
                scoreRateDataVO.setRank(0);
                scoreRateDataVOList.add(scoreRateDataVO);
            }
        }
    }

    private List<FieldAndScoreDataVO> getFieldAndScoreData(List<FieldAndScoreDataVO> voList,
            String basicDataCategoryName) {
        return voList.stream()
                .filter(item -> item.getBasicDataCategoryName()
                        .equals(basicDataCategoryName))
                .collect(Collectors.toList());
    }

    public List<DeptCalculateDetailVO> deptCalculateDetail(DeptCalculateDetailQuery query)
            throws Exception {
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        return tbScoreService.deptCalculateDetail(query, previousQuarter);
    }

    public CurrentFieldsDetailVO viewRawData(String areaCode) throws Exception {
        String previousQuarter = DateUtils.getPreviousQuarter();
        previousQuarter = QuarterConstant.CURRENT_QUARTER;
        Optional<TbBasicData> basicDataOptional = tbBasicDataService.lambdaQuery()
                .eq(TbBasicData::getDeptAreaCode, areaCode)
                .eq(TbBasicData::getQuarter, previousQuarter).oneOpt();
        if (basicDataOptional.isPresent()) {
            return tbBasicDataService.fieldsDetails(basicDataOptional.get().getId()).getData();
        } else {
            return new CurrentFieldsDetailVO();
        }
    }

    public ScoreCalculateDetailVO fieldsDetail(CalculateDetailQuery query) {
        List<SysUser> countyList = getCountyList(query.getCityAreaCode());
        try {
            return tbScoreService.fieldsDetail(query, countyList);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public List<SysUser> getCountyList(String areaCode) {
        String cityCode = areaCode.substring(0, 4);
        if (areaCode.equals("510000")) {
            cityCode = areaCode.substring(0, 3);
        }
        List<SysUser> list = sysUserService.lambdaQuery()
                .select(SysUser::getAreaCode, SysUser::getAreaName, SysUser::getAreaAlias,
                        SysUser::getUserId).eq(SysUser::getUserType,
                        UserTypeEnum.DEPARTMENT)
                .likeRight(SysUser::getAreaCode, cityCode).or(cityCode.equals("5101"))
                .in(cityCode.equals("5101"), SysUser::getAreaCode, "510008", "510015", "510017",
                        "510025")
                .or(cityCode.equals("5106"))
                .eq(cityCode.equals("5106"), SysUser::getAreaCode, "510049")
                .or(cityCode.equals("5109"))
                .eq(cityCode.equals("5109"), SysUser::getAreaCode, "510077")
                .orderByAsc(!areaCode.equals("510100") && !areaCode.equals("510600")
                                && !areaCode.equals("510900"),
                        SysUser::getAreaCode)
                .list();
        return list;
    }
}