bot-28/app/Support/PromotionRules.php

<?php

namespace App\Support;

use App\Services\Sharing\ShareDefaults;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;

final class PromotionRules
{
    public const LOSS = 7;
    public const FIRST_DEPOSIT = 8;
    public const WHEEL = 9;
    public const UPGRADE_INVITE = 10;
    /** Fixed campaigns have exactly one row: edited in place, never created. */
    public const FIXED = [self::LOSS, self::WHEEL, self::UPGRADE_INVITE];
    public const TASKS = ['online', 'login', 'invite', 'deposit', 'team_deposit', 'bet', 'team_bet'];
    public const DAILY = ['online', 'login'];
    public const PRIZES = ['0-666', '100', '50', '200', '350', '500', '150', '366'];
    public const ORDINARY_POOL_RULE = '未完成本轮全部任务时不会达到666，累计越接近666单次奖额越小。任务完成后，未命中666时按剩余差额和达成概率控制单次奖额。可用奖项等概率，固定奖项按面额发放。';
    public const REWARD_MODES = ['cash', 'coupon'];
    public const COUPON_CATEGORIES = ['self:sport', 'self:lottery'];
    private const COUPON_KEYS = ['reward_mode', 'coupon_valid_from', 'coupon_valid_until', 'coupon_categories', 'inviter_coupons', 'invitee_coupons'];

    public static function supports(int $type): bool { return in_array($type, [7, 8, 9, 10], true); }
    public static function types(): array { return [7 => '净亏邀请奖励', 8 => '首充奖励', 9 => '转盘活动', 10 => '邀请升级奖励']; }

    public static function defaults(int $type): array
    {
        // Upgrade invite pays straight to the available balance, so it has no turnover ratio.
        if ($type === self::UPGRADE_INVITE) return ['tiers' => []];
        $common = ['turnover_ratio' => '0.00'];
        return $common + match ($type) {
            7 => ['loss_amount' => '500.00', 'invite_count' => 3, 'reward_amount' => '500.00', 'reward_mode' => 'cash',
                'coupon_valid_from' => null, 'coupon_valid_until' => null, 'coupon_categories' => [], 'inviter_coupons' => [], 'invitee_coupons' => []],
            8 => ['min_deposit' => '100.00', 'reward_amount' => '10.00'],
            9 => ['completion_probability' => '20.00', 'online_seconds' => 3600,
                'deposit_amount' => '3000.00', 'team_deposit_amount' => '500.00',
                'bet_amount' => '5000.00', 'team_bet_amount' => '3000.00'],
            default => [],
        };
    }

    public static function normalize(int $type, array $input): array
    {
        $defaults = self::defaults($type);
        // 禁止投注的游戏大类改为全部首充活动共用的设置；旧配置里遗留的该键直接忽略。
        if ($type === self::FIRST_DEPOSIT) unset($input['forbidden_categories']);
        Validator::make(['params' => $input], ['params' => ['array:' . implode(',', array_keys($defaults))]])->validate();
        $data = array_replace($defaults, $input);
        if ($type === self::UPGRADE_INVITE) return ['tiers' => self::tiers($data['tiers'])];
        $coupon = array_intersect_key($data, array_flip(self::COUPON_KEYS));
        $data = array_diff_key($data, $coupon);
        $rules = [];
        foreach ($data as $key => $value) {
            $rules[$key] = match ($key) {
                'invite_count' => ['required', 'integer', 'min:1', 'max:1000'],
                'online_seconds' => ['required', 'integer', 'min:60', 'max:86400'],
                'completion_probability' => ['required', 'numeric', 'between:0,100', 'regex:/^\d{1,3}(\.\d{1,2})?$/'],
                'turnover_ratio' => ['required', 'numeric', 'between:0,10000', 'regex:/^\d{1,5}(\.\d{1,2})?$/'],
                default => ['required', 'numeric', 'gt:0', 'regex:/^\d{1,12}(\.\d{1,2})?$/'],
            };
        }
        Validator::make($data, $rules)->validate();
        foreach ($data as $key => $value) $data[$key] = in_array($key, ['invite_count', 'online_seconds'], true) ? (int)$value : bcadd((string)$value, '0', 2);
        return $coupon ? $data + self::coupons($coupon, $data['reward_amount']) : $data;
    }

    /** 全部首充活动共用的禁止投注游戏大类，存于 config 表（melbet 读取同一项）。 */
    public const FORBIDDEN_CONFIG = 'first_deposit_forbidden_categories';
    /** 首充活动详情链接（PC / H5 / APP），JSON 对象，全部首充活动共用。 */
    public const DETAIL_LINKS_CONFIG = 'first_deposit_detail_links';
    public const DETAIL_LINK_PLATFORMS = ['PC', 'H5', 'APP'];

