package com.ydtech.modules.partner.utils;


import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.xxl.job.core.handler.annotation.XxlJob;
import com.ydtech.modules.partner.dao.PartnerExpiredCommissionMapper;
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.PartnerRuleEntity;
import com.ydtech.modules.partner.service.PartnerLiftingRecordService;
import com.ydtech.modules.partner.service.PartnerRuleService;
import com.ydtech.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;


/**
 * 定时任务
 *
 * @author
 */

@Slf4j
@Component
public class TimedTaskUtils {

    @Autowired
    private PartnerLiftingRecordService liftingRecordService;

    @Autowired
    private PartnerPartnerAccountMapper accountMapper;

    @Autowired
    private PartnerUserMapper partnerUserMapper;

    @Autowired
    private PartnerRuleService partnerRuleService;

    @Autowired
    private PartnerExpiredCommissionMapper expiredCommissionMapper;

    @Autowired
    private PartnerPremiumDetailsMapper premiumDetailsMapper;

    @Value("${partner.expireDays}")
    private Integer expireDays;

    /**
     * TODO  每天晚上  记录佣金过期记录
     */
    //@XxlJob("updateOrderDateNoon")
    @Scheduled(cron = "0 0 0 * * *")
    public void updateOrderDateNoon() {
        log.info("记录佣金过期定时任务开始执行:{}", expireDays);
        List<PartnerUser> partnerUserList = partnerUserMapper.queryExpiredRecords(expireDays);
        for (PartnerUser partnerUser : partnerUserList) {
            String date = PartnerDateUtils.timeExample(expireDays);
            LambdaQueryWrapper<PartnerPremiumDetails> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(PartnerPremiumDetails::getUserId, partnerUser.getUserId())
                    .eq(PartnerPremiumDetails::getSource, partnerUser.getGrade())
                    .eq(PartnerPremiumDetails::getAppStatus, 1)
                    .between(PartnerPremiumDetails::getCreateTime,date+" 00:00:00",date+" 23:59:59");
            List<PartnerPremiumDetails> partnerPremiumDetails = premiumDetailsMapper.selectList(lambdaQueryWrapper);
            if (CollectionUtil.isNotEmpty(partnerPremiumDetails)){
                BigDecimal lockCommission = partnerPremiumDetails.stream().map(PartnerPremiumDetails::getExtractFee).reduce(BigDecimal.ZERO, BigDecimal::add);
                PartnerExpiredCommission commission = getExpiredUserCommission(partnerUser,lockCommission);
                expiredCommissionMapper.insert(commission);
                if (null != lockCommission){
                    PartnerPartnerAccount account = accountMapper.selectOne(new LambdaQueryWrapper<>(PartnerPartnerAccount.class)
                            .eq(PartnerPartnerAccount::getUserId, partnerUser.getUserId()).eq(PartnerPartnerAccount::getGrade, partnerUser.getGrade()));
                    if (null == account) {
                        continue;
                    }
                    if (null != lockCommission){
                        account.setExpiredAmount(account.getExpiredAmount().add(lockCommission));
                        accountMapper.updateById(account);
                    }
                    //更新单据状态
                    for (PartnerPremiumDetails detail : partnerPremiumDetails) {
                        detail.setAppStatus(2);
                        premiumDetailsMapper.updateById(detail);
                    }
                }
            }
        }
    }


    private static PartnerExpiredCommission getExpiredUserCommission(PartnerUser record, BigDecimal lockCommission) {
        PartnerExpiredCommission commission = new PartnerExpiredCommission();
        commission.setName(record.getName());
        commission.setMobile(record.getMobile());
        commission.setUserId(record.getUserId());
        commission.setDeptId(record.getDeptId());
        commission.setDeptName(record.getDeptName());
        commission.setGrade(String.valueOf(record.getGrade()));
        commission.setGradeAfter(String.valueOf(record.getGrade() + 1));
        commission.setLockCommission(null == lockCommission ? new BigDecimal("0") : lockCommission);
        commission.setDowngradeTime(record.getIdentityTime());
        commission.setExpiration(new Date());
        commission.setCreateTime(new Date());
        return commission;
    }

