@Slf4j
@DubboService(version = "1.0.0")
public class UserService implements IUserService {

    @Override
    public Response<UserResDTO> queryUserInfo(UserReqDTO reqDTO) {
        log.info("查询用户信息 userId: {} reqStr: {}", reqDTO.getUserId(), JSON.toJSONString(reqDTO));
        try {
            // 1. 模拟查询【你可以从数据库或者Redis缓存获取数据】
            UserResDTO resDTO = UserResDTO.builder()
                    .userId(reqDTO.getUserId())
                    .userName("小傅哥")
                    .userAge(20)
                    .build();

            // 2. 返回结果
            return Response.<UserResDTO>builder()
                    .code(Constants.ResponseCode.SUCCESS.getCode())
                    .info(Constants.ResponseCode.SUCCESS.getInfo())
                    .data(resDTO).build();
        } catch (Exception e) {
            log.error("查询用户信息失败 userId: {} reqStr: {}", reqDTO.getUserId(), JSON.toJSONString(reqDTO), e);
            return Response.<UserResDTO>builder()
                    .code(Constants.ResponseCode.UN_ERROR.getCode())
                    .info(Constants.ResponseCode.UN_ERROR.getInfo())
                    .build();
        }
    }

}

/**  
 * Created by lily via on 2024/6/15 14:59 * 单次抽奖随机抽奖算法实现  
 * 策略模式与工厂模式结合  
 *  
 * 场景A20%、B30%、C50%  
 * 总体概率：如果A奖品抽空后，B和C奖品的概率按照 3:5 均分，  
 * 相当于B奖品中奖概率由 0.3 升为 0.375  
 */@Component("singleRateRandomDrawAlgorithm")  
//@Primary  
public class SingleRateRandomDrawAlgorithm extends BaseAlgorithm {  
  
    /**  
     * @description: 单项随机概率抽奖  
     * @author Lily Via  
     * @date 2024/6/15 17:38  
     * @version 1.0  
     */    @Override  
    public String randomDraw(Long strategyId, List<String> excludeAwardIds) {  
        // 获取策略对应的元祖  
        String[] rateTuple = rateTupleMap.get(strategyId);  
        // todo: 校验rateTuple不为空  
        assert rateTuple != null;  
        // 生成随机索引  
        int randomVal = new SecureRandom().nextInt(100) + 1;  
        // 转换为斐波那契散列索引  
        int idx = hashIdx(randomVal);  
        // 查询是否中奖  
        String awardId = rateTuple[idx];  
        // 如果抽中奖品在排除奖品列表中则返回未中奖（说明这个奖品已经抽完）  
        if (excludeAwardIds.contains(awardId)) {  
            return "未中奖";  
        }  
        return awardId;  
    }  
}

@DubboService
public class ActivityBooth implements IActivityBooth {

    @Resource
    private IActivityDao activityDao;

    @Override
    public ActivityRes queryActivityById(ActivityReq req) {

        Activity activity = activityDao.queryActivityById(req.getActivityId());

        ActivityDto activityDto = new ActivityDto();
        activityDto.setActivityId(activity.getActivityId());
        activityDto.setActivityName(activity.getActivityName());
        activityDto.setActivityDesc(activity.getActivityDesc());
        activityDto.setBeginDateTime(activity.getBeginDateTime());
        activityDto.setEndDateTime(activity.getEndDateTime());
        activityDto.setStockAllTotal(activity.getStockAllTotal());
        activityDto.setStockDayTotal(activity.getStockDayTotal());
        activityDto.setTakeAllCount(activity.getStockAllTotal());
        activityDto.setTakeDayCount(activity.getStockDayTotal());

        return new ActivityRes(new Result(Constants.ResponseCode.SUCCESS.getCode(), Constants.ResponseCode.SUCCESS.getInfo()), activityDto);
    }

}

public abstract class BaseActivityPartake extends ActivityPartakeSupport implements IActivityPartake {  
  
    @Resource  
    private Map<Constants.Ids, IIdGenerator> idGeneratorMap;  
  
