package cc.mrbird.febs.mall.quartz;

import cc.mrbird.febs.common.enumerates.DataDictionaryEnum;
import cc.mrbird.febs.common.enumerates.MemberAccountLevelEnum;
import cc.mrbird.febs.common.enumerates.MemberAgentLevelEnum;
import cc.mrbird.febs.common.enumerates.OrderStatusEnum;
import cc.mrbird.febs.mall.entity.DataDictionaryCustom;
import cc.mrbird.febs.mall.entity.MallMember;
import cc.mrbird.febs.mall.entity.MallOrderInfo;
import cc.mrbird.febs.mall.mapper.DataDictionaryCustomMapper;
import cc.mrbird.febs.mall.mapper.MallMemberMapper;
import cc.mrbird.febs.mall.mapper.MallOrderInfoMapper;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;

/**
 * @author wzy
 * @date 2021-09-25
 **/
@Slf4j
@Component
public class OrderOvertimeJob {

    @Autowired
    private MallOrderInfoMapper orderInfoMapper;

    @Autowired
    private MallMemberMapper mallMemberMapper;

    @Autowired
    private DataDictionaryCustomMapper dataDictionaryCustomMapper;

    @Scheduled(cron = "0 0/5 * * * ? ")
    public void overtimeJob() {
        log.info("订单超时任务执行");
        List<MallOrderInfo> orderList = orderInfoMapper.selectOrderInfoByStatus(OrderStatusEnum.WAIT_PAY.getValue());
        if (CollUtil.isNotEmpty(orderList)) {
            for (MallOrderInfo orderInfo : orderList) {
                long subTime = DateUtil.between(orderInfo.getOrderTime(), new Date(), DateUnit.MINUTE, false);

                if (subTime > 15) {
                    orderInfo.setStatus(OrderStatusEnum.CANCEL.getValue());
                    orderInfo.setCancelType(MallOrderInfo.CANCEL_OVERTIME_NO_PAY);
                    orderInfoMapper.updateById(orderInfo);
                }
            }
        }

    }

    @Scheduled(cron = "0 0 1 * * ? ")
    public void updateMemberAgentLevel() {
        log.info("会员代理等级升级任务执行");
        /**
         * 获取会员信息
         *  1、已经升级成为一星
         */
        /**
         * 区代
         *  1、自身一星
         *  2、直推三个星级
         *  3、团队五个星级
         */
        updateMemberAgentLevelByName(DataDictionaryEnum.AGENT_ONE.getType(),DataDictionaryEnum.AGENT_ONE.getCode());
        /**
         * 县代
         *  1、自身2星
         *  2、直推5个星级
         *  3、团队50个星级
         */
        updateMemberAgentLevelByName(DataDictionaryEnum.AGENT_TWO.getType(),DataDictionaryEnum.AGENT_TWO.getCode());
        updateMemberAgentLevelByName(DataDictionaryEnum.AGENT_THREE.getType(),DataDictionaryEnum.AGENT_THREE.getCode());
        updateMemberAgentLevelByName(DataDictionaryEnum.AGENT_FOUR.getType(),DataDictionaryEnum.AGENT_FOUR.getCode());
        updateMemberAgentLevelByName(DataDictionaryEnum.AGENT_FIVE.getType(),DataDictionaryEnum.AGENT_FIVE.getCode());
    }

    private void updateMemberAgentLevelByName(String name,String code){
        DataDictionaryCustom agentDic = dataDictionaryCustomMapper.selectDicDataByTypeAndCode(
                name,
                code
        );
        JSONObject jsonObject = JSONUtil.parseObj(agentDic.getValue());
        //自身星级
        String levelSelf = jsonObject.get("levelSelf").toString();
        //直推星级数量
        String directLevelCnt = jsonObject.get("directLevelCnt").toString();
        //团队星级数量
        String teamLevelCnt = jsonObject.get("teamLevelCnt").toString();
        //两个市场均有上一个代理等级
        String minTeamLevelCnt = jsonObject.get("minTeamLevelCnt").toString();
        List<MallMember> agentLevelList = mallMemberMapper.selectByAccountLevel(levelSelf);
        if(CollUtil.isNotEmpty(agentLevelList)){
            for(MallMember mallMember : agentLevelList){
                //有星级的直推
                Integer directCnt = mallMemberMapper.selectByRefererIdAndAccountLevel(mallMember.getInviteId(),MemberAccountLevelEnum.NORMAL.getName());
                //团队中星级会员数量
                Integer teamCnt = mallMemberMapper.selectByReferersIdAndAccountLevel(mallMember.getInviteId(),MemberAccountLevelEnum.NORMAL.getName());
                //两个市场均有上一个代理等级
                Integer minCnt = 0;
                if(0 < Integer.parseInt(minTeamLevelCnt)){
                    String minLevel = MemberAgentLevelEnum.AGENT_ONE.minLevel(code);
                    //获取所有直推用户
                    List<MallMember> mallMembers = mallMemberMapper.selectByRefererId(mallMember.getInviteId());
                    if(CollUtil.isNotEmpty(mallMembers) && mallMembers.size() > 2){
                        Integer levelCnt = 0;
                        for(MallMember directMember : mallMembers){
                            Integer minlevelCnt = mallMemberMapper.selectByReferersIdAndLevel(directMember.getInviteId(),minLevel);
                            if(0 < minlevelCnt){
                                levelCnt = levelCnt + 1;
                            }
                            if(levelCnt >= Integer.parseInt(minTeamLevelCnt)){
                                minCnt = 1;
                                break;
                            }
                        }
                    }
                }else{
                    //区代不需要判断这个市场条件
                    minCnt = 1;
                }
                if(Integer.parseInt(directLevelCnt) <= directCnt
                        && Integer.parseInt(teamLevelCnt) <= teamCnt
                        && minCnt > 0){
                    //更新会员代理等级
                    mallMemberMapper.updateLevelById(MemberAgentLevelEnum.AGENT_ONE.getNameByCode(code),mallMember.getId());
                }
            }
        }
    }
}