    private static PartnerExpiredCommission getExpiredCommission(PartnerLiftingRecord record, BigDecimal lockCommission) {
        PartnerExpiredCommission commission = new PartnerExpiredCommission();
        commission.setName(record.getName());
        commission.setMobile(record.getMobile());
        commission.setUserId(record.getUserId());
        commission.setDeptId(record.getDeptId());
        commission.setDeptName(record.getDeptName());
        commission.setGrade(record.getOriginalLevel());
        commission.setGradeAfter(record.getAfterChange());
        commission.setLockCommission(null == lockCommission ? new BigDecimal("0") : lockCommission);
        commission.setDowngradeTime(record.getCreateTime());
        commission.setExpiration(new Date());
        commission.setCreateTime(new Date());
        return commission;
    }


    /**
     * TODO: 更新降级考核时间
     */
    @Scheduled(cron = "0 0 0 * * *")
    public void checkCommissionExpireTime() {
        // TODO等级规则
        List<PartnerRuleEntity> partnerRuleEntities = partnerRuleService.queryAll();
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        List<PartnerUser> partnerUsers = partnerUserMapper.queryDowngradedData();
        for (PartnerUser partnerUser : partnerUsers) {
            PartnerRuleEntity rule = getRule(String.valueOf(partnerUser.getGrade()), partnerRuleEntities);
            Integer khDays = rule.getKhDays();
            Date upgradeStartTime = getUpgradeStartTime(partnerUser);
            if (null == upgradeStartTime){
                continue;
            }
            System.out.println("开始时间：" + formatter.format(upgradeStartTime));
            //  生成结束时间
            Date upgradeEndTime = PartnerDateUtils.generateEndTime(upgradeStartTime, khDays);
            System.out.println("结束时间：" + formatter.format(upgradeEndTime));
            if (PartnerDateUtils.isSameDay(upgradeEndTime)){
                // TODO考核条件  不满足时需锁定
                ExpiredCommissionUtils commissionUtils = SpringUtil.getBean(ExpiredCommissionUtils.class);
                boolean checked = commissionUtils.checkUpgradeConditions(partnerUser);
                if (!checked){
                    //TODO  不满足
                    commissionUtils.generateLockRecords(partnerUser);
                }
                //TODO    更新考核周期
                partnerUserMapper.updateUpgradeCycleStartTime(partnerUser.getUserId(), PartnerDateUtils.addDaysToday(upgradeEndTime,1),partnerUser.getGrade());
            }

        }
        List<String> idList = partnerUsers.stream()
                .map(PartnerUser::getId)
                .collect(Collectors.toList());
        update(partnerRuleEntities,idList);
    }


    public void update(List<PartnerRuleEntity> partnerRuleEntities,List<String> idList){
        QueryWrapper<PartnerUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("identity_status", 0);
        queryWrapper.in("grade", 2,3,4);
        queryWrapper.orderByDesc("create_time");
        queryWrapper.notIn("id", idList);
        List<PartnerUser> partnerUsers = partnerUserMapper.selectList(queryWrapper);

        for (PartnerUser filteredUser : partnerUsers) {
            PartnerRuleEntity rule = getRule(String.valueOf(filteredUser.getGrade()), partnerRuleEntities);
            Date upgradeStartTime = getUpgradeStartTime(filteredUser);
            if (null == upgradeStartTime){
                continue;
            }
            //TODO    更新考核周期
            updateUpgradeCycleTime(filteredUser,rule, upgradeStartTime);
        }

    }

    private Date getUpgradeStartTime(PartnerUser filteredUser){
        Date upgradeStartTime = partnerUserMapper.selectUpgradeStartTime(filteredUser.getUserId(), filteredUser.getGrade());
        if (upgradeStartTime == null) {
            partnerUserMapper.updateUpgradeStartTime(filteredUser.getUserId(), filteredUser.getGrade());
        }
        return partnerUserMapper.selectUpgradeStartTime(filteredUser.getUserId(), filteredUser.getGrade());
    }

    public  void updateUpgradeCycleTime(PartnerUser partnerUser,PartnerRuleEntity rule,Date upgradeTime) {
        Integer khDays = rule.getKhDays();
        boolean today = false;
        while (!PartnerDateUtils.isWithinDays(upgradeTime, khDays)) {
            upgradeTime = PartnerDateUtils.addDaysToday(upgradeTime, khDays);
            today = true;
        }
        if (today){
            partnerUserMapper.updateUpgradeCycleStartTime(partnerUser.getUserId(), upgradeTime,partnerUser.getGrade());
        }
    }

    public PartnerRuleEntity getRule(String grade,List<PartnerRuleEntity> partnerRuleEntities) {
        return partnerRuleEntities.stream().filter(partnerRuleEntity -> StringUtils.equals(partnerRuleEntity.getGrade(), grade)).findAny().orElse(null);
    }

}