data-analysis/src/main/java/com/smppw/analysis/domain/service/impl/BaseInfoServiceImpl.java

package com.smppw.analysis.domain.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import com.smppw.analysis.domain.dao.*;
import com.smppw.analysis.domain.dao.nav.RongzhiIndexNavDao;
import com.smppw.analysis.domain.dao.rank.RankDao;
import com.smppw.analysis.domain.dao.rank.RankFactory;
import com.smppw.analysis.domain.dataobject.*;
import com.smppw.analysis.domain.dto.info.FundSimilarParams;
import com.smppw.analysis.domain.event.SaveCacheEvent;
import com.smppw.analysis.domain.gateway.CacheFactory;
import com.smppw.analysis.domain.gateway.CacheGateway;
import com.smppw.analysis.domain.mapper.core.CommonIndexMapper;
import com.smppw.analysis.domain.mapper.core.FundAssetSizeMapper;
import com.smppw.analysis.domain.mapper.core.MfChargeRateMapper;
import com.smppw.analysis.domain.mapper.core.PersonnelInformationMapper;
import com.smppw.analysis.domain.service.BaseInfoService;
import com.smppw.analysis.infrastructure.config.AnalysisProperty;
import com.smppw.analysis.infrastructure.consts.RedisConst;
import com.smppw.common.cache.CaffeineLocalCache;
import com.smppw.common.pojo.IStrategy;
import com.smppw.common.pojo.ValueLabelVO;
import com.smppw.common.pojo.enums.Frequency;
import com.smppw.common.pojo.enums.Indicator;
import com.smppw.constants.SecType;
import com.smppw.utils.StrategyHandleUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;

@Service
public class BaseInfoServiceImpl implements BaseInfoService, ApplicationContextAware {
    public static final String HF = "HF";
    public static final String MF = "MF";
    public static final String CF = "CF";
    public static final String FA = "FA";
    public static final String CI = "CI";
    public static final String CO = "CO";
    public static final String PL = "PL";
    public static final String PO = "PO";
    public static final String IN = "IN";
    public static final String AP = "AP";
    private static final Map<String, Boolean> INDEX_EXIST = MapUtil.newConcurrentHashMap();
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    private final RankFactory rankFactory;
    private final CacheGateway<Object> cacheGateway;
    private final IndexesProfileDao indexesProfileDao;
    private final RongzhiIndexNavDao rongzhiIndexNavDao;
    private final FundInformationDao fundInformationDao;
    private final FundAnnounceDao fundAnnounceDao;
    private final FundArchivesDao fundArchivesDao;
    private final MfChargeRateMapper mfChargeRateMapper;
    private final PersonnelInformationMapper personnelInformationMapper;
    private ApplicationContext applicationContext;
    private final FundAssetSizeMapper fundAssetSizeMapper;

    @Autowired
    private CommonIndexMapper commonIndexMapper;
    @Autowired
    private CompanyInformationDao companyInformationDao;
    @Autowired
    private PersonnelInformationDao personnelInformationDao;

    public BaseInfoServiceImpl(AnalysisProperty property, CacheFactory factory, RankFactory rankFactory,
                               IndexesProfileDao indexesProfileDao, RongzhiIndexNavDao rongzhiIndexNavDao,
                               FundInformationDao fundInformationDao, FundAnnounceDao fundAnnounceDao,
                               FundArchivesDao fundArchivesDao, MfChargeRateMapper mfChargeRateMapper,
                               PersonnelInformationMapper personnelInformationMapper, FundAssetSizeMapper fundAssetSizeMapper) {
        this.rankFactory = rankFactory;
        this.cacheGateway = factory.getCacheGateway(property.getCacheType());
        this.indexesProfileDao = indexesProfileDao;
        this.rongzhiIndexNavDao = rongzhiIndexNavDao;
        this.fundInformationDao = fundInformationDao;
        this.fundAnnounceDao = fundAnnounceDao;
        this.fundArchivesDao = fundArchivesDao;
        this.mfChargeRateMapper = mfChargeRateMapper;
        this.personnelInformationMapper = personnelInformationMapper;
        this.fundAssetSizeMapper = fundAssetSizeMapper;
    }

