from typing import List, Optional
from model import Serializable, CardRole, CardType, CardFaction
from model.card_validator import CardEffects, EffectType, EffectTimes


class Effect(Serializable):
    """Represents an effect of a card (gold, damage, heal, draw a card...)"""

    object_type = "effect"
    effect: CardEffects
    amount: int
    sub_effects: List["Effect"]
    mutex: List["Effect"]
    effect_type: Optional[EffectType] = None
    times: Optional[EffectTimes] = None

    def __init__(
        self,
        effect: CardEffects,
        amount: int,
        sub_effects: Optional[List["Effect"]] = None,
        effect_type: Optional[EffectType] = None,
        times: Optional[EffectTimes] = None,
        mutex: Optional[List["Effect"]] = None,
    ):
        super().__init__()
        if mutex is None:
            mutex = []
        if sub_effects is None:
            sub_effects = []
        self.effect = effect
        self.amount = amount
        self.sub_effects = sub_effects
        self.effect_type = effect_type
        self.mutex = mutex
        self.times = times

    def serialize(self) -> dict:
        return super().serialize() | {
            "sub_effects": [effect.uuid for effect in self.sub_effects],
            "mutex": [effect.uuid for effect in self.mutex],
        }


class Card(Serializable):
    """Represents any playable card"""

    id: int
    object_type = "card"
    sprite: str
    name: str
    cost: int | None
    role: CardRole
    card_type: CardType
    faction: CardFaction
    effects: List[Effect]
    defense: Optional[int]
    guard: Optional[bool]

    def __init__(
        self,
        card_id: int,
        sprite: str,
        name: str,
        cost: int | None,
        card_type: CardType,
        card_role: CardRole,
        faction: CardFaction,
        effects: List[Effect],
        defense: Optional[int],
        guard: Optional[bool],
    ):
        super().__init__()
        self.card_id = card_id
        self.sprite = sprite
        self.name = name
        self.cost = cost
        self.card_type = card_type
        self.card_role = card_role
        self.faction = faction
        self.effects = effects
        self.defense = defense
        self.guard = guard

    def serialize(self) -> dict:
        return super().serialize() | {
            "effects": [effect.uuid for effect in self.effects],
        }