kknongchang_2506/app/Module/Game/Services/ConsumeService.php

<?php

namespace App\Module\Game\Services;

use App\Module\Fund\Logic\User as FundLogic;
use App\Module\Fund\Enums\LOG_TYPE as FUND_LOG_TYPE;
use App\Module\Game\Enums\CONSUME_TYPE;
use App\Module\Game\Models\GameConsumeGroup;
use App\Module\Game\Models\GameConsumeItem;
use App\Module\GameItems\Services\ItemService;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use UCore\Db\Helper;
use UCore\Dto\Res;

/**
 * 消耗服务类
 *
 * 提供消耗组相关的服务，包括检查用户是否满足消耗条件、执行消耗等功能
 */
class ConsumeService
{

    /**
     * 检查用户是否满足消耗组的条件
     *
     * @param int $userId 用户ID
     * @param string|int $consumeGroupCode 消耗组编码或ID
     * @return array 检查结果，包含success字段表示是否满足条件，message字段表示错误信息
     */
    public static function checkConsume(int $userId, $consumeGroupCode): Res
    {
        try {
            // 获取消耗组
            /**
             * @var GameConsumeGroup $consumeGroup
             */
            $consumeGroup = is_numeric($consumeGroupCode)
                ? GameConsumeGroup::find($consumeGroupCode)
                : GameConsumeGroup::where('code', $consumeGroupCode)->first();

            if (!$consumeGroup) {
                return Res::error("消耗组不存在: {$consumeGroupCode}");
            }

            // 获取消耗组中的所有消耗项
            $consumeItems = $consumeGroup->consumeItems;

            if ($consumeItems->isEmpty()) {
                return Res::success();
            }

            // 检查每个消耗项
            foreach ($consumeItems as $item) {
                $checkResult = self::checkConsumeItem($userId, $item);

                if (!$checkResult['success']) {
                    return Res::error($checkResult['message'], $checkResult);
                }
            }

            // 所有条件都满足，返回成功; 返回消耗组信息
            return Res::success('',
                                ConsumeGroupService::consumeItems2Array($consumeItems)
            );
        } catch (\Exception $e) {
            Log::error('检查消耗条件失败', [
                'user_id'       => $userId,
                'consume_group' => $consumeGroupCode,
                'error'         => $e->getMessage()
            ]);

            return Res::error('检查消耗条件时发生错误: ' . $e->getMessage());

        }
    }

    /**
     * 执行消耗
     *
     * @param int $userId 用户ID
     * @param string|int $consumeGroupCode 消耗组编码或ID
     * @param string $source 消耗来源
     * @param int $sourceId 消耗来源ID
     * @return Res 执行结果
     */
    public static function executeConsume(int $userId, $consumeGroupCode, string $source, int $sourceId = 0, $check = true): Res
    {
        if ($check) {
            // 先检查是否满足消耗条件
            $checkResult = self::checkConsume($userId, $consumeGroupCode);
            if (!$checkResult->success) {
                return $checkResult;
            }
        }

        try {
            Helper::check_tr();
            // 获取消耗组
            /**
             * @var GameConsumeGroup $consumeGroup
             */
            $consumeGroup = is_numeric($consumeGroupCode)
                ? GameConsumeGroup::find($consumeGroupCode)
                : GameConsumeGroup::where('code', $consumeGroupCode)->first();

            // 获取消耗组中的所有消耗项
            $consumeItems = $consumeGroup->consumeItems;

            // 开始事务


            // 执行每个消耗项
            foreach ($consumeItems as $item) {
                $consumeResult = self::executeConsumeItem($userId, $item, $source, $sourceId);
                if (!$consumeResult['success']) {
                    DB::rollBack();

                    return Res::error($consumeResult['message'], $consumeResult);
                }
            }


            return Res::success('消耗执行成功', [
                'consume_group' => [
                    'id'   => $consumeGroup->id,
                    'code' => $consumeGroup->code,
                    'name' => $consumeGroup->name
                ],
                'list'          => ConsumeGroupService::consumeItems2Array($consumeItems)
            ]);
        } catch (\Exception $e) {

            Log::error('执行消耗失败', [
                'user_id'       => $userId,
                'consume_group' => $consumeGroupCode,
                'source'        => $source,
                'source_id'     => $sourceId,
                'error'         => $e->getMessage()
            ]);

            return Res::error('执行消耗时发生错误: ' . $e->getMessage());
        }
    }