    @Override
    public void setApplicationContext(@NonNull ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public List<ValueLabelVO> getCommonIndexList() {
        List<CommonIndexDO> dataList = this.commonIndexMapper.selectList();
        return dataList.stream().map(e -> new ValueLabelVO(e.getIndexId(), e.getIndexName())).collect(Collectors.toList());
    }

    @Override
    public String getLatestRankRat(String appKey) {
        RankDao instance = rankFactory.getInstance(appKey);
        return instance.getRankDate();
    }

    @Override
    public String getLatestRankRat(String appKey, String refId) {
        RankDao instance = rankFactory.getInstance(appKey);
        return instance.getRankDate(refId);
    }

    @Override
    public String getSecType(String secId) {
        if (secId == null) {
            return null;
        }
        if (secId.startsWith(HF)) {
            return SecType.PRIVATELY_OFFERED_FUND;
        } else if (secId.startsWith(MF)) {
            return SecType.PUBLICLY_OFFERED_FUNDS;
        } else if (secId.startsWith(CF)) {
            return SecType.PRIVATE_FUND;
        } else if (secId.startsWith(FA)) {
            return SecType.FACTOR;
        } else if (secId.startsWith(CI)) {
            return SecType.UDF_INDEX;
        } else if (secId.startsWith(CO)) {
            return SecType.COMPANY;
        } else if (secId.startsWith(PL)) {
            return SecType.MANAGER;
        } else if (secId.startsWith(PO)) {
            return SecType.COMBINATION;
        } else if (StrUtil.isNumeric(secId)) {
            IStrategy strategy = StrategyHandleUtils.getStrategy(secId);
            if (strategy != null) {
                return SecType.STRATEGY;
            }
        } else if (secId.startsWith(IN)) {
            List<String> thirdIndexes = CaffeineLocalCache.getThirdIndexes();
            if (thirdIndexes != null && thirdIndexes.contains(secId)) {
                return SecType.THIRD_INDEX_FUND;
            }
            List<String> riskOfFreeIdList = CaffeineLocalCache.getRiskOfFreeId();
            if (riskOfFreeIdList != null && riskOfFreeIdList.contains(secId)) {
                return SecType.RISK_OF_FREE;
            }
            Boolean isExist = INDEX_EXIST.getOrDefault(secId, false);
            if (!isExist) {
                isExist = rongzhiIndexNavDao.isExist(secId);
                INDEX_EXIST.put(secId, isExist);
                return SecType.INDEX_FUND;
            } else {
                return SecType.RONGZHI_INDEX;
            }
        } else if (secId.startsWith(AP)) {
            return SecType.ADVISORY_POOL_CURVE;
        }
        return null;
    }

    @Override
    public Map<String, List<String>> getTypeSecMap(List<String> secIdList) {
        Map<String, List<String>> secIdTypeMap = new HashMap<>(10);
        for (String secId : secIdList) {
            String secIdType = getSecType(secId);
            if (secIdTypeMap.containsKey(secIdType)) {
                List<String> list = secIdTypeMap.get(secIdType);
                list.add(secId);
            } else {
                List<String> list = new ArrayList<>();
                list.add(secId);
                secIdTypeMap.put(secIdType, list);
            }
        }
        return secIdTypeMap;
    }

    @Override
    public Map<String, String> querySecsType(List<String> secIdList) {
        if (CollUtil.isEmpty(secIdList)) {
            return MapUtil.newHashMap(8);
        }
        return secIdList.stream().collect(Collectors.toMap(e -> e, this::getSecType));
    }

    @Override
    public Frequency getNavFrequency(String secId) {
        Frequency frequency;
        String fundType = this.getSecType(secId);
        if (SecType.MANAGER.equals(fundType) || SecType.COMPANY.equals(fundType)) {
            frequency = Frequency.Monthly;
        } else if (SecType.PRIVATELY_OFFERED_FUND.equals(fundType) ||
                SecType.PUBLICLY_OFFERED_FUNDS.equals(fundType) ||
                SecType.INDEX_FUND.equals(fundType) ||
                SecType.RONGZHI_INDEX.equals(fundType)) {
            String freq = this.fundInformationDao.getNavFrequencyByFundId(secId);
            if ("天".equals(freq)) {
                frequency = Frequency.Daily;
            } else if ("周".equals(freq)) {
                frequency = Frequency.Weekly;
            } else {
                frequency = Frequency.Monthly;
            }
        } else {
            frequency = Frequency.Daily;
        }
        return frequency;
    }

    @Override
    public Map<String, String> querySecName(List<String> allSecIdList) {
        if (CollUtil.isEmpty(allSecIdList)) {
            return MapUtil.empty();
        }
        int size = allSecIdList.size();
        String key = RedisConst.SEC_NAME;
        Map<String, Object> hget = this.cacheGateway.hget(key);
        if (MapUtil.isEmpty(hget)) {
            hget = MapUtil.empty();
        }
        Map<Boolean, List<String>> redisSecMap = allSecIdList.stream().collect(Collectors.groupingBy(hget::containsKey));
        List<String> redisSecIds = redisSecMap.getOrDefault(Boolean.TRUE, ListUtil.empty());
        List<String> noRedisSecIds = redisSecMap.getOrDefault(Boolean.FALSE, ListUtil.empty());
        Map<String, Object> secNameMap = MapUtil.newHashMap(size, false);
        if (CollUtil.isNotEmpty(noRedisSecIds)) {
            Map<String, List<String>> typeSecMap = this.getTypeSecMap(noRedisSecIds);
            // 市场基金
            List<String> marketFundIds = ListUtil.of(SecType.PRIVATELY_OFFERED_FUND, SecType.PUBLICLY_OFFERED_FUNDS);
            this.loadNameMap(secNameMap, typeSecMap, marketFundIds, this.fundInformationDao::getMarketFundIdNameMap);
            // 市场指数
            List<String> marketIndexIds = ListUtil.of(SecType.INDEX_FUND, SecType.RONGZHI_INDEX, SecType.THIRD_INDEX_FUND);
            this.loadNameMap(secNameMap, typeSecMap, marketIndexIds, this.indexesProfileDao::getFundIdNameMap);
            // 基金经理
            List<String> managerIds = ListUtil.of(SecType.MANAGER);
            this.loadNameMap(secNameMap, typeSecMap, managerIds, this.personnelInformationDao::getFundIdNameMap);
            // 基金管理人
            List<String> companyIds = ListUtil.of(SecType.COMPANY);
            this.loadNameMap(secNameMap, typeSecMap, companyIds, this.companyInformationDao::getFundIdNameMap);
            // 策略
            List<String> strategyIds = ListUtil.of(SecType.STRATEGY);
            this.loadNameMap(secNameMap, typeSecMap, strategyIds, this::getStrategyIdNameMap);
            // 推送事件，存缓存
            SaveCacheEvent<Map<String, Object>> event = new SaveCacheEvent<>(key, secNameMap, t -> {
                this.cacheGateway.hset(key, t);
                return this.cacheGateway.expire(key, 1, TimeUnit.DAYS);
            });
            this.applicationContext.publishEvent(event);
        }
        // 解决乱序问题
        Map<String, String> result = MapUtil.newHashMap(size, true);
        for (String secId : allSecIdList) {
            String name = redisSecIds.contains(secId) ? MapUtil.getStr(hget, secId) : MapUtil.getStr(secNameMap, secId);
            result.put(secId, name);
        }
        return result;
    }

    @Override
    public List<MonetaryFundProfitDO> queryMonetaryFund(String fundId) {
        return this.fundInformationDao.queryMonetaryFund(fundId);
    }

    @Override
    public List<Map<String, Object>> getFundRank(String rankDate, String fundId, List<String> indexIds, Indicator indicator) {
        return this.fundInformationDao.getFundRank(rankDate, fundId, indexIds, indicator);
    }

    @Override
    public List<FundSimilarDo> getFundSimilarList(FundSimilarParams params) {
        if (StrUtil.isBlank(params.getThreshold()) || !NumberUtil.isNumber(params.getThreshold())) {
            logger.warn(String.format("相关性阈值 %s 设置错误，提供默认值：%s", params.getThreshold(), FundSimilarParams.DEFAULT_THRESHOLD));
            params.setThreshold(FundSimilarParams.DEFAULT_THRESHOLD);
        }
        IStrategy strategy = StrategyHandleUtils.getStrategy(params.getStrategy());
        String rankDate = this.getLatestRankRat(params.getAppKey());
        List<FundSimilarDo> tempList = ListUtil.list(true);
        if (params.getCalcType() == 2) {
            Map<String, Object> req = MapUtil.<String, Object>builder().put("strategy", strategy.getStrategyId()).put("startDate", params.getStartDate())
                    .put("tableName", "rz_hfdb_core.nav").put("trustId", params.getTrustId()).put("rankDate", rankDate).build();
            tempList.addAll(this.fundInformationDao.getSameCompanyFundIds(req));
        } else {
            Map<String, Object> req = MapUtil.<String, Object>builder().put("strategy", strategy.getStrategyId()).put("rankNum", 50)
                    .put("tableName", "rz_hfdb_core.fund_indicator_ranking").put("fundId", params.getSecId()).put("rankDate", rankDate).build();
            tempList.addAll(this.fundInformationDao.getSameStrategyFundIds(req));
        }
        List<FundSimilarDo> dataList = ListUtil.list(true);
        // 过滤当前基金
        dataList.addAll(tempList.stream().filter(e -> !params.getSecId().equals(e.getFundId())).collect(Collectors.toList()));
        return dataList;
    }

    @Override
    public List<ManualFundNoticeInfoDO> queryFundAnnounce(String fundId, List<String> typeList, String title) {
        return fundAnnounceDao.queryFundAnnounce(fundId, typeList, title);
    }

    @Override
    public FundArchivesInfoDO queryFundArchives(String fundId) {
        return fundArchivesDao.getFundArchives(fundId);
    }

    @Override
    public FundFeeDo getFundFee(String fundId) {
        return fundInformationDao.getFundFee(fundId);
    }

    @Override
    public List<ManualFundFeeDo> getManualFundFee(String fundId) {
        return mfChargeRateMapper.getManualFundFee(fundId);
    }

    @Override
    public List<PersonnelInformationDo> getFundManagerInfo(String fundId) {
        return personnelInformationMapper.getFundManagerInfo(fundId);
    }

    @Override
    public List<PersonnelWorkExperienceDo> listPersonnelWorkExperience(List<String> personnelIdList) {
        return personnelInformationMapper.listPersonnelWorkExperience(personnelIdList);
    }

    @Override
    public List<ManualFundManagerChangeDo> listFundManagerChangeHistory(String fundId) {
        return fundInformationDao.listFundManagerChangeHistory(fundId);
    }

    @Override
    public List<MfManagerFundNumDo> listMfManagerFundNumByManagerId(List<String> managerIdList) {
        return fundInformationDao.listMfManagerFundNumByManagerId(managerIdList);
    }

    @Override
    public List<PersonnelInformationDo> getFundPresentManagerInfo(String refId) {
        return personnelInformationMapper.getFundPresentManagerInfo(refId);
    }

    @Override
    public List<ManualFundAssetSizeDo> getAssetSizeList(String managerId) {
        return fundAssetSizeMapper.getAssetSizeList(managerId);
    }

    @Override
    public PrivatelyFundBaseInfoDo listPrivatelyFundInfo(String fundId) {
        return fundInformationDao.listPrivatelyFundInfo(fundId);
    }

    @Override
    public List<FundManagerInfoDo> listFundManagerByFundId(String fundId) {
        return fundInformationDao.listFundManagerByFundId(fundId);
    }

    /**
     * 把指定类型的标的的名称映射查询出来
     *
     * @param secNameMap 保存的map
     * @param typeSecMap 指定类型对应的标的
     * @param types      指定类型列表
     * @param function   查询操作封装
     */
    private void loadNameMap(Map<String, Object> secNameMap, Map<String, List<String>> typeSecMap,
                             List<String> types, Function<List<String>, Map<String, String>> function) {
        List<String> refIds = ListUtil.list(true);
        for (String type : types) {
            CollUtil.addAllIfNotContains(refIds, typeSecMap.getOrDefault(type, ListUtil.empty()));
        }
        if (CollUtil.isNotEmpty(refIds)) {
            secNameMap.putAll(function.apply(refIds));
        }
    }

    private Map<String, String> getStrategyIdNameMap(List<String> strategyIds) {
        if (CollUtil.isEmpty(strategyIds)) {
            return MapUtil.empty();
        }
        Map<String, String> result = MapUtil.newHashMap(strategyIds.size(), true);
        for (String strategyId : strategyIds) {
            result.put(strategyId, StrategyHandleUtils.getStrategy(strategyId).getStrategyNameDesc());
        }
        return result;
    }
}