    @Override  
    public PartakeResult doPartake(PartakeReq req) {  
  
        // 1. 查询是否存在未执行抽奖领取活动单【user_take_activity 存在 state = 0，领取了但抽奖过程失败的，可以直接返回领取结果继续抽奖】  
        UserTakeActivityVO userTakeActivityVO = this.queryNoConsumedTakeActivityOrder(req.getActivityId(), req.getuId());  
        if (null != userTakeActivityVO) {  
            return buildPartakeResult(userTakeActivityVO.getStrategyId(), userTakeActivityVO.getTakeId(), Constants.ResponseCode.NOT_CONSUMED_TAKE);  
        }  
  
        // 2. 查询活动账单  
        ActivityBillVO activityBillVO = super.queryActivityBill(req);  
  
        // 3. 活动信息校验处理【活动库存、状态、日期、个人参与次数】  
        Result checkResult = this.checkActivityBill(req, activityBillVO);  
        if (!Constants.ResponseCode.SUCCESS.getCode().equals(checkResult.getCode())) {  
            return new PartakeResult(checkResult.getCode(), checkResult.getInfo());  
        }  
  
        // 4. 扣减活动库存，通过Redis【活动库存扣减编号，作为锁的Key，缩小颗粒度】 Begin        StockResult subtractionActivityResult = this.subtractionActivityStockByRedis(req.getuId(), req.getActivityId(), activityBillVO.getStockCount(), activityBillVO.getEndDateTime());  
  
        if (!Constants.ResponseCode.SUCCESS.getCode().equals(subtractionActivityResult.getCode())) {  
            this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), subtractionActivityResult.getCode());  
            return new PartakeResult(subtractionActivityResult.getCode(), subtractionActivityResult.getInfo());  
        }  
  
        // 5. 插入领取活动信息【个人用户把活动信息写入到用户表】  
        Long takeId = idGeneratorMap.get(Constants.Ids.SnowFlake).nextId();  
        Result grabResult = this.grabActivity(req, activityBillVO, takeId);  
        if (!Constants.ResponseCode.SUCCESS.getCode().equals(grabResult.getCode())) {  
            this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), grabResult.getCode());  
            return new PartakeResult(grabResult.getCode(), grabResult.getInfo());  
        }  
  
        // 6. 扣减活动库存，通过Redis End  
        this.recoverActivityCacheStockByRedis(req.getActivityId(), subtractionActivityResult.getStockKey(), Constants.ResponseCode.SUCCESS.getCode());  
  
        return buildPartakeResult(activityBillVO.getStrategyId(), takeId, activityBillVO.getStockCount(), subtractionActivityResult.getStockSurplusCount(), Constants.ResponseCode.SUCCESS);  
    }

@ShardingTransactionType(TransactionType.LOCAL)
@Transactional

@ShardingTransactionType(TransactionType.LOCAL) 
@Transactional
@Override  
protected Result grabActivity(PartakeReq partake, ActivityBillVO bill) {
                // 扣减个人已参与次数  
                int updateCount = userTakeActivityRepository.subtractionLeftCount(bill.getActivityId(), bill.getActivityName(), bill.getTakeCount(), bill.getUserTakeLeftCount(), partake.getuId(), partake.getPartakeDate());  
                if (0 == updateCount) {  
                    status.setRollbackOnly();  
                    logger.error("领取活动，扣减个人已参与次数失败 activityId：{} uId：{}", partake.getActivityId(), partake.getuId());  
                    return Result.buildResult(Constants.ResponseCode.NO_UPDATE);  
                }  
  
                // 插入领取活动信息  
                Long takeId = idGeneratorMap.get(Constants.Ids.SnowFlake).nextId();  
                userTakeActivityRepository.takeActivity(bill.getActivityId(), bill.getActivityName(), bill.getTakeCount(), bill.getUserTakeLeftCount(), partake.getuId(), partake.getPartakeDate(), takeId);  
            } catch (DuplicateKeyException e) {  
                status.setRollbackOnly();  
                logger.error("领取活动，唯一索引冲突 activityId：{} uId：{}", partake.getActivityId(), partake.getuId(), e);  
                return Result.buildResult(Constants.ResponseCode.INDEX_DUP);  
            }  
            return Result.buildSuccessResult();  
}

