kknongchang_2506/app/Module/Mex/Logic/MexMatchLogic.php

<?php

namespace App\Module\Mex\Logic;

use App\Module\Game\Enums\REWARD_SOURCE_TYPE;
use App\Module\Mex\Models\MexOrder;
use App\Module\Mex\Models\MexWarehouse;
use App\Module\Mex\Models\MexTransaction;
use App\Module\Mex\Models\MexPriceConfig;
use App\Module\Mex\Enums\OrderType;
use App\Module\Mex\Enums\OrderStatus;
use App\Module\Mex\Enums\TransactionType;
use App\Module\Fund\Services\FundService;
use App\Module\Fund\Enums\FUND_TYPE;
use App\Module\Fund\Enums\FUND_CURRENCY_TYPE;
use App\Module\GameItems\Services\ItemService;
use App\Module\Mex\Logic\FundLogic;
use App\Module\Mex\Logic\MexMatchLogLogic;
use App\Module\Mex\Enums\MatchType;
use App\Module\GameItems\Enums\FREEZE_REASON_TYPE;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

/**
 * 农贸市场撮合逻辑
 *
 * 处理撮合相关的核心业务逻辑
 * 根据文档要求分离用户买入物品和用户卖出物品的撮合逻辑
 */
class MexMatchLogic
{
    /**
     * 仓库账户ID
     */
    private const WAREHOUSE_USER_ID = 15;

    /**
     * 调控账户ID
     */
    private const CONTROL_USER_ID = 16;

    /**
     * 执行用户买入物品撮合任务
     *
     * @param int|null $itemId 指定商品ID，null表示处理所有商品
     * @param int $batchSize 批处理大小
     * @return array 撮合结果
     */
    public static function executeUserBuyItemMatch(?int $itemId = null, int $batchSize = 100): array
    {
        $startTime = microtime(true);
        $totalMatched = 0;
        $totalAmount = '0.00000';
        $processedItems = [];
        $errors = [];

        try {
            if ($itemId) {
                // 处理指定商品
                $result = self::executeUserBuyItemMatchForItem($itemId, $batchSize);
                $processedItems[] = $itemId;
                $totalMatched += $result['matched_orders'];
                $totalAmount = bcadd($totalAmount, $result['total_amount'], 5);
                if (!$result['success']) {
                    $errors[] = "商品 {$itemId}: " . $result['message'];
                }
            } else {
                // 处理所有有待撮合的用户买入物品订单的商品
                $itemIds = MexOrder::where('order_type', OrderType::BUY)
                    ->where('status', OrderStatus::PENDING)
                    ->distinct()
                    ->pluck('item_id')
                    ->toArray();

                foreach ($itemIds as $currentItemId) {
                    $result = self::executeUserBuyItemMatchForItem($currentItemId, $batchSize);
                    $processedItems[] = $currentItemId;
                    $totalMatched += $result['matched_orders'];
                    $totalAmount = bcadd($totalAmount, $result['total_amount'], 5);

                    if (!$result['success']) {
                        $errors[] = "商品 {$currentItemId}: " . $result['message'];
                    }
                }
            }

            $endTime = microtime(true);
            $executionTime = round(($endTime - $startTime) * 1000, 2); // 毫秒

            Log::info('Mex用户买入物品撮合任务执行完成', [
                'processed_items' => $processedItems,
                'total_matched' => $totalMatched,
                'total_amount' => $totalAmount,
                'execution_time_ms' => $executionTime,
                'errors' => $errors,
            ]);

            return [
                'success' => true,
                'message' => '用户买入物品撮合任务执行完成',
                'processed_items' => $processedItems,
                'total_matched' => $totalMatched,
                'total_amount' => $totalAmount,
                'execution_time_ms' => $executionTime,
                'errors' => $errors,
            ];
        } catch (\Exception $e) {
            Log::error('Mex用户买入物品撮合任务执行失败', [
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString(),
            ]);

            return [
                'success' => false,
                'message' => '用户买入物品撮合任务执行失败：' . $e->getMessage(),
                'processed_items' => $processedItems,
                'total_matched' => $totalMatched,
                'total_amount' => $totalAmount,
            ];
        }
    }

