java-insagent-pc/src/main/java/com/ydtech/modules/partner/service/Impl/PartnerUserServiceImpl.java

package com.ydtech.modules.partner.service.Impl;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.core.page.HttpResult;
import com.ydtech.modules.admin.controller.SysUserController;
import com.ydtech.modules.admin.dao.SysPartnerConfigMapper;
import com.ydtech.modules.admin.dao.SysUserMapper;
import com.ydtech.modules.admin.model.SysUser;
import com.ydtech.modules.admin.model.vo.AppUserInfoVo;
import com.ydtech.modules.admin.model.vo.SysUser2Vo;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.esm.dao.EsmUserImageMapper;
import com.ydtech.modules.esm.model.EsmUserImage;
import com.ydtech.modules.order.dao.InsUploadFilesMapper;
import com.ydtech.modules.order.entity.api.zhongmei.constants.TimeConstants;
import com.ydtech.modules.order.entity.po.InsUploadFiles;
import com.ydtech.modules.partner.CalculateCommissionUtils;
import com.ydtech.modules.partner.dao.PartnerPartnerAccountMapper;
import com.ydtech.modules.partner.dao.PartnerPremiumDetailsMapper;
import com.ydtech.modules.partner.dao.PartnerUserMapper;
import com.ydtech.modules.partner.model.*;
import com.ydtech.modules.partner.model.param.AppHomeParams;
import com.ydtech.modules.partner.model.param.PartnerRuleEntity;
import com.ydtech.modules.partner.model.param.QueryVo;
import com.ydtech.modules.partner.model.param.UserGradeParam;
import com.ydtech.modules.partner.model.vo.*;
import com.ydtech.modules.partner.service.PartnerLiftingRecordService;
import com.ydtech.modules.partner.service.PartnerRuleService;
import com.ydtech.modules.partner.service.PartnerUserService;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.stream.Collectors;

import static net.sf.jsqlparser.parser.feature.Feature.values;

@Service
public class PartnerUserServiceImpl extends ServiceImpl<PartnerUserMapper, PartnerUser> implements PartnerUserService {


    @Autowired
    private PartnerRuleService ruleService;

    @Autowired
    private PartnerLiftingRecordService liftingRecordService;

    @Resource
    private SysUserMapper sysUserMapper;

    @Autowired
    private InsUploadFilesMapper uploadFilesMapper;

    @Autowired
    private PartnerPartnerAccountMapper partnerPartnerAccountMapper;

    @Autowired
    private PartnerPremiumDetailsMapper detailsMapper;


    @Override
    public int insert(PartnerUser partnerUser) {
        return baseMapper.insert(partnerUser);
    }

    @Override
    public IPage<PartnerUserVo> queryPage(QueryVo queryVo) {
        IPage<PartnerUserVo> page = baseMapper.queryPage(queryVo.getPage(),queryVo);
        return page;
    }

    @Override
    public List<RelationalVo>  relationalQuery(String id) {
        List<RelationalVo> list = new ArrayList<>();

        Integer grade = baseMapper.selectGradeIntMin(id);
        List<RelationalVo> partnerUsers = baseMapper.selectByUserId(id,grade);
        if (1 < grade){
            querySuperiors(list, grade,partnerUsers);
        }
        list.addAll(partnerUsers);
        querySubordinates(partnerUsers, grade,list);
        return list;
    }

    public void querySuperiors(List<RelationalVo> list,Integer grade,List<RelationalVo> partnerUsers){
        if (CollectionUtil.isEmpty(partnerUsers)){
            return;
        }
        String userId = partnerUsers.get(0).getUserId();
        grade --;
        List<RelationalVo> relationalVos = baseMapper.selectQuerySuperiors(userId,grade);
        list.addAll(relationalVos);
        querySuperiors( list, grade, relationalVos);
    }


    public void querySubordinates(List<RelationalVo> partnerUsers,Integer grade,List<RelationalVo> list){
        if (CollectionUtil.isEmpty(partnerUsers)){
            return;
        }
        String userId = partnerUsers.get(0).getUserId();
        grade ++;
        List<RelationalVo> relationalVos = baseMapper.selectByReferrerId(userId,grade);
        list.addAll(relationalVos);
        querySubordinates(relationalVos, grade,list);
    }


