<?php

namespace Tests\Unit\AppGame;

use Tests\TestCase;
use App\Module\AppGame\Handler\Land\SowHandler;
use App\Module\Farm\Validations\CropPlantValidation;
use App\Module\Farm\Validators\SeedLandTypeValidator;
use App\Module\Farm\Models\FarmLand;
use App\Module\Farm\Enums\LAND_TYPE;
use App\Module\Farm\Enums\LAND_STATUS;
use Uraus\Kku\Request\RequestLandSow;
use Uraus\Kku\Response\ResponseLandSow;


/**
 * SowHandler单元测试
 *
 * 重点测试玫瑰种子的土地类型限制功能
 */
class SowHandlerTest extends TestCase
{

    /**
     * 测试用户ID
     */
    private int $testUserId = 1;

    /**
     * 玫瑰种子物品ID
     */
    private int $roseSeedItemId = 17;

    /**
     * 设置测试环境
     */
    protected function setUp(): void
    {
        parent::setUp();
    }

    /**
     * 测试RequestLandSow请求对象结构
     */
    public function testRequestLandSowStructure()
    {
        $request = new RequestLandSow();

        // 测试设置土地ID
        $request->setLandId(1);
        $this->assertEquals(1, $request->getLandId());

        // 测试设置种子物品ID
        $request->setItemId(17);
        $this->assertEquals(17, $request->getItemId());

        // 测试设置种子实例ID
        $request->setItemInstanceId(100);
        $this->assertEquals(100, $request->getItemInstanceId());
    }

    /**
     * 测试ResponseLandSow响应对象结构
     */
    public function testResponseLandSowStructure()
    {
        $response = new ResponseLandSow();
        $this->assertInstanceOf(ResponseLandSow::class, $response);
    }

    /**
     * 测试SowHandler类结构
     */
    public function testSowHandlerStructure()
    {
        $this->assertTrue(class_exists(SowHandler::class));

        // 验证SowHandler是BaseHandler的子类
        $reflection = new \ReflectionClass(SowHandler::class);
        $this->assertTrue($reflection->isSubclassOf(\App\Module\AppGame\Handler\BaseHandler::class));
    }

    /**
     * 测试种子土地类型验证器 - 玫瑰种子在普通土地种植失败
     */
    public function testSeedLandTypeValidator_RoseSeedOnNormalLandFails()
    {
        // 创建模拟的验证对象
        $validation = new CropPlantValidation([]);

        // 创建模拟的普通土地
        $normalLand = new FarmLand();
        $normalLand->id = 1;
        $normalLand->user_id = $this->testUserId;
        $normalLand->land_type = LAND_TYPE::NORMAL->value;
        $normalLand->status = LAND_STATUS::IDLE->value;

        // 设置土地到验证对象
        $validation->land = $normalLand;

        // 创建验证器
        $validator = new SeedLandTypeValidator($validation, ['land']);

        // 验证应该失败
        $result = $validator->validate($this->roseSeedItemId, []);
        $this->assertFalse($result);
    }

    /**
     * 测试种子土地类型验证器 - 玫瑰种子在金土地种植成功
     */
    public function testSeedLandTypeValidator_RoseSeedOnGoldLandSucceeds()
    {
        // 创建模拟的验证对象
        $validation = new CropPlantValidation([]);

        // 创建模拟的金土地
        $goldLand = new FarmLand();
        $goldLand->id = 2;
        $goldLand->user_id = $this->testUserId;
        $goldLand->land_type = LAND_TYPE::GOLD->value;
        $goldLand->status = LAND_STATUS::IDLE->value;

        // 设置土地到验证对象
        $validation->land = $goldLand;

        // 创建验证器
        $validator = new SeedLandTypeValidator($validation, ['land']);

        // 验证应该成功
        $result = $validator->validate($this->roseSeedItemId, []);
        $this->assertTrue($result);
    }

    /**
     * 测试普通种子在所有土地类型都能种植
     */
    public function testNormalSeedOnAllLandTypes()
    {
        // 使用现有的普通种子（假设ID为1，没有土地类型限制）
        $normalSeedId = 1;

        // 确保普通种子没有土地类型限制
        DB::table('farm_seeds')
            ->where('item_id', $normalSeedId)
            ->update(['allowed_land_types' => null]);

        // 创建用户物品
        $this->createTestUserItem($this->testUserId, $normalSeedId, 10);

        $landTypes = [
            LAND_TYPE::NORMAL->value,
            LAND_TYPE::RED->value,
            LAND_TYPE::BLACK->value,
            LAND_TYPE::GOLD->value,
            LAND_TYPE::BLUE->value,
            LAND_TYPE::PURPLE->value,
        ];

        foreach ($landTypes as $landType) {
            $land = $this->createTestLand($landType);

            $validation = new CropPlantValidation([
                'user_id' => $this->testUserId,
                'land_id' => $land->id,
                'item_id' => $normalSeedId,
                'item_instance_id' => 0
            ]);

            // 所有土地类型都应该验证通过
            $result = $validation->validated();
            $this->assertInstanceOf(CropPlantValidation::class, $result);
        }
    }

    /**
     * 清理测试数据
     */
    private function cleanupTestData(): void
    {
        try {
            // 清理测试用户的数据
            DB::table('farm_lands')->where('user_id', $this->testUserId)->delete();
            DB::table('item_users')->where('user_id', $this->testUserId)->delete();
        } catch (\Exception) {
            // 忽略清理错误，可能表不存在
        }
    }

    /**
     * 创建测试农场数据
     */
    private function createTestFarmData(): void
    {
        try {
            // 使用现有的玫瑰种子配置（item_id = 17）
            // 确保玫瑰种子有正确的土地类型限制
            DB::table('farm_seeds')
                ->where('item_id', $this->roseSeedItemId)
                ->update(['allowed_land_types' => json_encode([4, 5, 6])]);

            // 创建用户物品
            $this->createTestUserItem($this->testUserId, $this->roseSeedItemId, 10);
        } catch (\Exception) {
            // 忽略数据库错误
        }
    }

    /**
     * 创建测试土地
     */
    private function createTestLand(int $landType): FarmLand
    {
        return FarmLand::create([
            'user_id' => $this->testUserId,
            'land_type' => $landType,
            'status' => LAND_STATUS::IDLE->value,
            'position_x' => 1,
            'position_y' => 1,
        ]);
    }


    /**
     * 创建测试用户物品
     */
    private function createTestUserItem(int $userId, int $itemId, int $quantity): void
    {
        try {
            DB::table('item_users')->insert([
                'user_id' => $userId,
                'item_id' => $itemId,
                'quantity' => $quantity,
                'instance_id' => 0,
                'created_at' => now(),
                'updated_at' => now(),
            ]);
        } catch (\Exception) {
            // 忽略插入错误
        }
    }
}