package com.ydtech.modules.partner.service.Impl;


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alipay.api.domain.Person;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ydtech.exception.SystemException;
import com.ydtech.modules.partner.dao.PartnerAttributeMapper;
import com.ydtech.modules.partner.dao.PartnerRuleMapper;
import com.ydtech.modules.partner.dao.PartnerUserMapper;
import com.ydtech.modules.partner.model.PartnerAttribute;
import com.ydtech.modules.partner.model.PartnerCommissionRules;
import com.ydtech.modules.partner.model.PartnerRule;
import com.ydtech.modules.partner.model.param.CommissionValidityPeriod;
import com.ydtech.modules.partner.model.param.PartnerRuleEntity;
import com.ydtech.modules.partner.service.PartnerRuleService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;


@Service
public class PartnerRuleServiceImpl extends ServiceImpl<PartnerRuleMapper, PartnerRule> implements PartnerRuleService {


    @Autowired
    private PartnerAttributeMapper attributeMapper;

    @Autowired
    private  PartnerUserMapper partnerUserMapper;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public int save(List<PartnerRuleEntity> ruleEntityList) {
        if (CollectionUtil.isEmpty(ruleEntityList)){
            throw new RuntimeException("参数不能为空");
        }
        int num = 0;
        try {
            for (PartnerRuleEntity ruleEntity : ruleEntityList) {
                PartnerRule partnerRule = new PartnerRule();
                BeanUtil.copyProperties(ruleEntity,partnerRule);
                if (StringUtils.isNotBlank(partnerRule.getId())){
                    baseMapper.updateById(partnerRule);
                }else {
                    baseMapper.insert(partnerRule);
                }
                if (StringUtils.equals("1",ruleEntity.getUpgrade())){
                    PartnerAttribute cycle = ruleEntity.getCycle();
                    if (ObjectUtil.isNotNull(cycle)){
                        if (StringUtils.isNotBlank(cycle.getId())){
                            attributeMapper.updateById(cycle);
                        }else {
                            cycle.setRuleId(partnerRule.getId());
                            attributeMapper.insert(cycle);
                        }
                    }
                    List<PartnerAttribute> requirement = ruleEntity.getRequirement();
                    if (CollectionUtil.isNotEmpty(requirement)){
                        for (PartnerAttribute attribute : requirement) {
                            if (StringUtils.isNotBlank(attribute.getId())){
                                attributeMapper.updateById(attribute);
                            }else {
                                attribute.setRuleId(partnerRule.getId());
                                attributeMapper.insert(attribute);
                            }
                        }
                    }
                }
                //  保级策略
                List<PartnerAttribute> strategy = ruleEntity.getStrategyArray();
                if (CollectionUtil.isNotEmpty(strategy)){
                    for (PartnerAttribute attribute : strategy) {
                        if (StringUtils.isNotBlank(attribute.getId())){
                            attributeMapper.updateById(attribute);
                        }else {
                            attribute.setRuleId(partnerRule.getId());
                            attributeMapper.insert(attribute);
                        }
                    }
                }
                num ++;
            }
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("保存失败");
        }
        return num;
    }

    @Override
    public List<PartnerRuleEntity> queryAll() {
        List<PartnerRuleEntity> partnerRuleEntities = attributeMapper.queryAll();
        return partnerRuleEntities;
    }

    @Override
    public  List<Map<String,String>>  queryGradeName() {
        return attributeMapper.queryGradeName();
    }

    private PartnerRuleEntity validateGradeAndFetchRuleEntity(String grade) {
        if (StringUtils.isBlank(grade)) {
            throw new SystemException("等级不能为空");
        }
        PartnerRuleEntity partnerRuleEntity = attributeMapper.selectByGrade(grade);
        if (StringUtils.equals("2", partnerRuleEntity.getUpgrade())) {
            throw new SystemException("当前等级不支持升级");
        }
        return partnerRuleEntity;
    }

