<?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\Models\FarmSeed;
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 SowHandlerSimpleTest extends TestCase
{
    /**
     * 测试用户ID
     */
    private int $testUserId = 1;

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

    /**
     * 测试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);
    }

    /**
     * 测试FarmSeed模型的土地类型检查方法
     */
    public function testFarmSeedLandTypeCheckMethods()
    {
        // 创建模拟的玫瑰种子（有土地类型限制）
        $roseSeed = new FarmSeed();
        $roseSeed->item_id = 17;
        $roseSeed->allowed_land_types = [
            LAND_TYPE::GOLD,
            LAND_TYPE::BLUE,
            LAND_TYPE::PURPLE
        ];

        // 测试不能在普通土地种植
        $this->assertFalse($roseSeed->canPlantOnLandType(LAND_TYPE::NORMAL->value));
        $this->assertFalse($roseSeed->canPlantOnLandTypeOrHigher(LAND_TYPE::NORMAL->value));

        // 测试不能在红土地种植
        $this->assertFalse($roseSeed->canPlantOnLandType(LAND_TYPE::RED->value));
        $this->assertFalse($roseSeed->canPlantOnLandTypeOrHigher(LAND_TYPE::RED->value));

        // 测试不能在黑土地种植
        $this->assertFalse($roseSeed->canPlantOnLandType(LAND_TYPE::BLACK->value));
        $this->assertFalse($roseSeed->canPlantOnLandTypeOrHigher(LAND_TYPE::BLACK->value));

        // 测试可以在金土地种植
        $this->assertTrue($roseSeed->canPlantOnLandType(LAND_TYPE::GOLD->value));
        $this->assertTrue($roseSeed->canPlantOnLandTypeOrHigher(LAND_TYPE::GOLD->value));

        // 测试可以在蓝土地种植
        $this->assertTrue($roseSeed->canPlantOnLandType(LAND_TYPE::BLUE->value));
        $this->assertTrue($roseSeed->canPlantOnLandTypeOrHigher(LAND_TYPE::BLUE->value));

        // 测试可以在紫土地种植
        $this->assertTrue($roseSeed->canPlantOnLandType(LAND_TYPE::PURPLE->value));
        $this->assertTrue($roseSeed->canPlantOnLandTypeOrHigher(LAND_TYPE::PURPLE->value));
    }

    /**
     * 测试普通种子（无土地类型限制）
     */
    public function testNormalSeedWithoutLandTypeRestriction()
    {
        // 创建模拟的普通种子（无土地类型限制）
        $normalSeed = new FarmSeed();
        $normalSeed->item_id = 1;
        $normalSeed->allowed_land_types = null;

        // 测试普通种子可以在所有土地种植
        $this->assertTrue($normalSeed->canPlantOnLandType(LAND_TYPE::NORMAL->value));
        $this->assertTrue($normalSeed->canPlantOnLandType(LAND_TYPE::RED->value));
        $this->assertTrue($normalSeed->canPlantOnLandType(LAND_TYPE::BLACK->value));
        $this->assertTrue($normalSeed->canPlantOnLandType(LAND_TYPE::GOLD->value));
        $this->assertTrue($normalSeed->canPlantOnLandType(LAND_TYPE::BLUE->value));
        $this->assertTrue($normalSeed->canPlantOnLandType(LAND_TYPE::PURPLE->value));

        // 测试"及以上等级"方法
        $this->assertTrue($normalSeed->canPlantOnLandTypeOrHigher(LAND_TYPE::NORMAL->value));
        $this->assertTrue($normalSeed->canPlantOnLandTypeOrHigher(LAND_TYPE::GOLD->value));
    }

    /**
     * 测试土地等级概念
     */
    public function testLandTypeHierarchy()
    {
        // 创建只能在金土地种植的种子
        $goldOnlySeed = new FarmSeed();
        $goldOnlySeed->item_id = 99;
        $goldOnlySeed->allowed_land_types = [LAND_TYPE::GOLD];

        // 测试等级概念：金土地(4)及以上等级包括蓝土地(5)和紫土地(6)
        $this->assertTrue($goldOnlySeed->canPlantOnLandTypeOrHigher(LAND_TYPE::GOLD->value));
        $this->assertTrue($goldOnlySeed->canPlantOnLandTypeOrHigher(LAND_TYPE::BLUE->value));
        $this->assertTrue($goldOnlySeed->canPlantOnLandTypeOrHigher(LAND_TYPE::PURPLE->value));

        // 但不能在低等级土地种植
        $this->assertFalse($goldOnlySeed->canPlantOnLandTypeOrHigher(LAND_TYPE::NORMAL->value));
        $this->assertFalse($goldOnlySeed->canPlantOnLandTypeOrHigher(LAND_TYPE::RED->value));
        $this->assertFalse($goldOnlySeed->canPlantOnLandTypeOrHigher(LAND_TYPE::BLACK->value));
    }

    /**
     * 测试AllowedLandTypesCast的基本功能
     */
    public function testAllowedLandTypesCastBasicFunctionality()
    {
        $cast = new \App\Module\Farm\Casts\AllowedLandTypesCast();
        
        // 测试null值处理
        $this->assertNull($cast->get(new FarmSeed(), 'allowed_land_types', null, []));
        $this->assertNull($cast->set(new FarmSeed(), 'allowed_land_types', null, []));
        
        // 测试空数组处理
        $this->assertEquals('[]', $cast->set(new FarmSeed(), 'allowed_land_types', [], []));
        
        // 测试枚举数组处理
        $landTypes = [LAND_TYPE::GOLD, LAND_TYPE::BLUE];
        $jsonResult = $cast->set(new FarmSeed(), 'allowed_land_types', $landTypes, []);
        $this->assertEquals('[4,5]', $jsonResult);
    }
}