// 年龄规则
@Component
public class UserAgeFilter extends BaseLogic {
    @Override
    public String matterValue(DecisionMatterReq decisionMatter) {
        return decisionMatter.getValMap().get("age").toString();
    }
}

// 性别规则
@Component
public class UserGenderFilter extends BaseLogic {
    @Override
    public String matterValue(DecisionMatterReq decisionMatter) {
        return decisionMatter.getValMap().get("gender").toString();
    }
    
}

public class EngineBase extends EngineConfig implements EngineFilter {

    private Logger logger = LoggerFactory.getLogger(EngineBase.class);

    @Override
    public EngineResult process(DecisionMatterReq matter) {
        throw new RuntimeException("未实现规则引擎服务");
    }

    protected TreeNodeVO engineDecisionMaker(TreeRuleRich treeRuleRich, DecisionMatterReq matter) {
        TreeRootVO treeRoot = treeRuleRich.getTreeRoot();
        Map<Long, TreeNodeVO> treeNodeMap = treeRuleRich.getTreeNodeMap();

        // 规则树根ID
        Long rootNodeId = treeRoot.getTreeRootNodeId();
        TreeNodeVO treeNodeInfo = treeNodeMap.get(rootNodeId);

        // 节点类型[NodeType]；1子叶、2果实
        while (Constants.NodeType.STEM.equals(treeNodeInfo.getNodeType())) {
            String ruleKey = treeNodeInfo.getRuleKey();
            LogicFilter logicFilter = logicFilterMap.get(ruleKey);
            String matterValue = logicFilter.matterValue(matter);
            Long nextNode = logicFilter.filter(matterValue, treeNodeInfo.getTreeNodeLineInfoList());
            treeNodeInfo = treeNodeMap.get(nextNode);
            logger.info("决策树引擎=>{} userId：{} treeId：{} treeNode：{} ruleKey：{} matterValue：{}", treeRoot.getTreeName(), matter.getUserId(), matter.getTreeId(), treeNodeInfo.getTreeNodeId(), ruleKey, matterValue);
        }

        return treeNodeInfo;
    }

}

public abstract class BaseLogic implements LogicFilter {
    @Override
    public Long filter(String matterValue, List<TreeNodeLineVO> treeNodeLineInfoList) {
        for (TreeNodeLineVO nodeLine : treeNodeLineInfoList) {
            if (decisionLogic(matterValue, nodeLine)) {
                return nodeLine.getNodeIdTo();
            }
        }
        return Constants.Global.TREE_NULL_NODE;
    }
    /**
     * 获取规则比对值
     * @param decisionMatter 规则比较判断值。在本例中为性别、年龄信息。
     * @return 比对值
     */
    @Override
    public abstract String matterValue(DecisionMatterReq decisionMatter);
    private boolean decisionLogic(String matterValue, TreeNodeLineVO nodeLine) {
        switch (nodeLine.getRuleLimitType()) {
            case Constants.RuleLimitType.EQUAL:
                return matterValue.equals(nodeLine.getRuleLimitValue());
            case Constants.RuleLimitType.GT:
                return Double.parseDouble(matterValue) > Double.parseDouble(nodeLine.getRuleLimitValue());
            case Constants.RuleLimitType.LT:
                return Double.parseDouble(matterValue) < Double.parseDouble(nodeLine.getRuleLimitValue());
            case Constants.RuleLimitType.GE:
                return Double.parseDouble(matterValue) >= Double.parseDouble(nodeLine.getRuleLimitValue());
            case Constants.RuleLimitType.LE:
                return Double.parseDouble(matterValue) <= Double.parseDouble(nodeLine.getRuleLimitValue());
            default:
                return false;
        }
    }
}

@Resource
    private EngineFilter engineFilter;
    @Test
    public void test_process() {
        DecisionMatterReq req = new DecisionMatterReq();
        req.setTreeId(2110081902L);
        req.setUserId("lily");
        req.setValMap(new HashMap<String, Object>() );
        EngineResult res = engineFilter.process(req);
        logger.info("请求参数：{}", JSON.toJSONString(req));
        logger.info("测试结果：{}", JSON.toJSONString(res));
    }