    public void querySubordinates(List<PartnerUser> list,  PartnerUser partnerUser){
        while (partnerUser != null && StringUtils.isNotBlank(partnerUser.getUserId())) {
            PartnerUser one = baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getReferrerId, partnerUser.getUserId()));
            list.add(one);
            querySubordinates( list,one);
        }
    }


    @Override
    public List<Map<String, String>> selectRecommender(String level) {
        if (StringUtils.isEmpty(level)){
            return new ArrayList<>(0);
        }
        if (StringUtils.equals(level,"2")){
            level = "1";
        }else if (StringUtils.equals(level,"3")){
            level = "2";
        }else if (StringUtils.equals(level,"4")){
            level = "3";
        }
        return baseMapper.selectRecommender(level);
    }

    @Override
    public HttpResult verifyUpgradeConditions(UserGradeParam userGradeParam) {
        if (StringUtils.isBlank(userGradeParam.getGrade())){
            return HttpResult.error("参数不能为空");
        }
        String grade = userGradeParam.getGrade();

        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id",userGradeParam.getId());
        queryWrapper.eq("grade",Integer.valueOf(grade) - 1 );
        Long count = baseMapper.selectCount(queryWrapper);
        if (count > 0){
            return HttpResult.error();
        }
        if (ruleService.verifyUpgradeConditions(userGradeParam.getId(),userGradeParam.getGrade())){
            return HttpResult.ok("满足升级条件");
        }
        return HttpResult.error("不满足升级条件");
    }

    @Override
    public HttpResult submitLiftingRecord(UserGradeParam userGradeParam) {
        if (StringUtils.equals("1",userGradeParam.getGrade())){
            return HttpResult.error("当前用户无法升级");
        }
        LambdaQueryWrapper<PartnerUser> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(PartnerUser::getUserId,userGradeParam.getId());
        lambdaQueryWrapper.eq(PartnerUser::getGrade,userGradeParam.getGrade());
        PartnerUser partnerUser = baseMapper.selectOne(lambdaQueryWrapper);
        //   条件
        PartnerRuleEntity ruleEntity = ruleService.selectByGrade(userGradeParam.getGrade());
        PartnerLiftingRecord record = new PartnerLiftingRecord();
        record.setName(partnerUser.getName());
        record.setMobile(partnerUser.getMobile());
        record.setUserId(partnerUser.getUserId());
        record.setDeptId(partnerUser.getDeptId());
        record.setDeptName(partnerUser.getDeptName());
        record.setType("0");
        record.setOriginalLevel(userGradeParam.getGrade());
        switch (userGradeParam.getGrade()) {
            case "1":
                record.setAfterChange("");
                break;
            case "2":
                record.setAfterChange("1");
                break;
            case "3":
                record.setAfterChange("2");
                break;
            case "4":
                record.setAfterChange("3");
                break;

        }
        record.setCycle(getMessage(ruleEntity));
        record.setUpgradeStrategy(ruleService.verifyUpgradeConditionsMessage(userGradeParam.getId(),userGradeParam.getGrade()));
        return liftingRecordService.saveLiftingRecord(record);
    }


    public String getMessage(PartnerRuleEntity ruleEntity){
        String message = "";
        PartnerAttribute entityCycle = ruleEntity.getCycle();
        switch (entityCycle.getCycle()){
            case "1":
                message = "成为该等级后，无限期";
                break;
            case "2":
                message = "成为该等级后，限期" + entityCycle.getFixedDays() + "天";
                break;
            case "3":
                message = "成为该等级后，固定限期" + entityCycle.getMin() + "至" + entityCycle.getMax();
                break;
        }
        return message;
    }



    @Override
    public HttpResult getHomePage(AppHomeParams params) {
        Set<String> list = new HashSet<>();
        getLevelUserId(params.getUserId(),list);
        //List<String> strings = baseMapper.selectRelatedPerList(params.getUserId(), params);
        list.add(params.getUserId());
        params.setRelatedPerList(list);
        params.setCountCycle("Day");
        HomeVo homeVo = new HomeVo();
        TodayOverview overview = new TodayOverview();
        if (CollectionUtil.isNotEmpty(list)){
            overview = baseMapper.selectTodayOverview(params);
            homeVo.setTodayOverview(overview);
        }else {
            homeVo.setTodayOverview(overview);
        }
        //查询当前用户等级
        List<TeamOverviewVo> teamOverviewVos = baseMapper.selectTeamOverview(params);
        for (TeamOverviewVo overviewVo : teamOverviewVos) {
            switch (overviewVo.getGrade()){
                case "1":
                    overviewVo.setVo1(baseMapper.selectStatistics(overviewVo.getGrade(), params));
                    break;
                case "2":
                    overviewVo.setVo2(baseMapper.selectStatistics(overviewVo.getGrade(), params));
                    break;
                case "3":
                    overviewVo.setVo3(baseMapper.selectStatistics(overviewVo.getGrade(), params));
                    break;
                case "4":
                    overviewVo.setVo4(baseMapper.selectStatistics(overviewVo.getGrade(), params));
                    break;
            }
        }
        homeVo.setTeamOverview(teamOverviewVos);
        return HttpResult.ok(homeVo);
    }

    @Override
    public void getLevelUserId(String userId,Set<String> list){
        List<String> level = baseMapper.selectByLevelUserId(userId);
        if (CollectionUtil.isNotEmpty(level)){
            level.removeIf(s -> s.equals(userId));
        }
        if (CollectionUtil.isEmpty(level)){
            return;
        }
        if ( containsOnlyId(level, userId)){
            return;
        }
        if (CollectionUtil.isNotEmpty(level)){
            list.addAll(level);
            for (String s : level) {
                getLevelUserId(s,list);
            }
        }
    }

    @Override
    public List<String> getUserGradeList(String userId) {
        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        List<PartnerUser> partnerUsers = baseMapper.selectList(queryWrapper);
        return partnerUsers.stream()
                .map(user -> String.valueOf(user.getGrade()))
                .collect(Collectors.toList());
    }

    @Override
    public HttpResult addUserIdentity(Map<String, Object> map) {
        try {
            if (map.containsKey("userId")){
                String userId = (String) map.get("userId");
                PartnerUser partnerUsers = baseMapper.selectMaxGradeUserId(userId);
                if (partnerUsers == null){
                    return HttpResult.error("请选择用户");
                }
                if (StringUtils.equals("4",String.valueOf(partnerUsers.getGrade()))){
                    return HttpResult.error("请邀请团队长");
                }
                if (map.containsKey("gradeList")){
                    List<String> list = (ArrayList<String>)  map.get("gradeList");
                    List<String> gradeList = list.stream()
                            .sorted(Comparator.comparingInt(Integer::parseInt))
                            .collect(Collectors.toList());
                    if (partnerUsers != null && CollectionUtil.isNotEmpty(gradeList)){
                        SysUser sysUser = sysUserMapper.selectById(userId);
                        for (String s : gradeList) {
                            PartnerUser partnerUser = new PartnerUser();
                            partnerUser.setName(sysUser.getName());
                            partnerUser.setMobile(sysUser.getMobile());
                            partnerUser.setUserId(sysUser.getId());
                            partnerUser.setDeptId(sysUser.getDeptId());
                            partnerUser.setDeptName(sysUser.getDeptName());
                            partnerUser.setGrade(Integer.valueOf(s));
                            partnerUser.setReferrerId(partnerUsers.getUserId());
                            baseMapper.insert(partnerUser);
//                        if (StringUtils.equals("4",s)){
//                            sysUser.setGrade(4);
//                            SysUser2Vo sysUser2Vo = getUser2Vo(sysUser,partnerUser.getUserId());
//                            SpringUtil.getBean(SysUserController.class).newSaveUserInfoByPartner(sysUser2Vo);
//                        }
                        }
                    }
                }
            }
        }catch (Exception e){
            log.error("添加失败",e);
            return HttpResult.error();
        }
        return HttpResult.ok("添加成功");
    }

    private static SysUser2Vo getUser2Vo(SysUser sysUser,String id) {
        SysUser2Vo sysUser2Vo = new SysUser2Vo();
        SysUser user = new SysUser();
        user.setName(sysUser.getName());
        user.setMobile(sysUser.getMobile());
        user.setIdentity(sysUser.getIdentity());
        user.setPassword(sysUser.getPassword());
        user.setRoleId("21");
        user.setReferrerId(id);
        user.setDeptSource("2");
        user.setGrade(4);
        sysUser2Vo.setSysUser( user);
        return sysUser2Vo;
    }

    public static boolean containsOnlyId(List<String> list, String targetId) {
        return list != null
                && !list.isEmpty()
                && list.stream().allMatch(targetId::equals);
    }


    @Override
    public void deleteByUserId(String id) {
        baseMapper.deleteByUserId(id);
    }

    @Override
    public HttpResult selectUser(AppHomeParams params) {
        return HttpResult.ok(baseMapper.selectUser(params));
    }

    public Integer queryLevel(Integer grade){
        if (!Objects.isNull(grade)){
            switch (grade){
                case 1:
                    return  2;
                case 2:
                    return 3;
                case 3:
                    return 4;
                case 4:
                    return 5;
            }
        }
        return 1;
    }

    public Map<Integer, String> getRule() {
        List<PartnerRule> partnerRules = ruleService.selectAll();
        Map<Integer, String> ruleMap = partnerRules.stream()
                .collect(Collectors.toMap(
                        PartnerRule::getGrade,
                        rule -> rule.getGradeName() != null ? rule.getGradeName() : "",
                        (existing, replacement) -> existing
                ));
        ruleMap.put(5, "团队长");
        ruleMap.put(6, "业务员");
        return ruleMap;
    }

    @Override
    public HttpResult userCountVo(AppHomeParams params) {
        PartnerUser minGrade = baseMapper.selectGradeMin(params.getUserId());
        if (minGrade == null) {
            return HttpResult.error("人员不存在");
        }
        Map<Integer, String> rule = getRule();
        Map<String, Object> vo = new HashMap<>();
        vo.put("vo1", getV1(minGrade, params, rule));
        vo.put("vo2", getVo2(minGrade, params, rule));
        vo.put("vo3", getVo3(minGrade, params, rule));
        vo.put("vo4", getVo4(minGrade, params, rule));
        return HttpResult.ok(vo);
    }


    /**
     *


     List<Student> sortedList = list.stream()
     .sorted(
     Comparator.comparing(Student::getSort)                     // 按 sort 升序
     .thenComparing(
     Student::getCreateTime,
     Comparator.nullsFirst(Comparator.reverseOrder())     // 创建时间降序，空值优先
     )
     )
     .collect(Collectors.toList());


     *
     *
     */

    @Override
    public HttpResult selectByIdList(String id) {
        if (StringUtils.isEmpty(id)) {
            return HttpResult.error("ID不能为空");
        }
        PartnerUser partnerUser = baseMapper.selectById(id);
        if (ObjectUtils.isEmpty(partnerUser)) {
            return HttpResult.error("人员不存在");
        }
        JSONObject referrerInfo = new JSONObject();
        referrerInfo.put("referrerGrade",baseMapper.selectByUserIdGrade(partnerUser.getUserId()));
        referrerInfo.put("referrerName",baseMapper.selectByUserIdUserName(partnerUser.getUserId()));
        referrerInfo.put("mobile",partnerUser.getMobile());
        referrerInfo.put("userName",partnerUser.getName());
        HashMap<String, Object> map = new HashMap<>();
        map.put("list",buildUserHierarchyResult(partnerUser.getUserId(), null));
        map.put("referrer",referrerInfo);
        return HttpResult.ok(map);
    }

    @Override
    public HttpResult selectByGradeList(Map<String,String> paeramsMap, String userId) {
        if (StringUtils.isEmpty(userId) || StringUtils.isEmpty(paeramsMap.get("grade"))) {
            return HttpResult.error("用户ID和等级不能为空");
        }
        AppHomeParams params = new AppHomeParams();
        params.setUserId(userId);
        List<TeamOverviewVo> teamOverviewVos = baseMapper.selectTeamOverview(params);
        List<Object> list = new ArrayList<>();
        for (TeamOverviewVo overviewVo : teamOverviewVos) {
            HashMap<String, Object> map = new HashMap<>();
            map.put("grade",overviewVo.getGrade());
            map.put("gradeName",overviewVo.getGradeName());
            PartnerUser partnerUser = baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class)
                    .eq(PartnerUser::getUserId, userId)
                    .ge((CollectionUtil.isNotEmpty(paeramsMap) && paeramsMap.containsKey("startTime") && StringUtils.isNotEmpty(paeramsMap.get("startTime"))),
                            PartnerUser::getCreateTime, paeramsMap.get("startTime") + " " + TimeConstants.START_TIME)
                    .le((CollectionUtil.isNotEmpty(paeramsMap) && paeramsMap.containsKey("endTime") && StringUtils.isNotEmpty(paeramsMap.get("endTime"))),
                            PartnerUser::getCreateTime, paeramsMap.get("endTime") + " " + TimeConstants.END_TIME)
                    .eq(PartnerUser::getGrade, paeramsMap.get("grade")));
            List<JSONObject> object = new ArrayList<>();
            if (ObjectUtils.isNotEmpty(partnerUser)) {
                object = buildUserHierarchyResult(partnerUser.getUserId(),paeramsMap);
            }
            map.put("data",object);
            list.add(map);
        }
        return HttpResult.ok(list);
    }

    @Override
    public Object myPerformance(Map<String, String> map) {
        Set<String> setList = new HashSet<>();
        getLevelUserId(map.get("userId"),setList);
        JSONObject totalMap = baseMapper.myPerformanceTotal(map,setList);
        List<JSONObject> datalist = baseMapper.queryDataList(map,setList);
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("data",datalist);
        hashMap.put("total",totalMap);
        return hashMap;
    }

    @Override
    public HttpResult myPerformanceDetails(String ordersNo) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("ordersNo",1);
        jsonObject.put("carId",1);
        //收入类型
        jsonObject.put("incomeType",1);
        //代理人
        jsonObject.put("agent",1);
        //所属团队
        jsonObject.put("belongingTeam",1);
        // 保费
        jsonObject.put("premium",1);
        //佣金
        jsonObject.put("commission",1);
        //出单时间
        jsonObject.put("orderTime",1);
        // 佣金比例
        ArrayList<Object> list = new ArrayList<>();
        JSONObject object = new JSONObject();
        object.put("grade","我的创始人佣金");
        object.put("commission","26738.48*1%=140");
        list.add(object);
        jsonObject.put("commissionRatio",list);
        return HttpResult.ok(jsonObject);
    }

    @Override
    public HttpResult avatarUpdate(PartnerUser partnerUser) {
        PartnerUser user = new PartnerUser();
        user.setPictureUrl(partnerUser.getPictureUrl());
        return baseMapper.update(user,new LambdaQueryWrapper<>(PartnerUser.class)
                .eq(PartnerUser::getUserId, partnerUser.getUserId())
        ) > 0 ? HttpResult.ok("保存成功") : HttpResult.error("保存失败");
    }

    @Override
    public HttpResult userCountStatisticsVo(AppHomeParams params) {
        PartnerUser minGrade = baseMapper.selectGradeMin(params.getUserId());
        if (minGrade == null) {
            return HttpResult.error("人员不存在");
        }
        Map<Integer, String> rule = getRule();
        Map<String, Object> vo = new HashMap<>();
        vo.put("vo1", getV1(minGrade, params, rule));
        vo.put("vo2", getVo2(minGrade, params, rule));
        return HttpResult.ok(vo);
    }

    @Override
    public HttpResult userCountProportionVo(AppHomeParams params) {
        PartnerUser minGrade = baseMapper.selectGradeMin(params.getUserId());
        if (minGrade == null) {
            return HttpResult.error("人员不存在");
        }
        Map<Integer, String> rule = getRule();
        List<JSONObject> vo3 = getVo3(minGrade, params, rule);
        return HttpResult.ok(vo3);
    }

    @Override
    public HttpResult userCountRankingVo(AppHomeParams params) {
        PartnerUser minGrade = baseMapper.selectGradeMin(params.getUserId());
        if (minGrade == null) {
            return HttpResult.error("人员不存在");
        }
        Map<Integer, String> rule = getRule();
        List<JSONObject> vo4 = getVo4(minGrade, params, rule);
        return HttpResult.ok(vo4);
    }


    private List<JSONObject> buildUserHierarchyResult(String userId, Map<String,String> paeramsMap) {
        Map<Integer, String> rule = getRule();
        List<JSONObject> list = new ArrayList<>();
        getLevelUser(userId,list, rule,paeramsMap);
        return  getSort(list);
    }

    @Override
    public boolean selectByUserIdList(String id) {
        List<PartnerUser> partnerUsers = baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getUserId, id));
        for (PartnerUser partnerUser : partnerUsers) {
            if (partnerUser.getGrade() > 4){
                return false;
            }
        }


        return CollectionUtil.isNotEmpty(partnerUsers) ? true : false;
    }

    @Override
    public AppUserInfoVo getUserInfo(Integer type) {
        String userId = BaseController.getUserId();
        AppUserInfoVo appUserInfoVo = sysUserMapper.queryByUserId(userId);
        Integer min = baseMapper.selectGradeIntMin(userId);
        appUserInfoVo.setGrade(min);
        PartnerUser partnerUser = baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class)
                .eq(PartnerUser::getUserId, userId)
                .eq(PartnerUser::getGrade, min));
        InsUploadFiles insUploadFiles = uploadFilesMapper.selectById(partnerUser.getPictureUrl());
        appUserInfoVo.setInsUploadFiles(insUploadFiles);
        return appUserInfoVo;
    }



    public List<JSONObject> getSort(List<JSONObject> list) {
        return list.stream()
                .sorted(Comparator.comparing(
                                jo -> parseSortField(JSONObject.parseObject(jo.toString())),
                                Comparator.nullsLast(Comparator.naturalOrder()))
                        .thenComparing(
                                jo -> parseCreateTime(JSONObject.parseObject(jo.toString())),
                                Comparator.nullsFirst(Comparator.naturalOrder())))
                .collect(Collectors.toList());
    }

    private static Integer parseSortField(JSONObject obj) {
        if (obj == null) {
            return 0;
        }
        Object value = obj.get("grade");
        if (value instanceof Number) {
            return ((Number) value).intValue();
        } else if (value instanceof String) {
            try {
                return Integer.parseInt(value.toString());
            } catch (NumberFormatException e) {
                return 0;
            }
        }
        return 0;
    }

    private static LocalDateTime parseCreateTime(JSONObject obj) {
        if (obj == null) {
            return LocalDateTime.MIN;
        }
        Object valueObj = obj.get("createTime");
        if (valueObj == null) {
            return LocalDateTime.MIN;
        }

        String value = valueObj.toString().trim();
        if (value.isEmpty()) {
            return LocalDateTime.MIN;
        }

        try {
            long epochSecond = Long.parseLong(value);
            return LocalDateTime.ofInstant(Instant.ofEpochSecond(epochSecond), ZoneId.systemDefault());
        } catch (NumberFormatException e) {
            return LocalDateTime.MIN;
        }
    }



    public void getLevelUser(String userId, List<JSONObject> list,Map<Integer, String> rule,Map<String,String> paeramsMap){
        LambdaQueryWrapper<PartnerUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PartnerUser::getReferrerId,userId);
        if (CollectionUtil.isNotEmpty(paeramsMap) && paeramsMap.containsKey("startTime") && StringUtils.isNotEmpty(paeramsMap.get("startTime"))){
            queryWrapper.ge(PartnerUser::getCreateTime, paeramsMap.get("startTime") + " " + TimeConstants.START_TIME);
        }
        if (CollectionUtil.isNotEmpty(paeramsMap) && paeramsMap.containsKey("endTime") && StringUtils.isNotEmpty(paeramsMap.get("endTime"))){
            queryWrapper.le(PartnerUser::getCreateTime, paeramsMap.get("endTime") + " " + TimeConstants.END_TIME);
        }
        List<PartnerUser> partnerUsers = baseMapper.selectList(queryWrapper);
        for (PartnerUser partnerUser : partnerUsers) {
            Set<String> set = new HashSet<>();
            set.add(partnerUser.getUserId());
            getLevelUserId(partnerUser.getUserId(), set);
            QueryWrapper<PartnerPremiumDetails> wrapper = new QueryWrapper<>();
            wrapper.in("user_id",set);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("id",partnerUser.getId());
            jsonObject.put("userName", partnerUser.getName());
            jsonObject.put("grade", partnerUser.getGrade());
            jsonObject.put("createTime", partnerUser.getCreateTime());
            jsonObject.put("gradeName", rule.getOrDefault(Integer.valueOf(partnerUser.getGrade() + 1), ""));
            jsonObject.put("number", countByUserIdLevel(partnerUser.getUserId()));
            BigDecimal premium = detailsMapper.selectTotalSumPremium(wrapper);
            jsonObject.put("premium", premium == null ? BigDecimal.ZERO : premium);
            BigDecimal commission = detailsMapper.selectTotalCommission(wrapper);
            jsonObject.put("commission",commission == null ? BigDecimal.ZERO : commission);
            list.add(jsonObject);
            //getLevelUser( partnerUser.getUserId(), list, rule);
        }

    }

    public Long countByUserIdLevel(String userId){
        if (Objects.isNull(userId)){
            return Long.parseLong("0");
        }
        return baseMapper.selectCount(new LambdaQueryWrapper<PartnerUser>().eq(PartnerUser::getReferrerId, userId));
    }



    public List<JSONObject> getVo4(PartnerUser minGrade, AppHomeParams params, Map<Integer, String> rule) {
        Integer grade = queryLevel(minGrade.getGrade());
        List<JSONObject> list = new ArrayList<>();
        List<String> currentUserIds = new ArrayList<>();
        currentUserIds.add(minGrade.getUserId());

        while (grade < 7) {
            List<PartnerUser> currentUserList = new ArrayList<>();
            if (CollectionUtil.isNotEmpty(currentUserIds)) {
                currentUserList = baseMapper.selectJuniorListUser(grade, currentUserIds, params);
                currentUserIds = currentUserList.stream().map(PartnerUser::getUserId).collect(Collectors.toList());
            }
            getVo4Data(list, grade, currentUserList, params, rule);
            if ((minGrade.getGrade() >= 1 && minGrade.getGrade() <= 3 && grade == 4) ||
                    (minGrade.getGrade() == 4 && grade == 5)) {
                break;
            }
            grade++;
        }
        return list;
    }

    public void getVo4Data(List<JSONObject> list, int grade, List<PartnerUser> currentUser, AppHomeParams params, Map<Integer, String> rule) {
        JSONObject object = new JSONObject();
        object.put("grade", grade);
        object.put("gradeName", rule.getOrDefault(grade, ""));
        List<JSONObject> arrayList = new ArrayList<>();

        for (PartnerUser user : currentUser) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("id", user.getId());
            jsonObject.put("userName", user.getName());
            jsonObject.put("number", baseMapper.userCountVo(user.getUserId(), params));
            arrayList.add(jsonObject);
        }

        arrayList.sort((o1, o2) -> o2.getString("number").compareTo(o1.getString("number")));
        object.put("data", arrayList);
        list.add(object);
    }

    public List<JSONObject> getVo3(PartnerUser minGrade, AppHomeParams params, Map<Integer, String> rule) {
        Integer grade = queryLevel(minGrade.getGrade());
        List<JSONObject> list = new ArrayList<>();
        List<String> currentUserIds = new ArrayList<>();
        currentUserIds.add(minGrade.getUserId());

        while (grade < 7) {
            if (CollectionUtil.isNotEmpty(currentUserIds)) {
                currentUserIds = baseMapper.selectJuniorList(grade, currentUserIds, params);
            }
            getVo3Data(list, grade, currentUserIds, params, rule);
            if ((minGrade.getGrade() >= 1 && minGrade.getGrade() <= 3 && grade == 4) ||
                    (minGrade.getGrade() == 4 && grade == 5)) {
                break;
            }
            grade++;
        }
        return list;
    }

    public void getVo3Data(List<JSONObject> list, int grade, List<String> currentUserIds, AppHomeParams params, Map<Integer, String> rule) {
        JSONObject object = new JSONObject();
        object.put("grade", grade);
        object.put("gradeName", rule.getOrDefault(grade, ""));

        Integer newNum = baseMapper.userCountIdsVo(currentUserIds, params);
        Integer number = baseMapper.userCountIdsVo(currentUserIds, null);


        JSONObject jsonObject = new JSONObject();
        //新增数量
        jsonObject.put("newNum", newNum);
        //总数量
        jsonObject.put("number", number);
        //新增占比
        jsonObject.put("newProportion", calculatePrecisePercentage(getToInt(newNum),getToInt(number)));
        //历史占比
        jsonObject.put("oldProportion",calculatePrecisePercentage(BigDecimal.valueOf(number).subtract(BigDecimal.valueOf(newNum)),getToInt(number)));
        object.put("data", jsonObject);
        list.add(object);
    }


    public static BigDecimal getToInt(Integer intValue){
        return Optional.ofNullable(intValue)
                .map(BigDecimal::valueOf)
                .orElse(BigDecimal.ZERO);
    }

    public static String calculatePrecisePercentage(BigDecimal part, BigDecimal total) {
        if (total.compareTo(BigDecimal.ZERO) == 0) {
            return "0";
        }
        BigDecimal ratio = part.divide(total, 4, RoundingMode.HALF_UP) // 保留4位小数
                .multiply(BigDecimal.valueOf(100))
                .setScale(2, RoundingMode.DOWN); // 最终保留两位小数
        return ratio + "%";
    }


    public List<Map<String, Object>> getVo2(PartnerUser minGrade, AppHomeParams params, Map<Integer, String> rule) {
        Integer grade = queryLevel(minGrade.getGrade());
        List<Map<String, Object>> list = new ArrayList<>();
        List<String> currentUserIds = new ArrayList<>();
        currentUserIds.add(minGrade.getUserId());
        while (grade < 7) {
            if (CollectionUtil.isNotEmpty(currentUserIds)) {
                currentUserIds = baseMapper.selectJuniorList(grade, currentUserIds, params);
            }
            processGradeVo2(list, grade, currentUserIds, params, rule);
            if ((minGrade.getGrade() >= 1 && minGrade.getGrade() <= 3 && grade == 4) ||
                    (minGrade.getGrade() == 4 && grade == 5)) {
                break;
            }
            grade++;
        }
        return list;
    }

    public void processGradeVo2(List<Map<String, Object>> list, int grade, List<String> currentUserIds, AppHomeParams params, Map<Integer, String> rule) {
        Map<String, Object> voMap = new HashMap<>();
        voMap.put("grade", grade);
        voMap.put("gradeName", rule.getOrDefault(grade, ""));
        List<Map<String, String>> maps = new ArrayList<>(0);
        if (CollectionUtil.isNotEmpty(currentUserIds)){
            maps = baseMapper.userCountVo2(currentUserIds, params);
        }


//        Map<String, Integer> mergedMap = arrayList.stream()
//                .flatMap(map -> map.entrySet().stream())
//                .collect(Collectors.toMap(
//                        Map.Entry::getKey,
//                        Map.Entry::getValue,
//                        Integer::sum
//                ));
//        for (Map.Entry<String, Integer> entry : mergedMap.entrySet()) {
//            Integer value = entry.getValue();
//        }
        List<String> keys = new ArrayList<>();
        List<String> values = new ArrayList<>();
        for (Map<String, String> map : maps) {
            for (Map.Entry<String, String> entry : map.entrySet()) {
                if ("total".equals(entry.getKey())){
                    keys.add(String.valueOf(entry.getValue()));
                }else if ("createTime".equals(entry.getKey())){
                    values.add(String.valueOf(entry.getValue()));
                }
            }
        }
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("dataTime",values);
        jsonObject.put("data",keys);
        voMap.put("data", jsonObject);
        list.add(voMap);
    }

    public List<Map<String, Object>> getV1(PartnerUser minGrade, AppHomeParams params, Map<Integer, String> rule) {
        Integer grade = queryLevel(minGrade.getGrade());
        List<Map<String, Object>> list = new ArrayList<>();
        List<String> currentUserIds = new ArrayList<>();
        currentUserIds.add(minGrade.getUserId());

        while (grade < 7) {
            if (CollectionUtil.isNotEmpty(currentUserIds)) {
                currentUserIds = baseMapper.selectJuniorList(grade, currentUserIds, params);
            }
            processGrade(list, grade, currentUserIds, params, rule);
            grade++;
        }
        return list;
    }

    public void processGrade(List<Map<String, Object>> list, int grade, List<String> currentUserIds, AppHomeParams params, Map<Integer, String> rule) {
        Map<String, Object> map = new HashMap<>();
        map.put("grade", grade);
        map.put("gradeName", rule.getOrDefault(grade, ""));
        Integer count = 0;

//        for (String id : currentUserIds) {
//            count += baseMapper.userCountVo(id, params);
//        }

        map.put("count", currentUserIds.size());
        list.add(map);
    }



    @Override
    public HttpResult myCommissionRate(String userId) {

        List<PartnerUser> partnerUsers = baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getUserId, userId));
        if (CollectionUtil.isEmpty(partnerUsers)){
            return HttpResult.error("用户无权益信息");
        }