    /** @return array{PC:string,H5:string,APP:string} */
    public static function detailLinks(): array
    {
        $saved = json_decode((string) DB::table('config')->where('field', self::DETAIL_LINKS_CONFIG)->value('val'), true);
        $links = [];
        foreach (self::DETAIL_LINK_PLATFORMS as $platform) {
            $links[$platform] = is_array($saved) && is_string($saved[$platform] ?? null) ? $saved[$platform] : '';
        }
        return $links;
    }

    /** 当前设置；未配置或内容损坏时视为不限制。 */
    public static function forbiddenSetting(): array
    {
        $value = json_decode((string) DB::table('config')->where('field', self::FORBIDDEN_CONFIG)->value('val'), true);
        try { return self::forbiddenCategories(is_array($value) ? $value : []); }
        catch (ValidationException) { return []; }
    }

    /** 首充活动规则附上当前的全局禁止大类，供展示、参加确认和发奖快照使用。 */
    public static function withForbidden(array $rules): array
    {
        return $rules + ['forbidden_categories' => self::forbiddenSetting()];
    }

    /** 禁止投注的游戏大类：与返佣规则同一套大类，去重后按大类顺序保存。 */
    public static function forbiddenCategories($value): array
    {
        $options = array_keys(ShareDefaults::commissionCategories());
        if ($value === null) return [];
        if (!is_array($value) || array_values($value) !== $value || array_filter($value, fn ($item) => !is_string($item) || !in_array($item, $options, true))
            || count(array_unique($value)) !== count($value)) {
            throw ValidationException::withMessages(['categories' => 'categories参数错误：只能选择返佣规则中的游戏大类且不能重复']);
        }
        return array_values(array_intersect($options, $value));
    }

    public static function hasPlayableCategory(array $rules, ?string $onlyCategory = null): bool
    {
        if (bccomp(bcmul($rules['reward_amount'], $rules['turnover_ratio'], 2), '0', 2) === 0) return true;
        $categories = $onlyCategory === null ? array_keys(ShareDefaults::commissionCategories()) : [$onlyCategory];
        return (bool) array_diff($categories, $rules['forbidden_categories']);
    }

    /** Coupon settings stay well-formed in cash mode so switching modes keeps them; completeness is enforced only in coupon mode. */
    private static function coupons(array $input, string $rewardAmount): array
    {
        $invalid = fn (string $message) => throw ValidationException::withMessages(['params' => $message]);
        $mode = $input['reward_mode'];
        if (!is_string($mode) || !in_array($mode, self::REWARD_MODES, true)) $invalid('reward_mode参数错误');
        $data = ['reward_mode' => $mode];
        foreach (['coupon_valid_from', 'coupon_valid_until'] as $key) {
            $value = $input[$key];
            if ($value === null || $value === '') { $data[$key] = null; continue; }
            $time = is_string($value) ? \DateTimeImmutable::createFromFormat('!Y-m-d H:i:s', $value) : false;
            if (!$time || $time->format('Y-m-d H:i:s') !== $value) $invalid($key . '参数错误');
            $data[$key] = $value;
        }
        $categories = $input['coupon_categories'];
        if (!is_array($categories) || array_diff($categories, self::COUPON_CATEGORIES) || count(array_unique($categories)) !== count($categories)) {
            $invalid('coupon_categories参数错误');
        }
        $data['coupon_categories'] = array_values(array_intersect(self::COUPON_CATEGORIES, $categories));
        foreach (['inviter_coupons', 'invitee_coupons'] as $key) {
            $tiers = $input[$key];
            if (!is_array($tiers) || array_values($tiers) !== $tiers || count($tiers) > 10) $invalid($key . '参数错误');
            $data[$key] = [];
            foreach ($tiers as $tier) {
                if (!is_array($tier) || array_diff(array_keys($tier), ['min_amount', 'discount', 'quantity']) || count($tier) !== 3) $invalid($key . '参数错误');
                foreach (['min_amount', 'discount'] as $field) {
                    if (!is_numeric($tier[$field]) || !preg_match('/^\d{1,12}(\.\d{1,2})?$/', (string)$tier[$field])) $invalid($key . '参数错误');
                }
                $quantity = is_scalar($tier['quantity']) ? filter_var($tier['quantity'], FILTER_VALIDATE_INT) : false;
                $min = bcadd((string)$tier['min_amount'], '0', 2); $discount = bcadd((string)$tier['discount'], '0', 2);
                if (bccomp($discount, '0', 2) <= 0 || bccomp($min, $discount, 2) < 0 || $quantity === false || $quantity < 1 || $quantity > 100) {
                    $invalid($key . '参数错误：抵扣金额须大于0且不高于使用门槛，份数为1至100');
                }
                $data[$key][] = ['min_amount' => $min, 'discount' => $discount, 'quantity' => $quantity];
            }
        }
        if ($data['coupon_valid_from'] !== null && $data['coupon_valid_until'] !== null && $data['coupon_valid_until'] <= $data['coupon_valid_from']) {
            $invalid('优惠券结束时间必须晚于开始时间');
        }
        if ($mode === 'coupon') {
            if (!$data['inviter_coupons']) $invalid('请至少配置一档邀请人优惠券');
            if (bccomp(self::faceValue($data['inviter_coupons']), $rewardAmount, 2) > 0) $invalid('优惠券抵扣总额不能超过奖励金额');
            if ($data['coupon_valid_from'] === null || $data['coupon_valid_until'] === null) $invalid('请填写优惠券可用时间');
            if (!$data['coupon_categories']) $invalid('请选择优惠券可用游戏类型');
        }
        return $data;
    }