    /**
     * 执行用户卖出物品撮合任务
     *
     * @param int|null $itemId 指定商品ID，null表示处理所有商品
     * @param int $batchSize 批处理大小
     * @return array 撮合结果
     */
    public static function executeUserSellItemMatch(?int $itemId = null, int $batchSize = 100): array
    {
        $startTime = microtime(true);
        $totalMatched = 0;
        $totalAmount = '0.00000';
        $processedItems = [];
        $errors = [];

        try {
            if ($itemId) {
                // 处理指定商品
                $result = self::executeUserSellItemMatchForItem($itemId, $batchSize);
                $processedItems[] = $itemId;
                $totalMatched += $result['matched_orders'];
                $totalAmount = bcadd($totalAmount, $result['total_amount'], 5);
                if (!$result['success']) {
                    $errors[] = "商品 {$itemId}: " . $result['message'];
                }
            } else {
                // 处理所有有待撮合的用户卖出物品订单的商品
                $itemIds = MexOrder::where('order_type', OrderType::SELL)
                    ->where('status', OrderStatus::PENDING)
                    ->distinct()
                    ->pluck('item_id')
                    ->toArray();

                foreach ($itemIds as $currentItemId) {
                    $result = self::executeUserSellItemMatchForItem($currentItemId, $batchSize);
                    $processedItems[] = $currentItemId;
                    $totalMatched += $result['matched_orders'];
                    $totalAmount = bcadd($totalAmount, $result['total_amount'], 5);

                    if (!$result['success']) {
                        $errors[] = "商品 {$currentItemId}: " . $result['message'];
                    }
                }
            }

            $endTime = microtime(true);
            $executionTime = round(($endTime - $startTime) * 1000, 2); // 毫秒

            Log::info('Mex用户卖出物品撮合任务执行完成', [
                'processed_items' => $processedItems,
                'total_matched' => $totalMatched,
                'total_amount' => $totalAmount,
                'execution_time_ms' => $executionTime,
                'errors' => $errors,
            ]);

            return [
                'success' => true,
                'message' => '用户卖出物品撮合任务执行完成',
                'processed_items' => $processedItems,
                'total_matched' => $totalMatched,
                'total_amount' => $totalAmount,
                'execution_time_ms' => $executionTime,
                'errors' => $errors,
            ];
        } catch (\Exception $e) {
            Log::error('Mex用户卖出物品撮合任务执行失败', [
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString(),
            ]);

            return [
                'success' => false,
                'message' => '用户卖出物品撮合任务执行失败：' . $e->getMessage(),
                'processed_items' => $processedItems,
                'total_matched' => $totalMatched,
                'total_amount' => $totalAmount,
            ];
        }
    }