    /**
     * 检查单个消耗项
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @return array 检查结果
     */
    protected static function checkConsumeItem(int $userId, GameConsumeItem $consumeItem): array
    {
        switch ($consumeItem->consume_type) {
            case CONSUME_TYPE::ITEM->value:
                $result = self::checkItemConsume($userId, $consumeItem);

                // 将 Res 对象转换为数组格式
                return [
                    'success'  => $result->success,
                    'message'  => $result->message,
                    'item_id'  => $result->data['item_id'] ?? null,
                    'required' => $result->data['required'] ?? null,
                    'actual'   => $result->data['actual'] ?? null
                ];

            case CONSUME_TYPE::FUND_CONFIG->value:
                $result = self::checkFundConfigConsume($userId, $consumeItem);

                // 将 Res 对象转换为数组格式
                return [
                    'success'        => $result->success,
                    'message'        => $result->message,
                    'fund_config_id' => $result->data['fund_config_id'] ?? null,
                    'required'       => $result->data['required'] ?? null,
                    'actual'         => $result->data['actual'] ?? null
                ];

            case CONSUME_TYPE::CURRENCY->value:
                return self::checkCurrencyConsume($userId, $consumeItem);

            default:
                return [
                    'success' => false,
                    'message' => "不支持的消耗类型: {$consumeItem->consume_type}"
                ];
        }
    }

    /**
     * 执行单个消耗项
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @param string $source 消耗来源
     * @param int $sourceId 消耗来源ID
     * @return array 执行结果
     */
    protected static function executeConsumeItem(int $userId, GameConsumeItem $consumeItem, string $source, int $sourceId): array
    {
        switch ($consumeItem->consume_type) {
            case CONSUME_TYPE::ITEM->value:
                $result = self::executeItemConsume($userId, $consumeItem, $source, $sourceId);

                // 将 Res 对象转换为数组格式
                return [
                    'success'  => $result->success,
                    'message'  => $result->message,
                    'item_id'  => $result->data['item_id'] ?? null,
                    'quantity' => $result->data['quantity'] ?? null
                ];

            case CONSUME_TYPE::FUND_CONFIG->value:
                $result = self::executeFundConfigConsume($userId, $consumeItem, $source, $sourceId);

                // 将 Res 对象转换为数组格式
                return [
                    'success'        => $result->success,
                    'message'        => $result->message,
                    'fund_config_id' => $result->data['fund_config_id'] ?? null,
                    'amount'         => $result->data['amount'] ?? null
                ];

            case CONSUME_TYPE::CURRENCY->value:
                return self::executeCurrencyConsume($userId, $consumeItem, $source, $sourceId);

            default:
                return [
                    'success' => false,
                    'message' => "不支持的消耗类型: {$consumeItem->consume_type}"
                ];
        }
    }

    /**
     * 检查物品消耗
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @return Res 检查结果
     */
    protected static function checkItemConsume(int $userId, GameConsumeItem $consumeItem): Res
    {
        $itemId   = $consumeItem->target_id;
        $quantity = $consumeItem->quantity;

        // 获取用户物品
        $userItems = ItemService::getUserItems($userId, [ 'item_id' => $itemId ]);

        // 计算用户拥有的物品总数
        $totalQuantity = 0;
        foreach ($userItems as $userItem) {
            $totalQuantity += $userItem->quantity;
        }

        // 检查数量是否足够
        if ($totalQuantity < $quantity) {
            return Res::error("物品数量不足，需要 {$quantity}，实际 {$totalQuantity}", [
                'item_id'  => $itemId,
                'required' => $quantity,
                'actual'   => $totalQuantity
            ]);
        }

        return Res::success('物品数量足够');
    }

    /**
     * 检查账户种类消耗
     *
     * 注意：这里的target_id指向fund_config表的id（账户种类ID）
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @return Res 检查结果
     */
    protected static function checkFundConfigConsume(int $userId, GameConsumeItem $consumeItem): Res
    {
        $fundConfigId = $consumeItem->target_id;
        $amount       = $consumeItem->quantity;

        // 获取用户账户
        $account = FundLogic::get_account($userId, $fundConfigId);

        // 检查账户是否存在
        if ($account === false) {
            return Res::error("用户没有该账户种类", [
                'fund_config_id' => $fundConfigId
            ]);
        }

        // 检查余额是否足够
        if ($account->balance < $amount) {
            return Res::error("账户余额不足，需要 {$amount}，实际 {$account->balance}", [
                'fund_config_id' => $fundConfigId,
                'required'       => $amount,
                'actual'         => $account->balance
            ]);
        }

        return Res::success('账户余额足够');
    }