    @Override
    public boolean verifyUpgradeConditions(String userId, String grade) {
        VerifyData data = extractCommonLogic(userId, grade);
        PartnerRuleEntity partnerRuleEntity = data.partnerRuleEntity;
        BigDecimal p = data.p;
        BigDecimal bf = data.bf;
        BigDecimal people = data.people;
        BigDecimal allBf = data.allBf;
        if (StringUtils.equals("1", partnerRuleEntity.getAppraise())) {
            return p.compareTo(people) >= 0 && bf.compareTo(allBf) >= 0;
        } else {
            return p.compareTo(people) >= 0 || bf.compareTo(allBf) >= 0;
        }
    }


    @Override
    public String verifyUpgradeConditionsMessage(String userId, String grade) {
        VerifyData data = extractCommonLogic(userId, grade);
        PartnerRuleEntity partnerRuleEntity = data.partnerRuleEntity;
        BigDecimal p = data.p;
        BigDecimal bf = data.bf;
        BigDecimal people = data.people;
        BigDecimal allBf = data.allBf;
        StringBuilder message = new StringBuilder();
        if (StringUtils.equals("1", partnerRuleEntity.getAppraise())) {
            if (p.compareTo(people) >= 0 && bf.compareTo(allBf) >= 0) {
                message.append("邀请").append(people).append("个合伙人, 累计保费达").append(allBf).append("元");
            }
        } else {
            if (p.compareTo(people) >= 0) {
                message.append("邀请").append(people).append("个合伙人");
            }
            if (bf != null && bf.compareTo(allBf) >= 0) {
                if (message.length() > 0) {
                    message.append(", ");
                }
                message.append("累计保费达").append(allBf).append("元");
            }
        }
        return message.toString();
    }



    private VerifyData extractCommonLogic(String userId, String grade) {
        PartnerRuleEntity partnerRuleEntity = validateGradeAndFetchRuleEntity(grade);
        if (partnerRuleEntity == null) {
            throw new SystemException("合作伙伴规则实体不能为空");
        }
        PartnerAttribute cycle1 = partnerRuleEntity.getCycle();
        List<PartnerAttribute> requirement = partnerRuleEntity.getRequirement();
        if (CollectionUtil.isEmpty(requirement)) {
            throw new SystemException("考核条件不能为空");
        }
        CommissionValidityPeriod period = getCommissionValidityPeriod(cycle1, userId, grade);
        if (period == null) {
            throw new SystemException("有效周期不能为空");
        }
        BigDecimal p = getInviteData(userId, grade, period);
        BigDecimal bf = partnerUserMapper.selectTotalSumPremium(userId, grade, period);
        //  查询当前用户出单的保费
        BigDecimal ownBf = partnerUserMapper.selectOwnSumPremium(userId, period);
        if (bf == null){
            bf = BigDecimal.ZERO;
        }
        BigDecimal people;
        BigDecimal allBf;
        if (requirement.size() >= 2) {
            people = getRequirementValue(requirement, 0);
            allBf = getRequirementValue(requirement, 1);
        } else {
            throw new SystemException("考核条件不足");
        }

        return new VerifyData(partnerRuleEntity, p, bf, people, allBf,ownBf);
    }

    private BigDecimal getRequirementValue(List<PartnerAttribute> requirement, int index) {
        if (requirement.size() > index) {
            return new BigDecimal(requirement.get(index).getMin());
        }
        throw new SystemException("考核条件配置错误");
    }


    private static class VerifyData {
        private final PartnerRuleEntity partnerRuleEntity;
        private final BigDecimal p;
        private final BigDecimal bf;
        private final BigDecimal people;
        private final BigDecimal allBf;
        private final BigDecimal ownBf;

        public VerifyData(PartnerRuleEntity partnerRuleEntity, BigDecimal p, BigDecimal bf, BigDecimal people, BigDecimal allBf,BigDecimal ownBf) {
            this.partnerRuleEntity = partnerRuleEntity;
            this.p = p;
            this.bf = bf;
            this.people = people;
            this.allBf = allBf;
            this.ownBf = ownBf;
        }
    }



    @Override
    public BigDecimal getInviteData(String userId, String grade,CommissionValidityPeriod period){
        int number = 0;
        if (StringUtils.equals("2", grade)){
            number = partnerUserMapper.assessment(userId,"3",period);
        }else if (StringUtils.equals("3", grade)){
            number = partnerUserMapper.assessment(userId,"4",period);
        }else if (StringUtils.equals("4", grade)){
            number = partnerUserMapper.assessment(userId,"5",period);
        }
        return new BigDecimal(number);
    }