    /**
     * 执行单个商品的用户买入物品撮合
     *
     * @param int $itemId 商品ID
     * @param int $batchSize 批处理大小
     * @return array 撮合结果
     */
    public static function executeUserBuyItemMatchForItem(int $itemId, int $batchSize = 100): array
    {
        $startTime = microtime(true);

        try {
            // 注意：根据文档要求，Logic层不应该开启事务，事务应该在Service层处理
            // 检查用户买入物品撮合条件
            $conditionCheck = self::checkUserBuyItemMatchConditions($itemId);
            if (!$conditionCheck['can_match']) {
                $result = [
                    'success' => false,
                    'message' => $conditionCheck['message'],
                    'matched_orders' => 0,
                    'total_amount' => '0.00000',
                ];

                // 记录撮合日志
                $endTime = microtime(true);
                $executionTimeMs = round(($endTime - $startTime) * 1000);
                MexMatchLogLogic::logMatch(MatchType::USER_BUY, $itemId, $batchSize, $result, $executionTimeMs);

                return $result;
            }

                $warehouse = $conditionCheck['warehouse'];
                $priceConfig = $conditionCheck['price_config'];

                // 获取待撮合的用户买入物品订单（MySQL查询时完成筛选和二级排序）
                $buyOrders = MexOrder::where('item_id', $itemId)
                    ->where('order_type', OrderType::BUY)
                    ->where('status', OrderStatus::PENDING)
                    ->where('price', '>=', $priceConfig->max_price) // 价格验证：价格≥最高价
                    ->where('quantity', '<=', $priceConfig->protection_threshold) // 数量保护：数量≤保护阈值
                    ->orderBy('price', 'desc')      // 价格优先（高价优先）
                    ->orderBy('created_at', 'asc')  // 时间优先（早下单优先）
                    ->limit($batchSize)
                    ->get();

                if ($buyOrders->isEmpty()) {
                    $result = [
                        'success' => true,
                        'message' => '没有符合条件的用户买入物品订单',
                        'matched_orders' => 0,
                        'total_amount' => '0.00000',
                    ];

                    // 记录撮合日志
                    $endTime = microtime(true);
                    $executionTimeMs = round(($endTime - $startTime) * 1000);
                    MexMatchLogLogic::logMatch(MatchType::USER_BUY, $itemId, $batchSize, $result, $executionTimeMs);

                    return $result;
                }

                $matchedOrders = 0;
                $totalAmount = '0.00000';
                $currentStock = $warehouse->quantity;

                foreach ($buyOrders as $order) {
                    // 检查库存是否充足（整单匹配原则）
                    if ($currentStock < $order->quantity) {
                        // 库存不足时结束本次撮合处理，避免无效循环
                        break;
                    }

                    // 执行用户买入物品订单撮合
                    $matchResult = self::executeUserBuyItemOrderMatch($order, $warehouse);
                    if ($matchResult['success']) {
                        $matchedOrders++;
                        $totalAmount = bcadd($totalAmount, $matchResult['total_amount'], 5);
                        $currentStock -= $order->quantity;

                        // 更新仓库对象的库存（用于后续订单判断）
                        $warehouse->quantity = $currentStock;
                    }
                }

            $result = [
                'success' => true,
                'message' => "成功撮合 {$matchedOrders} 个用户买入物品订单",
                'matched_orders' => $matchedOrders,
                'total_amount' => $totalAmount,
            ];

            // 记录撮合日志
            $endTime = microtime(true);
            $executionTimeMs = round(($endTime - $startTime) * 1000);
            MexMatchLogLogic::logMatch(MatchType::USER_BUY, $itemId, $batchSize, $result, $executionTimeMs);

            return $result;
        } catch (\Exception $e) {
            $result = [
                'success' => false,
                'message' => '用户买入物品撮合执行失败：' . $e->getMessage(),
                'matched_orders' => 0,
                'total_amount' => '0.00000',
            ];

            // 记录撮合日志（包含错误信息）
            $endTime = microtime(true);
            $executionTimeMs = round(($endTime - $startTime) * 1000);
            MexMatchLogLogic::logMatch(MatchType::USER_BUY, $itemId, $batchSize, $result, $executionTimeMs, $e->getMessage());

            return $result;
        }
    }