    /**
     * 检查代币账户消耗
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @return array 检查结果
     */
    protected static function checkFundConsume(int $userId, GameConsumeItem $consumeItem): array
    {
        $fundId = $consumeItem->target_id;
        $amount = $consumeItem->quantity;

        try {
            // 获取用户代币账户
            $fundService = new \App\Module\Fund\Services\FundService($userId, $fundId);
            $account     = $fundService->getAccount();

            // 检查账户是否存在
            if (!$account) {
                return [
                    'success' => false,
                    'message' => "用户没有该代币账户",
                    'fund_id' => $fundId
                ];
            }

            // 检查余额是否足够
            $balance = $account->balance;
            if ($balance < $amount) {
                return [
                    'success'  => false,
                    'message'  => "代币账户余额不足，需要 {$amount}，实际 {$balance}",
                    'fund_id'  => $fundId,
                    'required' => $amount,
                    'actual'   => $balance
                ];
            }

            return [
                'success' => true,
                'message' => '代币账户余额足够'
            ];
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '检查代币账户异常: ' . $e->getMessage(),
                'fund_id' => $fundId
            ];
        }
    }

    /**
     * 执行物品消耗
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @param string $source 消耗来源
     * @param int $sourceId 消耗来源ID
     * @return Res 执行结果
     */
    protected static function executeItemConsume(int $userId, GameConsumeItem $consumeItem, string $source, int $sourceId): Res
    {
        $itemId   = $consumeItem->target_id;
        $quantity = $consumeItem->quantity;

        // 消耗物品
        $result = ItemService::consumeItem($userId, $itemId, null, $quantity, [
            'source_type' => $source,
            'source_id'   => $sourceId,
            'details'     => [
                'consume_item_id'  => $consumeItem->id,
                'consume_group_id' => $consumeItem->group_id
            ]
        ]);

        if (!$result['success']) {
            return Res::error($result['message'] ?? '物品消耗失败', [
                'item_id'  => $itemId,
                'quantity' => $quantity
            ]);
        }

        return Res::success('物品消耗成功', [
            'item_id'  => $itemId,
            'quantity' => $quantity
        ]);
    }

    /**
     * 执行账户种类消耗
     *
     * 注意：这里的target_id指向fund_config表的id（账户种类ID）
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @param string $source 消耗来源
     * @param int $sourceId 消耗来源ID
     * @return Res 执行结果
     */
    protected static function executeFundConfigConsume(int $userId, GameConsumeItem $consumeItem, string $source, int $sourceId): Res
    {
        $fundConfigId = $consumeItem->target_id;
        $amount       = -$consumeItem->quantity; // 负数表示消耗

        // 构建备注
        $remark = "消耗组:{$consumeItem->group_id},来源:{$source}";
        if ($sourceId > 0) {
            $remark .= ",ID:{$sourceId}";
        }

        // 消耗账户资金
        $result = FundLogic::handle(
            $userId,
            $fundConfigId,
            $amount,
            FUND_LOG_TYPE::TRADE, // 使用TRADE类型，因为CONSUME可能不存在
            $sourceId,
            $remark
        );

        if ($result !== true) {
            $errorMessage = is_string($result) ? $result : '账户资金消耗失败';

            return Res::error($errorMessage, [
                'fund_config_id' => $fundConfigId,
                'amount'         => abs($amount)
            ]);
        }

        return Res::success('账户资金消耗成功', [
            'fund_config_id' => $fundConfigId,
            'amount'         => abs($amount)
        ]);
    }

    /**
     * 检查币种消耗
     *
     * 注意：这里的target_id指向fund_currency表的id（币种ID）
     * 这个方法会检查用户所有与该币种相关的账户，并计算总余额
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @return array 检查结果
     */
    protected static function checkCurrencyConsume(int $userId, GameConsumeItem $consumeItem): array
    {
        $currencyId = $consumeItem->target_id;
        $amount     = $consumeItem->quantity;

        try {
            // 获取该币种的所有账户种类
            $fundConfigs = \App\Module\Fund\Models\FundConfigModel::where('currency_id', $currencyId)->get();

            if ($fundConfigs->isEmpty()) {
                return [
                    'success'     => false,
                    'message'     => "币种不存在或没有关联的账户种类",
                    'currency_id' => $currencyId
                ];
            }

            // 获取用户所有与该币种相关的账户
            $fundConfigIds = $fundConfigs->pluck('id')->toArray();
            $accounts      = \App\Module\Fund\Models\FundModel::where('user_id', $userId)
                ->whereIn('fund_id', $fundConfigIds)
                ->get();

            if ($accounts->isEmpty()) {
                return [
                    'success'     => false,
                    'message'     => "用户没有该币种的账户",
                    'currency_id' => $currencyId
                ];
            }

            // 计算总余额
            $totalBalance = $accounts->sum('balance');

            // 检查余额是否足够
            if ($totalBalance < $amount) {
                return [
                    'success'     => false,
                    'message'     => "币种总余额不足，需要 {$amount}，实际 {$totalBalance}",
                    'currency_id' => $currencyId,
                    'required'    => $amount,
                    'actual'      => $totalBalance
                ];
            }

            return [
                'success'  => true,
                'message'  => '币种总余额足够',
                'accounts' => $accounts->toArray()
            ];
        } catch (\Exception $e) {
            return [
                'success'     => false,
                'message'     => '检查币种消耗异常: ' . $e->getMessage(),
                'currency_id' => $currencyId
            ];
        }
    }

    /**
     * 执行币种消耗
     *
     * 注意：这里的target_id指向fund_currency表的id（币种ID）
     * 这个方法会优先从用户的可用账户中扣除，如果不足则依次从其他账户扣除
     *
     * @param int $userId 用户ID
     * @param GameConsumeItem $consumeItem 消耗项
     * @param string $source 消耗来源
     * @param int $sourceId 消耗来源ID
     * @return array 执行结果
     */
    protected static function executeCurrencyConsume(int $userId, GameConsumeItem $consumeItem, string $source, int $sourceId): array
    {
        // todo 需要优化，迁移到Fund中
        $currencyId      = $consumeItem->target_id;
        $amountToConsume = $consumeItem->quantity;

        try {
            // 先检查是否有足够的余额
            $checkResult = self::checkCurrencyConsume($userId, $consumeItem);
            if (!$checkResult['success']) {
                return $checkResult;
            }

            // 获取该币种的所有账户种类
            $fundConfigs   = \App\Module\Fund\Models\FundConfigModel::where('currency_id', $currencyId)->get();
            $fundConfigIds = $fundConfigs->pluck('id')->toArray();

            // 获取用户所有与该币种相关的账户
            $accounts = \App\Module\Fund\Models\FundModel::where('user_id', $userId)
                ->whereIn('fund_id', $fundConfigIds)
                ->orderBy('fund_id') // 按账户种类ID排序，通常可用账户ID较小
                ->get();

            // 开始事务
            \Illuminate\Support\Facades\DB::beginTransaction();

            $remainingAmount  = $amountToConsume;
            $consumedAccounts = [];

            // 依次从各个账户中扣除
            foreach ($accounts as $account) {
                if ($remainingAmount <= 0) {
                    break;
                }

                $accountBalance = $account->balance;
                $amountToDeduct = min($accountBalance, $remainingAmount);

                if ($amountToDeduct > 0) {
                    // 构建备注
                    $remark = "币种消耗:{$currencyId},消耗组:{$consumeItem->group_id},来源:{$source}";
                    if ($sourceId > 0) {
                        $remark .= ",ID:{$sourceId}";
                    }

                    // 从当前账户扣除
                    $result = FundLogic::handle(
                        $userId,
                        $account->fund_id->value,
                        -$amountToDeduct, // 负数表示消耗
                        FUND_LOG_TYPE::TRADE,
                        $sourceId,
                        $remark
                    );

                    if ($result !== true) {
                        \Illuminate\Support\Facades\DB::rollBack();

                        return [
                            'success'        => false,
                            'message'        => is_string($result) ? $result : "从账户 {$account->fund_id} 扣除失败",
                            'currency_id'    => $currencyId,
                            'fund_config_id' => $account->fund_id,
                            'amount'         => $amountToDeduct
                        ];
                    }

                    $consumedAccounts[] = [
                        'fund_config_id' => $account->fund_id,
                        'amount'         => $amountToDeduct
                    ];

                    $remainingAmount -= $amountToDeduct;
                }
            }

            // 提交事务
            \Illuminate\Support\Facades\DB::commit();

            return [
                'success'           => true,
                'message'           => '币种消耗成功',
                'currency_id'       => $currencyId,
                'amount'            => $amountToConsume,
                'consumed_accounts' => $consumedAccounts
            ];
        } catch (\Exception $e) {
            // 回滚事务
            if (\Illuminate\Support\Facades\DB::transactionLevel() > 0) {
                \Illuminate\Support\Facades\DB::rollBack();
            }

            return [
                'success'     => false,
                'message'     => '币种消耗异常: ' . $e->getMessage(),
                'currency_id' => $currencyId,
                'amount'      => $amountToConsume
            ];
        }
    }

}