    /** Upgrade tiers: one bonus per share level reached, distinct levels from 2 up, sorted by level. */
    public static function tiers($tiers): array
    {
        $invalid = fn (string $message) => throw ValidationException::withMessages(['params' => $message]);
        if (!is_array($tiers) || array_values($tiers) !== $tiers || count($tiers) > 50) $invalid('tiers参数错误：最多50档');
        $data = [];
        foreach ($tiers as $tier) {
            if (!is_array($tier) || array_diff(array_keys($tier), ['level', 'amount']) || count($tier) !== 2) $invalid('tiers参数错误：每档须包含level和amount');
            $level = is_scalar($tier['level']) ? filter_var($tier['level'], FILTER_VALIDATE_INT) : false;
            if ($level === false || $level < 2) $invalid('tiers参数错误：等级须为2及以上的整数');
            if (isset($data[$level])) $invalid('tiers参数错误：等级' . $level . '重复');
            if (!is_numeric($tier['amount']) || !preg_match('/^\d{1,12}(\.\d{1,2})?$/', (string)$tier['amount']) || bccomp((string)$tier['amount'], '0', 2) <= 0) {
                $invalid('tiers参数错误：奖励金额须大于0且最多两位小数');
            }
            $data[$level] = ['level' => $level, 'amount' => bcadd((string)$tier['amount'], '0', 2)];
        }
        ksort($data);
        return array_values($data);
    }

    /** Total discount of one coupon set: sum of discount × quantity. */
    public static function faceValue(array $tiers): string
    {
        $total = '0.00';
        foreach ($tiers as $tier) $total = bcadd($total, bcmul((string)$tier['discount'], (string)$tier['quantity'], 2), 2);
        return $total;
    }

    public static function draw(int $coins, bool $complete, string $probability, ?callable $random = null): array
    {
        $random ??= fn (int $min, int $max) => random_int($min, $max);
        $remaining = 66600 - $coins;
        if ($remaining <= 0) throw new \LogicException('请先领取本轮奖金');
        $probabilityBps = (int)bcmul($probability, '100', 0);
        $hit = $complete && $random(1, 10000) <= $probabilityBps;
        if ($hit) return ['prize_index' => 0, 'amount_cents' => $remaining, 'reached' => true];

        if ($complete) {
            // Use twice the expected draws, rounded up and capped at ten. Budget one unit per draw,
            // then spread the remaining cents across that many misses once inside the buffer.
            $pacedSpins = (int)min(10, ceil(20000 / max(1, $probabilityBps)));
            $maxAmount = min($remaining - 1, max($remaining - $pacedSpins * 100, intdiv($remaining - 1, $pacedSpins), 1));
        } else {
            // No hard stop at 600: always leave 1.00 for the qualified stage. Below 600 award at most a quarter
            // of the room, above it at most a twentieth, so amounts shrink toward 666 without collapsing to zero.
            $headroom = max(0, 66500 - $coins);
            $divisor = $coins < 60000 ? 4 : 20;
            $maxAmount = intdiv($headroom + $divisor - 1, $divisor);
        }
        if ($maxAmount === 0) return ['prize_index' => 0, 'amount_cents' => 0, 'reached' => false];

        // Choose eligible sectors before drawing. A fixed face value is never truncated.
        $eligible = [0];
        foreach (self::PRIZES as $i => $amount) if ($i && (int)$amount * 100 <= $maxAmount) $eligible[] = $i;
        $index = $eligible[$random(0, count($eligible) - 1)];
        $amount = $index === 0 ? $random(1, $maxAmount) : (int)self::PRIZES[$index] * 100;
        return ['prize_index' => $index, 'amount_cents' => $amount, 'reached' => false];
    }
}