    /**
     * 执行单个商品的用户卖出物品撮合
     *
     * @param int $itemId 商品ID
     * @param int $batchSize 批处理大小
     * @return array 撮合结果
     */
    public static function executeUserSellItemMatchForItem(int $itemId, int $batchSize = 100): array
    {
        $startTime = microtime(true);

        try {
            // 注意：根据文档要求，Logic层不应该开启事务，事务应该在Service层处理
            // 检查用户卖出物品撮合条件
            $conditionCheck = self::checkUserSellItemMatchConditions($itemId);
            if (!$conditionCheck['can_match']) {
                $result = [
                    'success' => false,
                    'message' => $conditionCheck['message'],
                    'matched_orders' => 0,
                    'total_amount' => '0.00000',
                ];

                // 记录撮合日志
                $endTime = microtime(true);
                $executionTimeMs = round(($endTime - $startTime) * 1000);
                MexMatchLogLogic::logMatch(MatchType::USER_SELL, $itemId, $batchSize, $result, $executionTimeMs);

                return $result;
            }

                $priceConfig = $conditionCheck['price_config'];

                // 获取待撮合的用户卖出物品订单
                $sellOrders = MexOrder::where('item_id', $itemId)
                    ->where('order_type', OrderType::SELL)
                    ->where('status', OrderStatus::PENDING)
                    ->limit($batchSize)
                    ->get();

                if ($sellOrders->isEmpty()) {
                    $result = [
                        'success' => true,
                        'message' => '没有待撮合的用户卖出物品订单',
                        'matched_orders' => 0,
                        'total_amount' => '0.00000',
                    ];

                    // 记录撮合日志
                    $endTime = microtime(true);
                    $executionTimeMs = round(($endTime - $startTime) * 1000);
                    MexMatchLogLogic::logMatch(MatchType::USER_SELL, $itemId, $batchSize, $result, $executionTimeMs);

                    return $result;
                }

                $matchedOrders = 0;
                $totalAmount = '0.00000';

                foreach ($sellOrders as $order) {
                    // 价格验证：用户卖出物品价格≤最低价
                    if (bccomp($order->price, $priceConfig->min_price, 5) > 0) {
                        continue; // 价格不符合条件，跳过此订单
                    }

                    // 执行用户卖出物品订单撮合
                    $matchResult = self::executeUserSellItemOrderMatch($order);
                    if ($matchResult['success']) {
                        $matchedOrders++;
                        $totalAmount = bcadd($totalAmount, $matchResult['total_amount'], 5);
                    }
                }

            $result = [
                'success' => true,
                'message' => "成功撮合 {$matchedOrders} 个用户卖出物品订单",
                'matched_orders' => $matchedOrders,
                'total_amount' => $totalAmount,
            ];

            // 记录撮合日志
            $endTime = microtime(true);
            $executionTimeMs = round(($endTime - $startTime) * 1000);
            MexMatchLogLogic::logMatch(MatchType::USER_SELL, $itemId, $batchSize, $result, $executionTimeMs);

            return $result;
        } catch (\Exception $e) {
            $result = [
                'success' => false,
                'message' => '用户卖出物品撮合执行失败：' . $e->getMessage(),
                'matched_orders' => 0,
                'total_amount' => '0.00000',
            ];

            // 记录撮合日志（包含错误信息）
            $endTime = microtime(true);
            $executionTimeMs = round(($endTime - $startTime) * 1000);
            MexMatchLogLogic::logMatch(MatchType::USER_SELL, $itemId, $batchSize, $result, $executionTimeMs, $e->getMessage());

            return $result;
        }
    }