c.i.lottery.test.domain.ActivityTest     : 请求参数：{"treeId":2110081902,"userId":"lily","valMap":{"gender":"man","age":"25"}}
09:30:59.355  INFO 53959 --- [           main] c.i.lottery.test.domain.ActivityTest     : 测试结果：{"nodeId":112,"nodeValue":"100002","success":true,"treeId":2110081902,"userId":"lily"}

// 5. 发送MQ，触发发奖流程  
InvoiceVO invoiceVO = buildInvoiceVO(drawOrderVO);  
ListenableFuture<SendResult<String, Object>> future = kafkaProducer.sendLotteryInvoice(invoiceVO);  
future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {  
  
    @Override  
    public void onSuccess(SendResult<String, Object> stringObjectSendResult) {  
        // 4.1 MQ 消息发送完成，更新数据库表 user_strategy_export.mq_state = 1        activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.COMPLETE.getCode());  
    }  
  
    @Override  
    public void onFailure(Throwable throwable) {  
        // 4.2 MQ 消息发送失败，更新数据库表 user_strategy_export.mq_state = 2 【等待定时任务扫码补偿MQ消息】  
        activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.FAIL.getCode());  
    }  
  
});

@Component  
public class LotteryXxlJob {  
  
    private Logger logger = LoggerFactory.getLogger(LotteryXxlJob.class);  
  
    @Resource  
    private IActivityDeploy activityDeploy;  
  
    @Resource  
    private IActivityPartake activityPartake;  
  
    @Resource  
    private IStateHandler stateHandler;  
  
    @Resource  
    private IDBRouterStrategy dbRouter;  
  
  
    @Resource  
    private KafkaProducer kafkaProducer;  
  
    @XxlJob("lotteryActivityStateJobHandler")  
    public void lotteryActivityStateJobHandler() throws Exception {  
        logger.info("扫描活动状态 Begin");  
  
        List<ActivityVO> activityVOList = activityDeploy.scanToDoActivityList(0L);  
        if (activityVOList.isEmpty()) {  
            logger.info("扫描活动状态 End 暂无符合需要扫描的活动列表");  
            return;  
        }  
  
        while (!activityVOList.isEmpty()) {  
            for (ActivityVO activityVO : activityVOList) {  
                Integer state = activityVO.getState();  
                switch (state) {  
                    // 活动状态为审核通过，在临近活动开启时间前，审核活动为活动中。在使用活动的时候，需要依照活动状态核时间两个字段进行判断和使用。  
                    case 4:  
                        Result state4Result = stateHandler.doing(activityVO.getActivityId(), Constants.ActivityState.PASS);  
                        logger.info("扫描活动状态为活动中 结果：{} activityId：{} activityName：{} creator：{}", JSON.toJSONString(state4Result), activityVO.getActivityId(), activityVO.getActivityName(), activityVO.getCreator());  
                        break;  
                    // 扫描时间已过期的活动，从活动中状态变更为关闭状态【这里也可以细化为2个任务来处理，也可以把时间判断放到数据库中操作】  
                    case 5:  
                        if (activityVO.getEndDateTime().before(new Date())) {  
                            Result state5Result = stateHandler.close(activityVO.getActivityId(), Constants.ActivityState.DOING);  
                            logger.info("扫描活动状态为关闭 结果：{} activityId：{} activityName：{} creator：{}", JSON.toJSONString(state5Result), activityVO.getActivityId(), activityVO.getActivityName(), activityVO.getCreator());  
                        }  
                        break;  
                    default:  
                        break;  
                }  
            }  
  
            // 获取集合中最后一条记录，继续扫描后面10条记录  
            ActivityVO activityVO = activityVOList.get(activityVOList.size() - 1);  
            activityVOList = activityDeploy.scanToDoActivityList(activityVO.getId());  
        }  
  
        logger.info("扫描活动状态 End");  
  
    }  
  
