"""
卡牌参数系统测试
"""
import pytest
from kards_battle.cards.card_params import (
    ParameterDefinition, ParameterType, TargetType, ZoneType, FilterType,
    CardParameterValidator, CardParameterHelper
)
from kards_battle.cards.card_loader import CardLoader
from kards_battle.core.enums import Nation


class TestParameterDefinition:
    """参数定义测试"""
    
    def test_slot_parameter_creation(self):
        """测试槽位参数定义"""
        param_data = {
            "name": "position",
            "type": "slot",
            "range": [0, 4],
            "required": False,
            "description": "Deploy position"
        }
        
        param_def = ParameterDefinition.from_dict(param_data)
        
        assert param_def.name == "position"
        assert param_def.param_type == ParameterType.SLOT
        assert param_def.slot_range == [0, 4]
        assert not param_def.required
        assert param_def.description == "Deploy position"
    
    def test_target_parameter_creation(self):
        """测试目标参数定义"""
        param_data = {
            "name": "target_hq",
            "type": "target",
            "target_type": "hq",
            "filter": "any",
            "required": True,
            "description": "Select HQ to target"
        }
        
        param_def = ParameterDefinition.from_dict(param_data)
        
        assert param_def.name == "target_hq"
        assert param_def.param_type == ParameterType.TARGET
        assert param_def.target_type == TargetType.HQ
        assert param_def.target_filter == FilterType.ANY
        assert param_def.required
    
    def test_unit_target_parameter_creation(self):
        """测试单位目标参数定义"""
        param_data = {
            "name": "target_unit",
            "type": "target",
            "target_type": "unit",
            "valid_zones": ["O", "F"],
            "filter": "friendly",
            "unit_type_filter": ["fighter", "bomber"],
            "nation_filter": ["uk"],
            "required": True,
            "description": "Select British aircraft"
        }
        
        param_def = ParameterDefinition.from_dict(param_data)
        
        assert param_def.target_type == TargetType.UNIT
        assert param_def.valid_zones == [ZoneType.OWN, ZoneType.FRONT]
        assert param_def.target_filter == FilterType.FRIENDLY
        assert param_def.unit_type_filter == ["fighter", "bomber"]
        assert param_def.nation_filter == ["uk"]
    
    def test_multi_target_parameter_creation(self):
        """测试多目标参数定义"""
        param_data = {
            "name": "targets",
            "type": "multi_target",
            "target_type": "unit",
            "valid_zones": ["E", "F"],
            "filter": "enemy",
            "min_count": 1,
            "max_count": 3,
            "required": True,
            "description": "Select up to 3 enemy units"
        }
        
        param_def = ParameterDefinition.from_dict(param_data)
        
        assert param_def.param_type == ParameterType.MULTI_TARGET
        assert param_def.min_count == 1
        assert param_def.max_count == 3


class TestParameterValidator:
    """参数验证器测试"""
    
    def test_validate_slot_parameter(self):
        """测试槽位参数验证"""
        param_def = ParameterDefinition(
            name="position",
            param_type=ParameterType.SLOT,
            slot_range=[0, 4]
        )
        
        # 有效槽位
        assert CardParameterValidator.validate_slot_parameter(param_def, 0)
        assert CardParameterValidator.validate_slot_parameter(param_def, 2)
        assert CardParameterValidator.validate_slot_parameter(param_def, 4)
        
        # 无效槽位
        assert not CardParameterValidator.validate_slot_parameter(param_def, -1)
        assert not CardParameterValidator.validate_slot_parameter(param_def, 5)
        assert not CardParameterValidator.validate_slot_parameter(param_def, "invalid")
    
    def test_validate_hq_target_parameter(self):
        """测试HQ目标参数验证"""
        param_def = ParameterDefinition(
            name="target_hq",
            param_type=ParameterType.TARGET,
            target_type=TargetType.HQ
        )
        
        # 有效HQ目标
        valid_hq = {"player": 0}
        assert CardParameterValidator.validate_target_parameter(param_def, valid_hq)
        
        valid_hq2 = {"player": 1}
        assert CardParameterValidator.validate_target_parameter(param_def, valid_hq2)
        
        # 无效HQ目标
        invalid_hq1 = {"player": 2}  # 无效玩家ID
        assert not CardParameterValidator.validate_target_parameter(param_def, invalid_hq1)
        
        invalid_hq2 = {}  # 缺少player字段
        assert not CardParameterValidator.validate_target_parameter(param_def, invalid_hq2)
        
        invalid_hq3 = {"player": "invalid"}  # 非整数
        assert not CardParameterValidator.validate_target_parameter(param_def, invalid_hq3)
    
    def test_validate_unit_target_parameter(self):
        """测试单位目标参数验证"""
        param_def = ParameterDefinition(
            name="target_unit",
            param_type=ParameterType.TARGET,
            target_type=TargetType.UNIT,
            valid_zones=[ZoneType.OWN, ZoneType.FRONT]
        )
        
        # 有效单位目标
        valid_unit = {"zone": "O", "slot": 2}
        assert CardParameterValidator.validate_target_parameter(param_def, valid_unit)
        
        valid_unit2 = {"zone": "F", "slot": 0}
        assert CardParameterValidator.validate_target_parameter(param_def, valid_unit2)
        
        # 无效单位目标
        invalid_unit1 = {"zone": "E", "slot": 2}  # 不在valid_zones中
        assert not CardParameterValidator.validate_target_parameter(param_def, invalid_unit1)
        
        invalid_unit2 = {"zone": "O", "slot": 5}  # 槽位超出范围
        assert not CardParameterValidator.validate_target_parameter(param_def, invalid_unit2)
        
        invalid_unit3 = {"zone": "O"}  # 缺少slot
        assert not CardParameterValidator.validate_target_parameter(param_def, invalid_unit3)
    
    def test_validate_multi_target_parameter(self):
        """测试多目标参数验证"""
        param_def = ParameterDefinition(
            name="targets",
            param_type=ParameterType.MULTI_TARGET,
            target_type=TargetType.UNIT,
            valid_zones=[ZoneType.ENEMY],
            min_count=1,
            max_count=3
        )
        
        # 有效多目标
        valid_targets = [
            {"zone": "E", "slot": 0},
            {"zone": "E", "slot": 2}
        ]
        assert CardParameterValidator.validate_multi_target_parameter(param_def, valid_targets)
        
        # 数量不足
        too_few = []
        assert not CardParameterValidator.validate_multi_target_parameter(param_def, too_few)
        
        # 数量过多
        too_many = [
            {"zone": "E", "slot": 0},
            {"zone": "E", "slot": 1},
            {"zone": "E", "slot": 2},
            {"zone": "E", "slot": 3}
        ]
        assert not CardParameterValidator.validate_multi_target_parameter(param_def, too_many)
    
    def test_validate_card_parameters(self):
        """测试卡牌参数集合验证"""
        definitions = [
            ParameterDefinition(
                name="target",
                param_type=ParameterType.TARGET,
                target_type=TargetType.HQ,
                required=True
            ),
            ParameterDefinition(
                name="value",
                param_type=ParameterType.VALUE,
                min_value=1,
                max_value=10,
                required=False
            )
        ]
        
        # 有效参数
        valid_params = {
            "target": {"player": 0},
            "value": 5
        }
        errors = CardParameterValidator.validate_card_parameters(definitions, valid_params)
        assert len(errors) == 0
        
        # 缺少必需参数
        missing_required = {"value": 5}
        errors = CardParameterValidator.validate_card_parameters(definitions, missing_required)
        assert "target" in errors
        
        # 未知参数
        unknown_param = {
            "target": {"player": 0},
            "unknown": "value"
        }
        errors = CardParameterValidator.validate_card_parameters(definitions, unknown_param)
        assert "unknown" in errors


