<?php

namespace Tests\Unit\GameItems;

use App\Module\Game\Logics\ItemTemp;
use App\Module\GameItems\Enums\FREEZE_REASON_TYPE;
use App\Module\GameItems\Events\ItemQuantityChanged;
use App\Module\GameItems\Logics\ItemFreeze;
use App\Module\GameItems\Models\ItemUser;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Event;
use Tests\TestCase;

/**
 * 物品冻结同步修复验证测试
 *
 * 验证修复后的物品冻结拆堆同步功能
 */
class ItemFreezeSyncFixTest extends TestCase
{
    protected function setUp(): void
    {
        parent::setUp();
    }

    /**
     * 测试拆堆冻结后的lastdata同步修复
     * 
     * 验证拆堆时能正确同步两个物品堆的状态到lastdata
     */
    public function test_split_stack_freeze_lastdata_sync_fix()
    {
        DB::beginTransaction();
        
        try {
            $userId = 9999; // 使用一个不存在物品记录的用户ID
            $itemId = 2; // 使用现有的萝卜物品
            $originalQuantity = 200;
            $freezeQuantity = 80;

            // 清理可能存在的临时数据
            ItemTemp::clearUserItemChanges($userId);

            // 创建测试用户物品记录
            $userItem = ItemUser::create([
                'user_id' => $userId,
                'item_id' => $itemId,
                'instance_id' => null,
                'quantity' => $originalQuantity,
                'expire_at' => now()->addDays(30),
                'is_frozen' => false,
                'frozen_log_id' => null,
            ]);

            // 启用真实事件监听（不使用fake）
            $originalEventDispatcher = app('events');

            // 执行部分冻结操作（会触发拆堆）
            $result = ItemFreeze::freezeNormalItem(
                $userId,
                $itemId,
                $freezeQuantity,
                FREEZE_REASON_TYPE::TRADE_ORDER,
                12345,
                'test_order',
                null
            );

            // 验证冻结操作成功
            $this->assertTrue($result['success']);
            $this->assertEquals($freezeQuantity, $result['frozen_quantity']);

            // 验证临时数据中包含两个物品堆的变更信息
            $itemChanges = ItemTemp::getUserItemChanges($userId);


            $this->assertCount(2, $itemChanges, '应该有两个物品堆的变更记录');

            // 验证原堆叠的变更记录
            $originalStackChange = null;
            $frozenStackChange = null;
            
            foreach ($itemChanges as $change) {
                if ($change->userItemId === $userItem->id) {
                    $originalStackChange = $change;
                } else {
                    $frozenStackChange = $change;
                }
            }

            $this->assertNotNull($originalStackChange, '应该有原堆叠的变更记录');
            $this->assertNotNull($frozenStackChange, '应该有冻结堆叠的变更记录');

            // 验证原堆叠变更记录的正确性
            $this->assertEquals($itemId, $originalStackChange->itemId);
            $this->assertEquals($originalQuantity, $originalStackChange->oldQuantity);
            $this->assertEquals($originalQuantity - $freezeQuantity, $originalStackChange->newQuantity);
            $this->assertEquals(-$freezeQuantity, $originalStackChange->changeAmount);
            $this->assertFalse($originalStackChange->oldFrozenStatus);
            $this->assertFalse($originalStackChange->newFrozenStatus);

            // 验证冻结堆叠变更记录的正确性
            $this->assertEquals($itemId, $frozenStackChange->itemId);
            $this->assertEquals(0, $frozenStackChange->oldQuantity);
            $this->assertEquals($freezeQuantity, $frozenStackChange->newQuantity);
            $this->assertEquals($freezeQuantity, $frozenStackChange->changeAmount);
            $this->assertNull($frozenStackChange->oldFrozenStatus);
            $this->assertTrue($frozenStackChange->newFrozenStatus);

            // 验证数据库中的实际状态
            $userItem->refresh();
            $this->assertEquals($originalQuantity - $freezeQuantity, $userItem->quantity);
            $this->assertFalse($userItem->is_frozen);

            // 查找新创建的冻结堆叠
            $frozenItem = ItemUser::where('user_id', $userId)
                ->where('item_id', $itemId)
                ->where('is_frozen', true)
                ->where('quantity', $freezeQuantity)
                ->first();

            $this->assertNotNull($frozenItem, '应该有新创建的冻结堆叠');
            $this->assertEquals($freezeQuantity, $frozenItem->quantity);
            $this->assertTrue($frozenItem->is_frozen);

        } finally {
            DB::rollBack();
        }
    }

    /**
     * 测试全部冻结时的单堆同步
     * 
     * 验证全部冻结时只有一个物品堆状态变更
     */
    public function test_full_freeze_single_stack_sync()
    {
        DB::beginTransaction();
        
        try {
            $userId = 9998; // 使用一个不存在物品记录的用户ID
            $itemId = 3; // 使用现有的辣椒物品
            $quantity = 50;

            // 清理可能存在的临时数据
            ItemTemp::clearUserItemChanges($userId);

            // 创建测试用户物品记录
            $userItem = ItemUser::create([
                'user_id' => $userId,
                'item_id' => $itemId,
                'instance_id' => null,
                'quantity' => $quantity,
                'expire_at' => now()->addDays(30),
                'is_frozen' => false,
                'frozen_log_id' => null,
            ]);

            // 执行全部冻结操作（不会拆堆）
            $result = ItemFreeze::freezeNormalItem(
                $userId,
                $itemId,
                $quantity, // 全部冻结
                FREEZE_REASON_TYPE::TRADE_ORDER,
                12346,
                'test_order',
                null
            );

            // 验证冻结操作成功
            $this->assertTrue($result['success']);
            $this->assertEquals($quantity, $result['frozen_quantity']);

            // 验证临时数据中只有一个物品堆的变更信息
            $itemChanges = ItemTemp::getUserItemChanges($userId);
            $this->assertCount(1, $itemChanges, '应该只有一个物品堆的变更记录');

            $change = $itemChanges[0];
            $this->assertEquals($userItem->id, $change->userItemId);
            $this->assertEquals($itemId, $change->itemId);
            $this->assertEquals($quantity, $change->oldQuantity);
            $this->assertEquals($quantity, $change->newQuantity);
            $this->assertEquals(0, $change->changeAmount);
            $this->assertFalse($change->oldFrozenStatus);
            $this->assertTrue($change->newFrozenStatus);

            // 验证数据库中的实际状态
            $userItem->refresh();
            $this->assertEquals($quantity, $userItem->quantity);
            $this->assertTrue($userItem->is_frozen);

        } finally {
            DB::rollBack();
        }
    }
}