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();

                // 如果没有待撮合的订单，记录一条总体日志表示没有可处理的商品
                if (empty($itemIds)) {
                    $endTime = microtime(true);
                    $executionTimeMs = round(($endTime - $startTime) * 1000);

                    // 记录没有待撮合订单的日志（使用商品ID 0 表示全局撮合任务）
                    MexMatchLogLogic::logMatch(
                        MatchType::USER_BUY,
                        0, // 使用0表示全局撮合任务
                        $batchSize,
                        [
                            'success' => true,
                            'message' => '没有待撮合的用户买入物品订单',
                            'matched_orders' => 0,
                            'total_amount' => '0.00000',
                        ],
                        $executionTimeMs
                    );
                }

                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();

                // 如果没有待撮合的订单，记录一条总体日志表示没有可处理的商品
                if (empty($itemIds)) {
                    $endTime = microtime(true);
                    $executionTimeMs = round(($endTime - $startTime) * 1000);

                    // 记录没有待撮合订单的日志（使用商品ID 0 表示全局撮合任务）
                    MexMatchLogLogic::logMatch(
                        MatchType::USER_SELL,
                        0, // 使用0表示全局撮合任务
                        $batchSize,
                        [
                            'success' => true,
                            'message' => '没有待撮合的用户卖出物品订单',
                            'matched_orders' => 0,
                            'total_amount' => '0.00000',
                        ],
                        $executionTimeMs
                    );
                }

                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();

                // 为价格不符合条件的买入订单记录无法成交原因
                MexOrder::where('item_id', $itemId)
                    ->where('order_type', OrderType::BUY)
                    ->where('status', OrderStatus::PENDING)
                    ->where('price', '<', $priceConfig->max_price) // 价格低于最高价
                    ->update([
                        'last_match_failure_reason' => "价格验证失败：买入价格低于最高价格 {$priceConfig->max_price}"
                    ]);

                // 为数量超过保护阈值的买入订单记录无法成交原因
                MexOrder::where('item_id', $itemId)
                    ->where('order_type', OrderType::BUY)
                    ->where('status', OrderStatus::PENDING)
                    ->where('price', '>=', $priceConfig->max_price) // 价格符合条件
                    ->where('quantity', '>', $priceConfig->protection_threshold) // 数量超过保护阈值
                    ->update([
                        'last_match_failure_reason' => "数量保护：订单数量超过保护阈值 {$priceConfig->protection_threshold}"
                    ]);

                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) {
                        // 记录库存不足的无法成交原因
                        $order->update([
                            'last_match_failure_reason' => "库存不足：当前库存 {$currentStock}，需要 {$order->quantity}"
                        ]);

                        // 库存不足时结束本次撮合处理，避免无效循环
                        break;
                    }

                    // 执行用户买入物品订单撮合（带事务处理）
                    $matchResult = \App\Module\Mex\Services\MexMatchService::executeUserBuyItemOrderMatchWithTransaction($order, $warehouse);
                    if ($matchResult['success']) {
                        $matchedOrders++;
                        $totalAmount = bcadd($totalAmount, $matchResult['total_amount'], 5);
                        $currentStock -= $order->quantity;

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

                        // 清除之前的无法成交原因（如果有的话）
                        if ($order->last_match_failure_reason) {
                            $order->update(['last_match_failure_reason' => null]);
                        }
                    } else {
                        // 记录撮合失败的原因
                        $order->update([
                            'last_match_failure_reason' => $matchResult['message']
                        ]);
                    }
                }

            $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)
                    ->where('price', '<',$priceConfig->min_price)
                    ->orderBy('price', 'asc')
                    ->orderBy('id', 'asc')
                    ->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) {
                        Log::info('卖出订单价格验证失败', [
                            'order_id' => $order->id,
                            'order_price' => $order->price,
                            'min_price' => $priceConfig->min_price,
                            'price_compare' => bccomp($order->price, $priceConfig->min_price, 5)
                        ]);

                        // 记录价格验证失败的无法成交原因
                        $order->update([
                            'last_match_failure_reason' => "价格验证失败：卖出价格 {$order->price} 高于最低价格 {$priceConfig->min_price}"
                        ]);

                        continue; // 价格不符合条件，跳过此订单
                    }

                    // 执行用户卖出物品订单撮合（带事务处理）
                    $matchResult = \App\Module\Mex\Services\MexMatchService::executeUserSellItemOrderMatchWithTransaction($order);
                    if ($matchResult['success']) {
                        $matchedOrders++;
                        $totalAmount = bcadd($totalAmount, $matchResult['total_amount'], 5);
                        Log::info('卖出订单撮合成功', [
                            'order_id' => $order->id,
                            'total_amount' => $matchResult['total_amount']
                        ]);

                        // 清除之前的无法成交原因（如果有的话）
                        if ($order->last_match_failure_reason) {
                            $order->update(['last_match_failure_reason' => null]);
                        }
                    } else {
                        Log::error('卖出订单撮合失败', [
                            'order_id' => $order->id,
                            'error_message' => $matchResult['message']
                        ]);

                        // 记录撮合失败的原因
                        $order->update([
                            'last_match_failure_reason' => $matchResult['message']
                        ]);
                    }
                }

            $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 撮合结果
     */
    public static function executeUserBuyItemOrderMatch(MexOrder $order, MexWarehouse $warehouse): array
    {
        try {
            // 计算成交金额
            $totalAmount = bcmul($order->price, $order->quantity, 9);

            // 先执行账户流转逻辑，确保资金和物品流转成功后再更新订单状态和创建成交记录
            // 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 撮合结果
     */
    public 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(),
        ];
    }

    /**
     * 将用户冻结资金转入仓库账户
     *
     * @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);
            // 多少钱，就是多少钱，资金模块能够正确处理，不需要外部处理
            $result = $fundService->trade(
                self::WAREHOUSE_USER_ID,
                $amount,
                '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 {

            // 消耗用户物品（包括冻结的物品）
            $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);
            // 资金系统，能够正确处理金额，不需要外部处理
            $result = $fundService->trade(
                $userId,
                $amount,
                '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(),
            ];
        }
    }
}