    @Override
    public  CommissionValidityPeriod getCommissionValidityPeriod(PartnerAttribute cycle1, String userId, String grade) {
        CommissionValidityPeriod period = new CommissionValidityPeriod();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (StringUtils.equals("1", cycle1.getCycle())) {
            return period;
        } else if (StringUtils.equals("2", cycle1.getCycle())) {
            Date upgradeTime = partnerUserMapper.selectUpgradeTime(userId, grade);
            if (upgradeTime == null) {
                partnerUserMapper.updateUpgradeTime(userId,grade);
                upgradeTime = partnerUserMapper.selectUpgradeTime(userId, grade);
                if (Objects.isNull(upgradeTime)){
                    return period;
                }
            }
            String fixedDays = cycle1.getFixedDays();

            if (!isWithinDays(upgradeTime,Integer.valueOf(fixedDays) )) {
                updateUpgradeTimeByDate(upgradeTime,Integer.valueOf(fixedDays),userId,grade );
                upgradeTime = partnerUserMapper.selectUpgradeTime(userId, grade);
            }
            period.setStartDate(dateFormat.format(upgradeTime));
            period.setEndDate(dateFormat.format(addDays(upgradeTime,Integer.valueOf(fixedDays))));
        } else if (StringUtils.equals("3", cycle1.getCycle())) {
//            Date fixedCycle = partnerUserMapper.selectFixedCycleTime(userId, grade);
//            if (fixedCycle == null) {
//                partnerUserMapper.updateFixedCycleTime(userId);
//                fixedCycle = partnerUserMapper.selectFixedCycleTime(userId, grade);
//                if (fixedCycle == null){
//                    return period;
//                }
//            }
//            period.setStartDate(rules.getStartDate());
//            period.setEndDate(rules.getEndDate());
        }
        return period;
    }


    public  Date addDays(Date date, int days) {
        LocalDateTime localDate = date.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalDateTime();
        LocalDateTime newLocalDate = localDate.plusDays(days);
        LocalDateTime endOfDay = newLocalDate.withHour(23)
                .withMinute(59)
                .withSecond(59)
                .withNano(999_999_999);
        return Date.from(endOfDay.atZone(ZoneId.systemDefault()).toInstant());
    }

    private  void updateUpgradeTimeByDate(Date assessmentTime, int days, String userId,String grade) {
        Date newDate = addDaysToday(assessmentTime, days);
        while (!isWithinDays(newDate, days)) {
            newDate = addDaysToday(newDate, days);
        }
        partnerUserMapper.updateUpgradeTimeByDate(userId, newDate,Integer.valueOf(grade));
    }


    public  Date addDaysToday(Date date, int days) {
        LocalDateTime localDate = date.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalDateTime();
        LocalDateTime newLocalDate = localDate.plusDays(days);
        // 设置时分秒为0
        LocalDateTime newDateTime = newLocalDate.withHour(0)
                .withMinute(0)
                .withSecond(0)
                .withNano(0);
        return Date.from(newDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }


    public  boolean isWithinDays(Date date, int days) {
        LocalDate targetDate = date.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalDate();
        return Math.abs(ChronoUnit.DAYS.between(LocalDate.now(), targetDate)) <= days;
    }


    @Override
    public PartnerRuleEntity selectByGrade(String grade) {
        return attributeMapper.selectByGrade(grade);
    }

    @Override
    public List<PartnerRule> selectAll() {
        return baseMapper.selectList(new LambdaQueryWrapper<>());
    }


    public boolean compare(String str1 ,String str2){
        try {
            int num1 = Integer.parseInt(str1);
            int num2 = Integer.parseInt(str2);

            if (num1 > num2) {
                return true;
            } else if (num1 < num2) {
                return false;
            } else {
                return true;
            }
        } catch (NumberFormatException e) {
            System.err.println("字符串包含非数字字符！");
            return false;
        }
    }







}