    /**
     * 执行单个用户买入物品订单的撮合
     *
     * @param MexOrder $order 用户买入物品订单
     * @param MexWarehouse $warehouse 仓库信息
     * @return array 撮合结果
     */
    private static function executeUserBuyItemOrderMatch(MexOrder $order, MexWarehouse $warehouse): array
    {
        try {
            // 计算成交金额
            $totalAmount = bcmul($order->price, $order->quantity, 5);

            // 先执行账户流转逻辑，确保资金和物品流转成功后再更新订单状态和创建成交记录
            // 1. 用户冻结资金转入仓库账户
            $fundResult = self::transferFrozenFundsToWarehouse($order->user_id, $totalAmount, $order->id, $order->currency_type);
            if (!$fundResult['success']) {
                throw new \Exception('资金流转失败：' . $fundResult['message']);
            }

            // 2. 仓库账户物品转出到用户账户
            $itemResult = self::transferItemsFromWarehouseToUser($order->user_id, $order->item_id, $order->quantity, $order->id);
            if (!$itemResult['success']) {
                throw new \Exception('物品流转失败：' . $itemResult['message']);
            }

            // 资金和物品流转成功后，更新订单状态
            $order->update([
                'status' => OrderStatus::COMPLETED,
                'completed_quantity' => $order->quantity,
                'completed_amount' => $totalAmount,
                'completed_at' => now(),
            ]);

            // 更新仓库库存
            $warehouse->quantity -= $order->quantity;
            $warehouse->total_sell_quantity += $order->quantity;
            $warehouse->total_sell_amount = bcadd($warehouse->total_sell_amount, $totalAmount, 5);
            $warehouse->last_transaction_at = now();
            $warehouse->save();

            // 创建成交记录
            $transaction = MexTransaction::create([
                'buy_order_id' => $order->id,
                'sell_order_id' => null,
                'buyer_id' => $order->user_id,
                'seller_id' => self::WAREHOUSE_USER_ID, // 仓库账户作为卖方
                'item_id' => $order->item_id,
                'currency_type' => $order->currency_type->value,
                'quantity' => $order->quantity,
                'price' => $order->price,
                'total_amount' => $totalAmount,
                'transaction_type' => TransactionType::USER_BUY,
                'is_admin_operation' => false,
            ]);

            // 验证成交记录是否创建成功
            if (!$transaction || !$transaction->id) {
                throw new \Exception('成交记录创建失败');
            }

            return [
                'success' => true,
                'message' => '订单撮合成功',
                'order_id' => $order->id,
                'transaction_id' => $transaction->id,
                'total_amount' => $totalAmount,
            ];
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '订单撮合失败：' . $e->getMessage(),
                'order_id' => $order->id,
                'total_amount' => '0.00000',
            ];
        }
    }



    /**
     * 执行单个用户卖出物品订单的撮合
     *
     * @param MexOrder $order 用户卖出物品订单
     * @return array 撮合结果
     */
    private static function executeUserSellItemOrderMatch(MexOrder $order): array
    {
        try {
            // 计算成交金额
            $totalAmount = bcmul($order->price, $order->quantity, 5);

            // 先执行账户流转逻辑，确保资金和物品流转成功后再更新订单状态和创建成交记录
            // 1. 用户冻结物品转入仓库账户
            $itemResult = self::transferFrozenItemsToWarehouse($order->user_id, $order->item_id, $order->quantity, $order->id);
            if (!$itemResult['success']) {
                throw new \Exception('物品流转失败：' . $itemResult['message']);
            }

            // 2. 仓库账户资金转出到用户账户
            $fundResult = self::transferFundsFromWarehouseToUser($order->user_id, $totalAmount, $order->id, $order->currency_type);
            if (!$fundResult['success']) {
                throw new \Exception('资金流转失败：' . $fundResult['message']);
            }

            // 资金和物品流转成功后，更新订单状态
            $order->update([
                'status' => OrderStatus::COMPLETED,
                'completed_quantity' => $order->quantity,
                'completed_amount' => $totalAmount,
                'completed_at' => now(),
            ]);

            // 更新仓库库存
            $warehouse = MexWarehouse::where('item_id', $order->item_id)->first();
            if (!$warehouse) {
                // 如果仓库记录不存在，创建新记录
                $warehouse = MexWarehouse::create([
                    'item_id' => $order->item_id,
                    'quantity' => $order->quantity,
                    'total_buy_amount' => $totalAmount,
                    'total_buy_quantity' => $order->quantity,
                    'last_transaction_at' => now(),
                ]);
            } else {
                // 更新现有仓库记录
                $warehouse->quantity += $order->quantity;
                $warehouse->total_buy_quantity += $order->quantity;
                $warehouse->total_buy_amount = bcadd($warehouse->total_buy_amount, $totalAmount, 5);
                $warehouse->last_transaction_at = now();
                $warehouse->save();
            }

            // 创建成交记录
            $transaction = MexTransaction::create([
                'buy_order_id' => null,
                'sell_order_id' => $order->id,
                'buyer_id' => self::WAREHOUSE_USER_ID, // 仓库账户作为买方
                'seller_id' => $order->user_id,
                'item_id' => $order->item_id,
                'currency_type' => $order->currency_type->value,
                'quantity' => $order->quantity,
                'price' => $order->price,
                'total_amount' => $totalAmount,
                'transaction_type' => TransactionType::USER_SELL,
                'is_admin_operation' => false,
            ]);

            // 验证成交记录是否创建成功
            if (!$transaction || !$transaction->id) {
                throw new \Exception('成交记录创建失败');
            }

            return [
                'success' => true,
                'message' => '用户卖出物品订单撮合成功',
                'order_id' => $order->id,
                'transaction_id' => $transaction->id,
                'total_amount' => $totalAmount,
            ];
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '用户卖出物品订单撮合失败：' . $e->getMessage(),
                'order_id' => $order->id,
                'total_amount' => '0.00000',
            ];
        }
    }

    /**
     * 检查用户买入物品撮合条件
     *
     * @param int $itemId 商品ID
     * @return array 检查结果
     */
    public static function checkUserBuyItemMatchConditions(int $itemId): array
    {
        // 检查价格配置
        $priceConfig = MexPriceConfig::where('item_id', $itemId)->where('is_enabled', true)->first();
        if (!$priceConfig) {
            return [
                'can_match' => false,
                'message' => '商品未配置价格信息或已禁用',
            ];
        }

        // 检查仓库库存
        $warehouse = MexWarehouse::where('item_id', $itemId)->first();
        if (!$warehouse || $warehouse->quantity <= 0) {
            return [
                'can_match' => false,
                'message' => '仓库库存不足',
            ];
        }

        // 检查是否有符合条件的待撮合用户买入物品订单
        $pendingBuyOrders = MexOrder::where('item_id', $itemId)
            ->where('order_type', OrderType::BUY)
            ->where('status', OrderStatus::PENDING)
            ->where('price', '>=', $priceConfig->max_price) // 价格≥最高价
            ->where('quantity', '<=', $priceConfig->protection_threshold) // 数量≤保护阈值
            ->count();

        if ($pendingBuyOrders === 0) {
            return [
                'can_match' => false,
                'message' => '没有符合条件的待撮合用户买入物品订单',
            ];
        }

        return [
            'can_match' => true,
            'message' => '用户买入物品撮合条件满足',
            'warehouse' => $warehouse,
            'price_config' => $priceConfig,
            'pending_orders' => $pendingBuyOrders,
        ];
    }

    /**
     * 检查用户卖出物品撮合条件
     *
     * @param int $itemId 商品ID
     * @return array 检查结果
     */
    public static function checkUserSellItemMatchConditions(int $itemId): array
    {
        // 检查价格配置
        $priceConfig = MexPriceConfig::where('item_id', $itemId)->where('is_enabled', true)->first();
        if (!$priceConfig) {
            return [
                'can_match' => false,
                'message' => '商品未配置价格信息或已禁用',
            ];
        }

        // 检查是否有待撮合的用户卖出物品订单
        $pendingSellOrders = MexOrder::where('item_id', $itemId)
            ->where('order_type', OrderType::SELL)
            ->where('status', OrderStatus::PENDING)
            ->count();

        if ($pendingSellOrders === 0) {
            return [
                'can_match' => false,
                'message' => '没有待撮合的用户卖出物品订单',
            ];
        }

        return [
            'can_match' => true,
            'message' => '用户卖出物品撮合条件满足',
            'price_config' => $priceConfig,
            'pending_orders' => $pendingSellOrders,
        ];
    }

    /**
     * 获取用户买入物品撮合统计信息
     *
     * @return array 统计信息
     */
    public static function getUserBuyItemMatchStats(): array
    {
        // 获取待撮合用户买入物品订单统计
        $pendingStats = MexOrder::where('order_type', OrderType::BUY)
            ->where('status', OrderStatus::PENDING)
            ->selectRaw('
                COUNT(*) as total_pending,
                COUNT(DISTINCT item_id) as pending_items,
                SUM(quantity) as total_quantity,
                SUM(total_amount) as total_amount
            ')
            ->first();

        // 获取今日用户买入物品撮合统计
        $todayStats = MexTransaction::where('transaction_type', TransactionType::USER_BUY)
            ->whereDate('created_at', today())
            ->selectRaw('
                COUNT(*) as today_matched,
                SUM(quantity) as today_quantity,
                SUM(total_amount) as today_amount
            ')
            ->first();

        // 获取有库存的商品数量
        $availableItems = MexWarehouse::where('quantity', '>', 0)->count();

        return [
            'pending_orders' => $pendingStats->total_pending ?? 0,
            'pending_items' => $pendingStats->pending_items ?? 0,
            'pending_quantity' => $pendingStats->total_quantity ?? 0,
            'pending_amount' => $pendingStats->total_amount ?? '0.00000',
            'today_matched' => $todayStats->today_matched ?? 0,
            'today_quantity' => $todayStats->today_quantity ?? 0,
            'today_amount' => $todayStats->today_amount ?? '0.00000',
            'available_items' => $availableItems,
            'stats_time' => now(),
        ];
    }

    /**
     * 获取用户卖出物品撮合统计信息
     *
     * @return array 统计信息
     */
    public static function getUserSellItemMatchStats(): array
    {
        // 获取待撮合用户卖出物品订单统计
        $pendingStats = MexOrder::where('order_type', OrderType::SELL)
            ->where('status', OrderStatus::PENDING)
            ->selectRaw('
                COUNT(*) as total_pending,
                COUNT(DISTINCT item_id) as pending_items,
                SUM(quantity) as total_quantity,
                SUM(total_amount) as total_amount
            ')
            ->first();

        // 获取今日用户卖出物品撮合统计
        $todayStats = MexTransaction::where('transaction_type', TransactionType::USER_SELL)
            ->whereDate('created_at', today())
            ->selectRaw('
                COUNT(*) as today_matched,
                SUM(quantity) as today_quantity,
                SUM(total_amount) as today_amount
            ')
            ->first();

        return [
            'pending_orders' => $pendingStats->total_pending ?? 0,
            'pending_items' => $pendingStats->pending_items ?? 0,
            'pending_quantity' => $pendingStats->total_quantity ?? 0,
            'pending_amount' => $pendingStats->total_amount ?? '0.00000',
            'today_matched' => $todayStats->today_matched ?? 0,
            'today_quantity' => $todayStats->today_quantity ?? 0,
            'today_amount' => $todayStats->today_amount ?? '0.00000',
            'stats_time' => now(),
        ];
    }

    // 保留旧方法以兼容现有代码
    /**
     * 获取撮合统计信息（已废弃，请使用getUserBuyItemMatchStats）
     *
     * @deprecated 请使用getUserBuyItemMatchStats或getUserSellItemMatchStats
     * @return array 统计信息
     */
    public static function getMatchStats(): array
    {
        return self::getUserBuyItemMatchStats();
    }

    /**
     * 检查撮合条件（已废弃，请使用checkUserBuyItemMatchConditions）
     *
     * @deprecated 请使用checkUserBuyItemMatchConditions或checkUserSellItemMatchConditions
     * @param int $itemId 商品ID
     * @return array 检查结果
     */
    public static function checkMatchConditions(int $itemId): array
    {
        return self::checkUserBuyItemMatchConditions($itemId);
    }

    /**
     * 执行撮合任务（已废弃，请使用executeUserBuyItemMatch）
     *
     * @deprecated 请使用executeUserBuyItemMatch或executeUserSellItemMatch
     * @param int|null $itemId 指定商品ID，null表示处理所有商品
     * @param int $batchSize 批处理大小
     * @return array 撮合结果
     */
    public static function executeMatch(?int $itemId = null, int $batchSize = 100): array
    {
        return self::executeUserBuyItemMatch($itemId, $batchSize);
    }

    /**
     * 执行单个商品的撮合（已废弃，请使用executeUserBuyItemMatchForItem）
     *
     * @deprecated 请使用executeUserBuyItemMatchForItem或executeUserSellItemMatchForItem
     * @param int $itemId 商品ID
     * @param int $batchSize 批处理大小
     * @return array 撮合结果
     */
    public static function executeItemMatch(int $itemId, int $batchSize = 100): array
    {
        return self::executeUserBuyItemMatchForItem($itemId, $batchSize);
    }

    /**
     * 将用户冻结资金转入仓库账户
     *
     * @param int $userId 用户ID
     * @param string $amount 金额
     * @param int $orderId 订单ID
     * @param FUND_CURRENCY_TYPE|null $currencyType 币种类型，默认使用钻石
     * @return array 转移结果
     */
    private static function transferFrozenFundsToWarehouse(int $userId, string $amount, int $orderId, ?FUND_CURRENCY_TYPE $currencyType = null): array
    {
        try {
            // 获取币种类型，默认使用钻石
            $currencyType = $currencyType ?? FundLogic::getDefaultCurrency();

            // 获取对应的冻结账户类型
            $frozenAccountType = FundLogic::getFrozenAccountType($currencyType);
            if (!$frozenAccountType) {
                return [
                    'success' => false,
                    'message' => '不支持的币种类型',
                ];
            }

            // 从用户冻结账户转移到仓库账户
            $fundService = new FundService($userId, $frozenAccountType->value);
            $precision = $currencyType->getPrecision();
            $fundAmount = (int)bcmul($amount, bcpow('10', $precision), 0); // 根据币种精度转换

            $result = $fundService->trade(
                self::WAREHOUSE_USER_ID,
                $fundAmount,
                'MEX_ORDER',
                $orderId,
                '用户买入物品撮合-资金转移'
            );

            if (is_string($result)) {
                return [
                    'success' => false,
                    'message' => $result,
                ];
            }

            return [
                'success' => true,
                'message' => '资金转移成功',
                'data' => $result,
            ];
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '资金转移异常：' . $e->getMessage(),
            ];
        }
    }

    /**
     * 将仓库账户物品转出到用户账户
     *
     * @param int $userId 用户ID
     * @param int $itemId 物品ID
     * @param int $quantity 数量
     * @param int $orderId 订单ID
     * @return array 转移结果
     */
    private static function transferItemsFromWarehouseToUser(int $userId, int $itemId, int $quantity, int $orderId): array
    {
        try {
            // 添加物品到用户账户
            $result = ItemService::addItem($userId, $itemId, $quantity, [
                'source' => 'mex_order',
                'source_type'    => REWARD_SOURCE_TYPE::MEX_BUY,
                'source_id' => $orderId,
                'remark' => '用户买入物品撮合-物品转移',
            ]);

            if (!$result || !isset($result['success']) || !$result['success']) {
                return [
                    'success' => false,
                    'message' => '物品添加失败：' . ($result['message'] ?? '未知错误'),
                ];
            }

            return [
                'success' => true,
                'message' => '物品转移成功',
                'data' => $result,
            ];
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '物品转移异常：' . $e->getMessage(),
            ];
        }
    }

    /**
     * 将用户冻结物品转入仓库账户
     *
     * @param int $userId 用户ID
     * @param int $itemId 物品ID
     * @param int $quantity 数量
     * @param int $orderId 订单ID
     * @return array 转移结果
     */
    private static function transferFrozenItemsToWarehouse(int $userId, int $itemId, int $quantity, int $orderId): array
    {
        try {
            // TODO: 这里需要实现从用户冻结物品转移到仓库的逻辑
            // 由于物品冻结功能比较复杂，这里先返回成功，后续完善

            // 消耗用户物品（包括冻结的物品）
            $result = ItemService::consumeItem($userId, $itemId, null, $quantity, [
                'source' => 'mex_order',
                'source_id' => $orderId,
                'remark' => '用户卖出物品撮合-物品转移',
                'include_frozen' => true, // 包括冻结的物品
            ]);

            if (!$result || !isset($result['success']) || !$result['success']) {
                return [
                    'success' => false,
                    'message' => '物品消耗失败：' . ($result['message'] ?? '未知错误'),
                ];
            }

            return [
                'success' => true,
                'message' => '物品转移成功',
                'data' => $result,
            ];
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '物品转移异常：' . $e->getMessage(),
            ];
        }
    }

    /**
     * 将仓库账户资金转出到用户账户
     *
     * @param int $userId 用户ID
     * @param string $amount 金额
     * @param int $orderId 订单ID
     * @param FUND_CURRENCY_TYPE|null $currencyType 币种类型，默认使用钻石
     * @return array 转移结果
     */
    private static function transferFundsFromWarehouseToUser(int $userId, string $amount, int $orderId, ?FUND_CURRENCY_TYPE $currencyType = null): array
    {
        try {
            // 获取币种类型，默认使用钻石
            $currencyType = $currencyType ?? FundLogic::getDefaultCurrency();

            // 获取对应的可用账户类型
            $availableAccountType = FundLogic::getAvailableAccountType($currencyType);
            if (!$availableAccountType) {
                return [
                    'success' => false,
                    'message' => '不支持的币种类型',
                ];
            }

            // 从仓库账户转移到用户账户
            $fundService = new FundService(self::WAREHOUSE_USER_ID, $availableAccountType->value);
            $precision = $currencyType->getPrecision();
            $fundAmount = (int)bcmul($amount, bcpow('10', $precision), 0); // 根据币种精度转换

            $result = $fundService->trade(
                $userId,
                $fundAmount,
                'MEX_ORDER',
                $orderId,
                '用户卖出物品撮合-资金转移'
            );

            if (is_string($result)) {
                return [
                    'success' => false,
                    'message' => $result,
                ];
            }

            return [
                'success' => true,
                'message' => '资金转移成功',
                'data' => $result,
            ];
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '资金转移异常：' . $e->getMessage(),
            ];
        }
    }
}