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.system.domain.TbBasicData;
import com.finance.system.domain.TbBasicDataCategory;
import com.finance.system.domain.TbDataScreenScore;
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 java.util.ArrayList;
import java.util.List;
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("省本级");
        int cityCount = getCount("市");
        int developmentZonesCount = getCount("开发区");
        int countyCount = getCount("县");

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

    private int getCount(String 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 {
        String nowQuarter = DateUtils.getNowQuarter();
        RiskAndTransferVO riskAndTransferVO = new RiskAndTransferVO();
        //查询转移支付规模总额
        List<TbBasicData> list = tbBasicDataService.lambdaQuery()
                .select(TbBasicData::getTransferPaymentScale)
                .eq(TbBasicData::getQuarter, nowQuarter)
                .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<TbDataScreenScore> dataScreenScoreList = tbDataScreenScoreService.selectRiskByQuarter(
                nowQuarter, riskLevel.getId(), null);
        for (RiskLevelVO vo : riskLevelVOList) {
            long count = dataScreenScoreList.stream()
                    .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);
        List<RiskRankingVO> voList = tbDataScreenScoreService.queryRiskRanking(riskLevel.getId(),
                DateUtils.getNowQuarter(), AreaLevelEnum.COUNTY);
        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 {
        List<TbQuestion> list = tbQuestionService.lambdaQuery()
                .eq(TbQuestion::getQuarter, DateUtils.getNowQuarter()).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 nowQuarter = DateUtils.getNowQuarter();
        //查询问题
        List<TbQuestion> list = tbQuestionService.lambdaQuery()
                .eq(TbQuestion::getQuarter, nowQuarter).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);
        List<DataScreenScoreVO> thisYearScore = tbDataScreenScoreService.queryScoreByAreaAndYear(
                areaCode, riskLevel.getId(), 1);
        Optional<Double> thisYear = thisYearScore.stream().map(DataScreenScoreVO::getScore)
                .reduce(Double::sum);
        dataAnalysisVO.setYearScore(thisYear.orElse(0D));
        List<DataScreenScoreVO> lastYearScore = tbDataScreenScoreService.queryScoreByAreaAndYear(
                areaCode, riskLevel.getId(), 2);
        Optional<Double> lastYear = lastYearScore.stream().map(DataScreenScoreVO::getScore)
                .reduce(Double::sum);
        dataAnalysisVO.setLastYearScore(lastYear.orElse(0D));
        //查询风险等级
        List<TbDataScreenScore> dataScreenScoreList = tbDataScreenScoreService.selectRiskByQuarter(
                nowQuarter,
                riskLevel.getId(), areaCode);
        for (TbDataScreenScore tbDataScreenScore : dataScreenScoreList) {
            for (RiskLevelVO vo : riskLevelVOList) {
                if (vo.getRiskLevel().equals(RiskLevelEnum.L1)
                        && tbDataScreenScore.getScore() <= vo.getMin()) {
                    dataAnalysisVO.setRiskLevel(vo.getRiskLevel().getCode());
                }
                if (tbDataScreenScore.getScore() >= vo.getMin()
                        && tbDataScreenScore.getScore() <= vo.getMax()) {
                    dataAnalysisVO.setRiskLevel(vo.getRiskLevel().getCode());
                }
                if (vo.getRiskLevel().equals(RiskLevelEnum.L4)
                        && tbDataScreenScore.getScore() >= vo.getMax()) {
                    dataAnalysisVO.setRiskLevel(vo.getRiskLevel().getCode());
                }
            }
        }
        //查询形式指标得分
        List<ScoreDataVO> scoreDataVOList = new ArrayList<>();
        handleDataIndicators(areaCode, scoreDataVOList);
        dataAnalysisVO.setScoreDataList(scoreDataVOList);
        //查询数据指标得分
        List<ScoreRateDataVO> scoreRateDataVOList = new ArrayList<>();
        handleDataIndicators(areaCode, scoreRateDataVOList, nowQuarter);
        dataAnalysisVO.setScoreRateDataList(scoreRateDataVOList);
        //查询大屏下方字段列表
        List<TbBasicDataCategory> categoryList = tbBasicDataCategoryService.lambdaQuery()
                .eq(TbBasicDataCategory::getStatus, ShowStatusEnum.SHOW).last("limit 4").list();
        List<FieldAndScoreDataVO> voList = tbBasicDataService.selectBasicDataFieldsConfig(areaCode,
                nowQuarter);
        if (categoryList.isEmpty()) {
            dataAnalysisVO.setScoreRateDataListOne(CollUtils.emptyList());
            dataAnalysisVO.setScoreRateDataListTwo(CollUtils.emptyList());
            dataAnalysisVO.setScoreRateDataListThree(CollUtils.emptyList());
            dataAnalysisVO.setScoreRateDataListFour(CollUtils.emptyList());
        } else {
            int size = categoryList.size();
            for (int i = 0; i < 4; i++) {
                List<FieldAndScoreDataVO> dataList;
                if (i < size) {
                    dataList = getFieldAndScoreData(voList,
                            categoryList.get(i).getBasicDataCategoryName());
                } else {
                    dataList = CollUtils.emptyList();
                }
                switch (i) {
                    case 0:
                        dataAnalysisVO.setScoreRateDataListOne(dataList);
                        break;
                    case 1:
                        dataAnalysisVO.setScoreRateDataListTwo(dataList);
                        break;
                    case 2:
                        dataAnalysisVO.setScoreRateDataListThree(dataList);
                        break;
                    case 3:
                        dataAnalysisVO.setScoreRateDataListFour(dataList);
                        break;
                }
            }
        }
        return dataAnalysisVO;
    }

    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 {
        return tbScoreService.deptCalculateDetail(query, DateUtils.getNowQuarter());
    }

    public CurrentFieldsDetailVO viewRawData(String areaCode) throws Exception {
        Optional<TbBasicData> basicDataOptional = tbBasicDataService.lambdaQuery()
                .eq(TbBasicData::getDeptAreaCode, areaCode)
                .eq(TbBasicData::getStatus, ReportingStatusEnum.FILLED)
                .eq(TbBasicData::getQuarter, DateUtils.getNowQuarter()).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());
        return tbScoreService.fieldsDetail(query, countyList);
    }

    public List<SysUser> getCountyList(String areaCode) {
        String cityCode = areaCode.substring(0, 4);
        List<SysUser> list = sysUserService.lambdaQuery()
                .select(SysUser::getAreaCode, SysUser::getAreaName, SysUser::getAreaAlias,
                        SysUser::getUserId).eq(SysUser::getUserType,
                        UserTypeEnum.DEPARTMENT)
                .ne(SysUser::getAreaCode, areaCode)
                .likeRight(SysUser::getAreaCode, cityCode).list();
        return list;
    }
}