package com.ssyf.task.service;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.ssyf.module.robot.domain.entity.GiftRelation;
import com.ssyf.module.robot.domain.entity.RGiftConfig;
import com.ssyf.module.robot.domain.entity.RRobotFee;
import com.ssyf.module.robot.service.GiftRelationService;
import com.ssyf.third.bmiss.model.GiftDetail;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;

/**
 * 礼物决策管理器
 * 负责根据规则（黑名单、白名单、预算）从礼物列表中选出最优礼物
 */
@Slf4j
@Component
public class GiftDecisionManager {

    @Autowired
    private GiftRelationService giftRelationService;

    /**
     * 选择一个可发送的礼物
     *
     * @param apiGiftList     第三方API返回的直播间礼物列表
     * @param giftConfig      送礼配置
     * @param robotFee        机器人费用账户信息
     * @param availableBudget 当前任务计算出的可用预算（TaskHelper计算出的软限制）
     * @return 选中的礼物详情，如果没有合适的则返回 null
     */
    public GiftDetail decideGift(List<GiftDetail> apiGiftList, RGiftConfig giftConfig, RRobotFee robotFee, double availableBudget) {
        if (CollUtil.isEmpty(apiGiftList)) {
            return null;
        }

        // 1. 计算机器人的实际支付能力 (Hard Limit)
        // 硬限制 = (总分配额度 - 已使用额度)
        double totalLimit = robotFee.getTotalAmount() != null ? robotFee.getTotalAmount() : 0.0;
        double usedAmount = robotFee.getUsedAmount() != null ? robotFee.getUsedAmount() : 0.0;
        double applyAmount = robotFee.getApplyAmount() != null ? robotFee.getApplyAmount() : 0.0;

        double remainingHardLimit = totalLimit - usedAmount + applyAmount;

        if (remainingHardLimit <= 0) {
            log.debug("机器人费用硬限额不足: Limit={}, Used={}", totalLimit, usedAmount);
            return null;
        }

        // 2. 计算当前允许的最大礼物单价
        // 逻辑：允许的价格 = min(软预算, 硬限额) + 当前钱包余额(applyAmount)
        // 解释：硬限额是还没申请的钱，applyAmount是已经申请到钱包里的钱。礼物价格不能超过这俩之和。
        // 同时也不能超过 TaskHelper 算出来的当前批次预算 (availableBudget)

        
        // 实际能买得起的价格上限
        double maxAffordablePrice = Math.min(availableBudget, remainingHardLimit) + applyAmount;

        // 3. 获取配置的关联关系 (黑名单/白名单)
        // giftConfigOut = 排除的礼物 (黑名单)
        List<GiftRelation> excludedRelations = giftRelationService.getListByRelationCode(giftConfig.getUuid(), "giftConfigOut");
        Set<Integer> blackListIds = CollUtil.isEmpty(excludedRelations) ? Collections.emptySet() :
                excludedRelations.stream().map(GiftRelation::getGiftId).collect(Collectors.toSet());

        // giftConfig = 指定优先/允许的礼物 (白名单)
        List<GiftRelation> preferredRelations = giftRelationService.getListByRelationCode(giftConfig.getUuid(), "giftConfig");
        Set<Integer> whiteListIds = CollUtil.isEmpty(preferredRelations) ? Collections.emptySet() :
                preferredRelations.stream().map(GiftRelation::getGiftId).collect(Collectors.toSet());

        // 4. 筛选逻辑
        List<GiftDetail> candidates = apiGiftList.stream()
                .filter(g -> {
                    // 4.1 价格过滤
                    if (g.getGift_price() == null || g.getGift_price().doubleValue() > maxAffordablePrice) {
                        return false;
                    }
                    // 4.2 黑名单过滤
                    if (blackListIds.contains(g.getGift_id())) {
                        return false;
                    }
                    return true;
                })
                .collect(Collectors.toList());

        if (CollUtil.isEmpty(candidates)) {
            log.debug("经价格和黑名单筛选后无可用礼物: MaxPrice={}", maxAffordablePrice);
            return null;
        }

        // 5. 决策优先级 (白名单策略)
        // 如果配置了白名单，则只从白名单里选 (或者优先选，这里采用严格模式：有白名单则只发白名单)
        if (CollUtil.isNotEmpty(whiteListIds)) {
            List<GiftDetail> whiteListCandidates = candidates.stream()
                    .filter(g -> whiteListIds.contains(g.getGift_id()))
                    .collect(Collectors.toList());

            if (CollUtil.isNotEmpty(whiteListCandidates)) {
                // 在白名单候选者中随机
                return randomSelect(whiteListCandidates);
            } else {
                // 有白名单配置，但都没钱买/不在API列表中
                log.debug("配置了指定礼物但均不可用(价格或不存在)");
                return null;
            }
        }

        // 6. 无白名单，从所有符合条件的候选中随机
        return randomSelect(candidates);
    }

    private GiftDetail randomSelect(List<GiftDetail> list) {
        if (CollUtil.isEmpty(list)) {
            return null;
        }
        return list.get(ThreadLocalRandom.current().nextInt(list.size()));
    }
}