class TestCardParameterHelper:
    """卡牌参数辅助类测试"""
    
    def test_format_parameter_value(self):
        """测试参数值格式化"""
        # 槽位参数
        slot_def = ParameterDefinition(name="pos", param_type=ParameterType.SLOT)
        assert CardParameterHelper.format_parameter_value(slot_def, 2) == "slot 2"
        
        # HQ目标参数
        hq_def = ParameterDefinition(name="hq", param_type=ParameterType.TARGET, target_type=TargetType.HQ)
        assert CardParameterHelper.format_parameter_value(hq_def, {"player": 0}) == "HQ0"
        
        # 单位目标参数
        unit_def = ParameterDefinition(name="unit", param_type=ParameterType.TARGET, target_type=TargetType.UNIT)
        assert CardParameterHelper.format_parameter_value(unit_def, {"zone": "O", "slot": 2}) == "O2"
        
        # 多目标参数
        multi_def = ParameterDefinition(name="units", param_type=ParameterType.MULTI_TARGET, target_type=TargetType.UNIT)
        multi_value = [{"zone": "E", "slot": 1}, {"zone": "E", "slot": 3}]
        assert CardParameterHelper.format_parameter_value(multi_def, multi_value) == "E1, E3"


class TestCardLoaderWithParams:
    """卡牌加载器参数支持测试"""
    
    def test_load_parameterized_card(self):
        """测试加载带参数的卡牌"""
        loader = CardLoader()
        
        # 创建测试卡牌数据
        card_data = {
            "id": "test_parameterized_card",
            "name": "Test Parameterized Card",
            "type": "unit",
            "cost": 3,
            "nation": "germany",
            "rarity": 2,
            "unit_definition_id": "test_unit",
            "params": [
                {
                    "name": "position",
                    "type": "slot",
                    "range": [0, 4],
                    "required": False,
                    "description": "Deploy position"
                }
            ]
        }
        
        card = loader._create_unit_card(card_data)
        
        assert card.has_parameters()
        assert len(card.parameters) == 1
        
        param = card.parameters[0]
        assert param.name == "position"
        assert param.param_type == ParameterType.SLOT
        assert not param.required
    
    def test_card_parameter_validation(self):
        """测试卡牌参数验证"""
        loader = CardLoader()
        
        card_data = {
            "id": "test_card",
            "name": "Test Card",
            "type": "unit",
            "cost": 2,
            "nation": "germany",
            "rarity": 1,
            "unit_definition_id": "test_unit",
            "params": [
                {
                    "name": "target",
                    "type": "target",
                    "target_type": "hq",
                    "filter": "enemy",
                    "required": True,
                    "description": "Select enemy HQ"
                }
            ]
        }
        
        card = loader._create_unit_card(card_data)
        
        # 测试有效参数
        valid_params = {"target": {"player": 1}}
        errors = card.validate_parameters(valid_params)
        assert len(errors) == 0
        
        # 测试无效参数
        invalid_params = {"target": {"player": 2}}
        errors = card.validate_parameters(invalid_params)
        assert len(errors) > 0
        
        # 测试缺少必需参数
        missing_params = {}
        errors = card.validate_parameters(missing_params)
        assert len(errors) > 0