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;

/**
 * 消耗服务类
 *
 * 提供消耗组相关的服务，包括检查用户是否满足消耗条件、执行消耗等功能
 */
class ConsumeService
{
    /**
     * 检查用户是否满足消耗组的条件
     *
     * @param int $userId 用户ID
     * @param string|int $consumeGroupCode 消耗组编码或ID
     * @return array 检查结果，包含success字段表示是否满足条件，message字段表示错误信息
     */
    public static function checkConsume(int $userId, $consumeGroupCode): array
    {
        try {
            // 获取消耗组
            $consumeGroup = is_numeric($consumeGroupCode)
                ? GameConsumeGroup::find($consumeGroupCode)
                : GameConsumeGroup::where('code', $consumeGroupCode)->first();

            if (!$consumeGroup) {
                return [
                    'success' => false,
                    'message' => "消耗组不存在: {$consumeGroupCode}"
                ];
            }

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

            if ($consumeItems->isEmpty()) {
                return [
                    'success' => true,
                    'message' => '消耗组中没有消耗项'
                ];
            }

            // 检查每个消耗项
            foreach ($consumeItems as $item) {
                $checkResult = self::checkConsumeItem($userId, $item);
                if (!$checkResult['success']) {
                    return $checkResult;
                }
            }

            return [
                'success' => true,
                'message' => '满足所有消耗条件'
            ];
        } catch (\Exception $e) {
            Log::error('检查消耗条件失败', [
                'user_id' => $userId,
                'consume_group' => $consumeGroupCode,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'message' => '检查消耗条件时发生错误: ' . $e->getMessage()
            ];
        }
    }

    /**
     * 执行消耗
     *
     * @param int $userId 用户ID
     * @param string|int $consumeGroupCode 消耗组编码或ID
     * @param string $source 消耗来源
     * @param int $sourceId 消耗来源ID
     * @return array 执行结果，包含success字段表示是否成功，message字段表示错误信息
     */
    public static function executeConsume(int $userId, $consumeGroupCode, string $source, int $sourceId = 0): array
    {
        // 先检查是否满足消耗条件
        $checkResult = self::checkConsume($userId, $consumeGroupCode);
        if (!$checkResult['success']) {
            return $checkResult;
        }

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

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

            // 开始事务
            DB::beginTransaction();

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

            // 提交事务
            DB::commit();

            return [
                'success' => true,
                'message' => '消耗执行成功',
                'consume_group' => [
                    'id' => $consumeGroup->id,
                    'code' => $consumeGroup->code,
                    'name' => $consumeGroup->name
                ]
            ];
        } catch (\Exception $e) {
            // 回滚事务
            DB::rollBack();

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

            return [
                'success' => false,
                'message' => '执行消耗时发生错误: ' . $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:
                return self::checkItemConsume($userId, $consumeItem);

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

            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:
                return self::executeItemConsume($userId, $consumeItem, $source, $sourceId);

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

            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 array 检查结果
     */
    protected static function checkItemConsume(int $userId, GameConsumeItem $consumeItem): array
    {
        $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 [
                'success' => false,
                'message' => "物品数量不足，需要 {$quantity}，实际 {$totalQuantity}",
                'item_id' => $itemId,
                'required' => $quantity,
                'actual' => $totalQuantity
            ];
        }

        return [
            'success' => true,
            'message' => '物品数量足够'
        ];
    }

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

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

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

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

        return [
            'success' => true,
            'message' => '账户余额足够'
        ];
    }

    /**
     * 检查代币账户消耗
     *
     * @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 array 执行结果
     */
    protected static function executeItemConsume(int $userId, GameConsumeItem $consumeItem, string $source, int $sourceId): array
    {
        $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 [
                'success' => false,
                'message' => $result['message'] ?? '物品消耗失败',
                'item_id' => $itemId,
                'quantity' => $quantity
            ];
        }

        return [
            'success' => true,
            'message' => '物品消耗成功',
            '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 array 执行结果
     */
    protected static function executeFundConfigConsume(int $userId, GameConsumeItem $consumeItem, string $source, int $sourceId): array
    {
        $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) {
            return [
                'success' => false,
                'message' => is_string($result) ? $result : '账户资金消耗失败',
                'fund_config_id' => $fundConfigId,
                'amount' => abs($amount)
            ];
        }

        return [
            'success' => true,
            'message' => '账户资金消耗成功',
            '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
            ];
        }
    }
}