//        BigDecimal totalAmountSafe = partnerUsers.stream()
//                .map(PartnerUser::getCommissionRate)
//                .filter(Objects::nonNull)
//                .reduce(BigDecimal.ZERO, BigDecimal::add);

        BigDecimal totalAmountSafe = BigDecimal.ZERO;
        for (PartnerUser partnerUser : partnerUsers) {
            BigDecimal bigDecimal = CalculateCommissionUtils.calculateCommission(String.valueOf(partnerUser.getGrade()),partnerUser.getUserId(),"");
            totalAmountSafe = totalAmountSafe.add(bigDecimal);
        }
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("totalRate",totalAmountSafe);

        Map<Integer, String> rule = getRule();

        ArrayList<Object> list = new ArrayList<>();
        for (PartnerUser user : partnerUsers) {
            JSONObject object = new JSONObject();
            object.put("grade",user.getGrade());
            object.put("gradeName",rule.getOrDefault(user.getGrade(),""));
            object.put("commissionRate",CalculateCommissionUtils.calculateCommission(String.valueOf(user.getGrade()),user.getUserId(),""));
            list.add(object);
        }
        jsonObject.put("data",list);
        return HttpResult.ok(jsonObject);
    }

    @Override
    public List<PartnerUser> selectByUserId(String userId) {
        return baseMapper.selectList(new LambdaQueryWrapper<>(PartnerUser.class).eq(PartnerUser::getUserId, userId));
    }

    @Override
    public PartnerUser selectByUserIdAndGrade(String referrerId, Integer grade) {
        return baseMapper.selectOne(new LambdaQueryWrapper<>(PartnerUser.class)
                .eq(PartnerUser::getUserId, referrerId).eq(PartnerUser::getGrade, grade));
    }

    @Override
    public PartnerPartnerAccount newGetFee(String userId) {
        return partnerPartnerAccountMapper.selectByUserId(userId);
    }


}