    @XxlJob("lotteryOrderMQStateJobHandler")  
    public void lotteryOrderMQStateJobHandler() throws Exception {  
        // 验证参数  
        String jobParam = XxlJobHelper.getJobParam();  
        if (null == jobParam) {  
            logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 错误 params is null");  
            return;  
        }  
  
        // 获取分布式任务配置参数信息 参数配置格式：1,2,3 也可以是指定扫描一个，也可以配置多个库，按照部署的任务集群进行数量配置，均摊分别扫描效率更高  
        String[] params = jobParam.split(",");  
        logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 开始 params：{}", JSON.toJSONString(params));  
  
        if (params.length == 0) {  
            logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 结束 params is null");  
            return;  
        }  
  
        // 获取分库分表配置下的分表数  
        int tbCount = dbRouter.tbCount();  
  
        // 循环获取指定扫描库  
        for (String param : params) {  
            // 获取当前任务扫描的指定分库  
            int dbCount = Integer.parseInt(param);  
  
            // 判断配置指定扫描库数，是否存在  
            if (dbCount > dbRouter.dbCount()) {  
                logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 结束 dbCount not exist");  
                continue;  
            }  
  
            // 循环扫描对应表  
            for (int i = 0; i < tbCount; i++) {  
  
                // 扫描库表数据  
                List<InvoiceVO> invoiceVOList = activityPartake.scanInvoiceMqState(dbCount, i);  
                logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 扫描库：{} 扫描表：{} 扫描数：{}", dbCount, i, invoiceVOList.size());  
  
                // 补偿 MQ 消息  
                for (InvoiceVO invoiceVO : invoiceVOList) {  
  
                    ListenableFuture<SendResult<String, Object>> future = kafkaProducer.sendLotteryInvoice(invoiceVO);  
                    future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {  
  
                        @Override  
                        public void onSuccess(SendResult<String, Object> stringObjectSendResult) {  
                            // MQ 消息发送完成，更新数据库表 user_strategy_export.mq_state = 1                            activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.COMPLETE.getCode());  
                        }  
  
                        @Override  
                        public void onFailure(Throwable throwable) {  
                            // MQ 消息发送失败，更新数据库表 user_strategy_export.mq_state = 2 【等待定时任务扫码补偿MQ消息】  
                            activityPartake.updateInvoiceMqState(invoiceVO.getuId(), invoiceVO.getOrderId(), Constants.MQState.FAIL.getCode());  
                        }  
  
                    });  
                }  
            }  
  
        }  
  
        logger.info("扫描用户抽奖奖品发放MQ状态[Table = 2*4] 完成 param：{}", JSON.toJSONString(params));  
  
    }  
  
}

@Override

public String process(BehaviorMatter request) {

// 获取到消息类型对应逻辑处理类

LogicFilter logicFilter = router(request);

// 如果当前节点没有后续节点, 说明单次消息返回内容

if (null == logicFilter.getLogicLineList()) {

return logicFilter.filter(request);

}

// 为连续型消息节点

String openId = request.getOpenId();

// 尝试获取上次触发过内容的节点

LogicFilter continuedLogicFilter = continueTalk(openId);

// 如果为刚开始对话

if (null == continuedLogicFilter) {

// 记录当前对话内容

saveTalk(openId, logicFilter);

return logicFilter.filter(request);

}

// 继续未完成的对话

// 对话在进行中, 尝试根据回复信息找到下一个对话消息逻辑节点

List<LogicLine> logicLines = continuedLogicFilter.getLogicLineList();

LogicFilter nextNode = null;

// 遍历查询 --》》 这段逻辑似乎还是应该交给 LogicFilter 实现更好！！

for (LogicLine logicLine : logicLines) {

if (request.getContent().contains(logicLine.getAccessSign())) {

nextNode = logicLine.getNextNode();

break;

}

}

if (nextNode == null) {

return "对话消息引擎执行错误, 请按照提示内容重新回复";

}

// 获取当前节点回复的消息

String backMsg = nextNode.filter(request);

// 如果当前回复节点已抵达对话逻辑末尾, 清除对话缓存信息

// 否则进行对话信息保存

if (null == nextNode.getLogicLineList()) {

removeTalk(openId);

} else {

saveTalk(openId, nextNode);

}

return backMsg;

}