monsters_models.py

"""
Cruel Monsters - Data Models
AQW-themed Pokemon system with full admin customization
"""

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Any, Set
from enum import Enum
from datetime import datetime, timezone
import json

# ==================== ENUMS ====================

class MonsterRarity(str, Enum):
    STARTER = "starter"
    COMMON = "common"
    UNCOMMON = "uncommon"
    RARE = "rare"
    EPIC = "epic"
    LEGENDARY = "legendary"
    MYTHIC = "mythic"

class MonsterStatus(str, Enum):
    TESTING = "testing"
    LIVE = "live"
    DISABLED = "disabled"

class ElementType(str, Enum):
    FIRE = "Fire"
    WATER = "Water"
    ICE = "Ice"
    NATURE = "Nature"
    EARTH = "Earth"
    ELECTRIC = "Electric"
    METAL = "Metal"
    LIGHT = "Light"
    DARK = "Dark"
    CHAOS = "Chaos"
    DRAGON = "Dragon"
    NORMAL = "Normal"

class DamageCategory(str, Enum):
    PHYSICAL = "physical"  # ATK vs DEF
    SPECIAL = "special"    # MATK vs MDEF

class StatusEffectType(str, Enum):
    BURN = "burn"          # DOT
    POISON = "poison"      # DOT (stacking)
    FREEZE = "freeze"      # Skip turn (thaws after)
    PARALYZE = "paralyze"  # 50% skip turn
    SLEEP = "sleep"        # Skip turns until wake
    CONFUSION = "confusion" # May hit self
    SHIELD = "shield"      # Absorb damage
    BUFF = "buff"          # Stat increase
    DEBUFF = "debuff"      # Stat decrease

class EffectType(str, Enum):
    DAMAGE = "damage"
    HEAL = "heal"
    SHIELD = "shield"
    DOT = "dot"
    BUFF = "buff"
    DEBUFF = "debuff"
    STATUS = "status"      # Apply status effect
    CLEANSE = "cleanse"    # Remove status
    DRAIN = "drain"        # Damage + heal
    RECOIL = "recoil"      # Self damage
    MARK = "mark"          # Apply mark/tag for combos
    SPREAD = "spread"      # Spread effect to other targets
    CHAIN = "chain"        # Multi-hit
    EXECUTE = "execute"    # Bonus damage based on HP threshold


class AbilityRole(str, Enum):
    """What job does this ability do?"""
    NUKE = "nuke"           # High single-target damage
    AOE = "aoe"             # Multi-target damage
    SETUP = "setup"         # Applies status/marks for combos
    FINISHER = "finisher"   # Execute bonus
    SUSTAIN = "sustain"     # Healing/shielding
    CONTROL = "control"     # CC effects
    UTILITY = "utility"     # Buffs, cleanses, etc.
    COMBO = "combo"         # Stack consumer
    MODE = "mode"           # Stance switcher


class TriggerType(str, Enum):
    """When does the payoff activate?"""
    NONE = "none"
    STATUS_ON_TARGET = "status_on_target"
    STATUS_ON_SELF = "status_on_self"
    TARGET_HP_BELOW = "target_hp_below"
    TARGET_HP_ABOVE = "target_hp_above"
    SELF_HP_BELOW = "self_hp_below"
    SELF_HP_ABOVE = "self_hp_above"
    STACK_COUNT = "stack_count"
    ON_CRIT = "on_crit"
    ON_KILL = "on_kill"
    RANDOM_CHANCE = "random_chance"
    TURN_NUMBER = "turn_number"


class CostType(str, Enum):
    """What's the tradeoff?"""
    NONE = "none"
    RECOIL_PERCENT = "recoil_percent"
    RECOIL_FLAT = "recoil_flat"
    SELF_DEBUFF = "self_debuff"
    CONSUME_BUFF = "consume_buff"
    ACCURACY_PENALTY = "accuracy_penalty"
    HP_THRESHOLD = "hp_threshold"

class StatTemplate(str, Enum):
    """Predefined stat distributions for quick monster creation"""
    BALANCED = "balanced"       # Even stats
    TANK = "tank"              # High HP/DEF
    GLASS_CANNON = "glass_cannon"  # High ATK, low DEF
    SPEEDY = "speedy"          # High SPD
    MAGE = "mage"              # High MATK/MDEF
    BRUISER = "bruiser"        # High HP/ATK
    WALL = "wall"              # Very high DEF/MDEF

# ==================== STAT TEMPLATES ====================

STAT_TEMPLATES = {
    StatTemplate.BALANCED: {"hp": 50, "atk": 50, "def": 50, "matk": 50, "mdef": 50, "spd": 50},
    StatTemplate.TANK: {"hp": 75, "atk": 40, "def": 70, "matk": 35, "mdef": 60, "spd": 30},
    StatTemplate.GLASS_CANNON: {"hp": 35, "atk": 80, "def": 30, "matk": 75, "mdef": 35, "spd": 65},
    StatTemplate.SPEEDY: {"hp": 45, "atk": 55, "def": 40, "matk": 50, "mdef": 45, "spd": 85},
    StatTemplate.MAGE: {"hp": 45, "atk": 30, "def": 40, "matk": 80, "mdef": 70, "spd": 55},
    StatTemplate.BRUISER: {"hp": 70, "atk": 70, "def": 50, "matk": 40, "mdef": 45, "spd": 45},
    StatTemplate.WALL: {"hp": 60, "atk": 35, "def": 80, "matk": 35, "mdef": 75, "spd": 25},
}

# Rarity stat multipliers (higher rarity = stronger)
RARITY_MULTIPLIERS = {
    MonsterRarity.STARTER: 1.0,
    MonsterRarity.COMMON: 0.85,
    MonsterRarity.UNCOMMON: 1.0,
    MonsterRarity.RARE: 1.15,
    MonsterRarity.EPIC: 1.3,
    MonsterRarity.LEGENDARY: 1.45,
    MonsterRarity.MYTHIC: 1.6,
}

# Rarity spawn weights (lower = rarer)
RARITY_SPAWN_WEIGHTS = {
    MonsterRarity.COMMON: 50,
    MonsterRarity.UNCOMMON: 30,
    MonsterRarity.RARE: 12,
    MonsterRarity.EPIC: 5,
    MonsterRarity.LEGENDARY: 2.5,
    MonsterRarity.MYTHIC: 0.5,
}

# ==================== EFFECT MODELS ====================

@dataclass
class Effect:
    """Single effect that an ability can apply"""
    type: EffectType
    
    # For damage/heal/drain/recoil
    min_value: Optional[int] = None
    max_value: Optional[int] = None
    category: Optional[DamageCategory] = None  # physical or special
    
    # For DOT/shield
    value: Optional[int] = None
    duration: Optional[int] = None
    
    # For buff/debuff
    stat: Optional[str] = None  # hp, atk, def, matk, mdef, spd
    
    # For status
    status_type: Optional[StatusEffectType] = None
    status_chance: Optional[int] = 100  # Percentage chance
    
    # For cleanse
    cleanse_target: Optional[str] = None  # "self" or "all_negative" or specific status
    
    # For drain
    drain_percent: Optional[int] = None  # % of damage to heal
    
    # NEW: Scaling
    scaling_stat: Optional[str] = None  # "atk", "matk", "spd", "missing_hp", "max_hp"
    scaling_percent: Optional[int] = None  # % of stat to add as bonus
    
    # NEW: Marks/Tags
    mark_id: Optional[str] = None  # Custom mark identifier
    mark_stacks: Optional[int] = 1  # Stacks to add/require
    consume_marks: Optional[bool] = False  # Consume marks when triggered
    
    # NEW: Multi-target
    spread_count: Optional[int] = None  # Spread to N other targets
    chain_count: Optional[int] = None  # Hit N times
    
    # NEW: Execute
    execute_threshold: Optional[int] = None  # HP % threshold
    execute_multiplier: Optional[float] = None  # Damage multiplier
    
    # NEW: Targeting
    target: Optional[str] = "enemy"  # "enemy", "self", "ally", "all_enemies", "random"
    
    # NEW: Bonus modifier (for payoffs)
    bonus_percent: Optional[int] = None  # +X% to effect
    
    def to_dict(self) -> Dict:
        result = {"type": self.type.value}
        for attr in ["min_value", "max_value", "value", "duration", "stat", 
                     "status_chance", "cleanse_target", "drain_percent",
                     "scaling_stat", "scaling_percent", "mark_id", "mark_stacks",
                     "consume_marks", "spread_count", "chain_count",
                     "execute_threshold", "execute_multiplier", "target", "bonus_percent"]:
            val = getattr(self, attr)
            if val is not None:
                result[attr] = val
        if self.category:
            result["category"] = self.category.value
        if self.status_type:
            result["status_type"] = self.status_type.value
        return result
    
    @staticmethod
    def from_dict(data: Dict) -> 'Effect':
        return Effect(
            type=EffectType(data["type"]),
            min_value=data.get("min_value"),
            max_value=data.get("max_value"),
            category=DamageCategory(data["category"]) if data.get("category") else None,
            value=data.get("value"),
            duration=data.get("duration"),
            stat=data.get("stat"),
            status_type=StatusEffectType(data["status_type"]) if data.get("status_type") else None,
            status_chance=data.get("status_chance", 100),
            cleanse_target=data.get("cleanse_target"),
            drain_percent=data.get("drain_percent"),
            scaling_stat=data.get("scaling_stat"),
            scaling_percent=data.get("scaling_percent"),
            mark_id=data.get("mark_id"),
            mark_stacks=data.get("mark_stacks", 1),
            consume_marks=data.get("consume_marks", False),
            spread_count=data.get("spread_count"),
            chain_count=data.get("chain_count"),
            execute_threshold=data.get("execute_threshold"),
            execute_multiplier=data.get("execute_multiplier"),
            target=data.get("target", "enemy"),
            bonus_percent=data.get("bonus_percent"),
        )

# ==================== CONDITIONS (for combos) ====================

@dataclass
class Condition:
    """Condition for triggering conditional effects (combos)"""
    # Only one should be set per condition
    last_ability_id: Optional[str] = None      # If last ability used was X
    self_hp_below: Optional[int] = None        # If own HP below X%
    self_hp_above: Optional[int] = None        # If own HP above X%
    target_hp_below: Optional[int] = None      # If target HP below X%
    target_has_status: Optional[str] = None    # If target has status X
    self_has_status: Optional[str] = None      # If self has status X
    turn_number_gte: Optional[int] = None      # If turn >= X
    
    def to_dict(self) -> Dict:
        result = {}
        for attr in ["last_ability_id", "self_hp_below", "self_hp_above", 
                     "target_hp_below", "target_has_status", "self_has_status",
                     "turn_number_gte"]:
            val = getattr(self, attr)
            if val is not None:
                result[attr] = val
        return result
    
    @staticmethod
    def from_dict(data: Dict) -> 'Condition':
        return Condition(**data)

@dataclass
class ConditionalEffect:
    """Effect that only applies when condition is met"""
    condition: Condition
    effects: List[Effect]
    description: Optional[str] = None  # Display text like "Combo!"
    
    def to_dict(self) -> Dict:
        return {
            "condition": self.condition.to_dict(),
            "effects": [e.to_dict() for e in self.effects],
            "description": self.description
        }
    
    @staticmethod
    def from_dict(data: Dict) -> 'ConditionalEffect':
        return ConditionalEffect(
            condition=Condition.from_dict(data["condition"]),
            effects=[Effect.from_dict(e) for e in data["effects"]],
            description=data.get("description")
        )


# ==================== NEW TRIGGER SYSTEM ====================

@dataclass
class Trigger:
    """Advanced trigger for ability payoffs"""
    type: TriggerType = TriggerType.NONE
    
    # Status-based triggers
    required_status: Optional[str] = None  # Status type name
    status_on: Optional[str] = "target"  # "target" or "self"
    
    # HP-based triggers
    hp_threshold: Optional[int] = None  # % HP
    hp_comparison: Optional[str] = "below"  # "below" or "above"
    hp_target: Optional[str] = "target"  # "target" or "self"
    
    # Stack-based triggers
    mark_id: Optional[str] = None
    required_stacks: Optional[int] = None
    consume_stacks: Optional[bool] = False
    
    # Other triggers
    crit_trigger: Optional[bool] = False
    kill_trigger: Optional[bool] = False
    random_chance: Optional[int] = None  # % chance
    turn_number: Optional[int] = None
    
    def to_dict(self) -> Dict:
        result = {"type": self.type.value}
        for attr in ["required_status", "status_on", "hp_threshold", "hp_comparison",
                     "hp_target", "mark_id", "required_stacks", "consume_stacks",
                     "crit_trigger", "kill_trigger", "random_chance", "turn_number"]:
            val = getattr(self, attr)
            if val is not None:
                result[attr] = val
        return result
    
    @staticmethod
    def from_dict(data: Dict) -> 'Trigger':
        return Trigger(
            type=TriggerType(data.get("type", "none")),
            required_status=data.get("required_status"),
            status_on=data.get("status_on", "target"),
            hp_threshold=data.get("hp_threshold"),
            hp_comparison=data.get("hp_comparison", "below"),
            hp_target=data.get("hp_target", "target"),
            mark_id=data.get("mark_id"),
            required_stacks=data.get("required_stacks"),
            consume_stacks=data.get("consume_stacks", False),
            crit_trigger=data.get("crit_trigger", False),
            kill_trigger=data.get("kill_trigger", False),
            random_chance=data.get("random_chance"),
            turn_number=data.get("turn_number"),
        )
    
    def get_description(self) -> str:
        """Get human-readable trigger description"""
        if self.type == TriggerType.NONE:
            return "Always"
        elif self.type == TriggerType.STATUS_ON_TARGET:
            return f"If target has {self.required_status}"
        elif self.type == TriggerType.STATUS_ON_SELF:
            return f"If you have {self.required_status}"
        elif self.type == TriggerType.TARGET_HP_BELOW:
            return f"If target below {self.hp_threshold}% HP"
        elif self.type == TriggerType.TARGET_HP_ABOVE:
            return f"If target above {self.hp_threshold}% HP"
        elif self.type == TriggerType.SELF_HP_BELOW:
            return f"If you below {self.hp_threshold}% HP"
        elif self.type == TriggerType.SELF_HP_ABOVE:
            return f"If you above {self.hp_threshold}% HP"
        elif self.type == TriggerType.STACK_COUNT:
            return f"At {self.required_stacks}+ {self.mark_id} stacks"
        elif self.type == TriggerType.ON_CRIT:
            return "On critical hit"
        elif self.type == TriggerType.ON_KILL:
            return "On kill"
        elif self.type == TriggerType.RANDOM_CHANCE:
            return f"{self.random_chance}% chance"
        return "Unknown trigger"


@dataclass
class Cost:
    """Cost/tradeoff for using an ability"""
    type: CostType = CostType.NONE
    
    # Recoil
    recoil_percent: Optional[int] = None  # % of damage dealt
    recoil_flat: Optional[int] = None  # Flat HP loss
    
    # Self-debuff
    debuff_stat: Optional[str] = None
    debuff_value: Optional[int] = None
    debuff_duration: Optional[int] = None
    
    # Accuracy
    accuracy_penalty: Optional[int] = None  # % miss chance
    
    # HP threshold to use
    hp_required_below: Optional[int] = None  # Must be below X% HP to use
    
    def to_dict(self) -> Dict:
        result = {"type": self.type.value}
        for attr in ["recoil_percent", "recoil_flat", "debuff_stat", "debuff_value",
                     "debuff_duration", "accuracy_penalty", "hp_required_below"]:
            val = getattr(self, attr)
            if val is not None:
                result[attr] = val
        return result
    
    @staticmethod
    def from_dict(data: Dict) -> 'Cost':
        return Cost(
            type=CostType(data.get("type", "none")),
            recoil_percent=data.get("recoil_percent"),
            recoil_flat=data.get("recoil_flat"),
            debuff_stat=data.get("debuff_stat"),
            debuff_value=data.get("debuff_value"),
            debuff_duration=data.get("debuff_duration"),
            accuracy_penalty=data.get("accuracy_penalty"),
            hp_required_below=data.get("hp_required_below"),
        )
    
    def get_description(self) -> str:
        """Get human-readable cost description"""
        if self.type == CostType.NONE:
            return "None"
        elif self.type == CostType.RECOIL_PERCENT:
            return f"{self.recoil_percent}% recoil"
        elif self.type == CostType.RECOIL_FLAT:
            return f"-{self.recoil_flat} HP recoil"
        elif self.type == CostType.SELF_DEBUFF:
            return f"-{self.debuff_value} {self.debuff_stat.upper()} ({self.debuff_duration}t)"
        elif self.type == CostType.ACCURACY_PENALTY:
            return f"{self.accuracy_penalty}% miss chance"
        elif self.type == CostType.HP_THRESHOLD:
            return f"Requires <{self.hp_required_below}% HP"
        return "Unknown cost"

# ==================== ABILITY DEFINITION ====================

@dataclass
class AbilityDefinition:
    """Reusable ability in the library - Enhanced with DNA system"""
    id: str
    name: str
    description: str
    element_type: ElementType
    category: DamageCategory
    cooldown: int  # 0-5 turns
    base_effects: List[Effect]
    conditional_effects: List[ConditionalEffect] = field(default_factory=list)
    
    # NEW: Ability DNA system
    role: AbilityRole = AbilityRole.NUKE
    triggers: List[Trigger] = field(default_factory=list)
    payoffs: List[Effect] = field(default_factory=list)
    costs: List[Cost] = field(default_factory=list)
    
    # NEW: Metadata
    power_budget: int = 0  # Calculated power level
    tags: List[str] = field(default_factory=list)  # For filtering
    created_by: Optional[int] = None
    created_at: Optional[str] = None
    
    def to_dict(self) -> Dict:
        return {
            "id": self.id,
            "name": self.name,
            "description": self.description,
            "element_type": self.element_type.value,
            "category": self.category.value,
            "cooldown": self.cooldown,
            "base_effects": [e.to_dict() for e in self.base_effects],
            "conditional_effects": [c.to_dict() for c in self.conditional_effects],
            "role": self.role.value,
            "triggers": [t.to_dict() for t in self.triggers],
            "payoffs": [p.to_dict() for p in self.payoffs],
            "costs": [c.to_dict() for c in self.costs],
            "power_budget": self.power_budget,
            "tags": self.tags,
            "created_by": self.created_by,
            "created_at": self.created_at,
        }
    
    @staticmethod
    def from_dict(data: Dict) -> 'AbilityDefinition':
        return AbilityDefinition(
            id=data["id"],
            name=data["name"],
            description=data["description"],
            element_type=ElementType(data["element_type"]),
            category=DamageCategory(data["category"]),
            cooldown=data["cooldown"],
            base_effects=[Effect.from_dict(e) for e in data["base_effects"]],
            conditional_effects=[ConditionalEffect.from_dict(c) for c in data.get("conditional_effects", [])],
            role=AbilityRole(data.get("role", "nuke")),
            triggers=[Trigger.from_dict(t) for t in data.get("triggers", [])],
            payoffs=[Effect.from_dict(p) for p in data.get("payoffs", [])],
            costs=[Cost.from_dict(c) for c in data.get("costs", [])],
            power_budget=data.get("power_budget", 0),
            tags=data.get("tags", []),
            created_by=data.get("created_by"),
            created_at=data.get("created_at"),
        )
    
    def get_description_short(self) -> str:
        """Generate short description for battle UI"""
        parts = []
        for eff in self.base_effects:
            if eff.type == EffectType.DAMAGE:
                parts.append(f"{eff.min_value}-{eff.max_value} dmg")
            elif eff.type == EffectType.HEAL:
                parts.append(f"Heal {eff.value}")
            elif eff.type == EffectType.SHIELD:
                parts.append(f"+{eff.value} 🛡️")
            elif eff.type == EffectType.STATUS and eff.status_type:
                status_emoji = {
                    StatusEffectType.BURN: "🔥",
                    StatusEffectType.POISON: "☠️",
                    StatusEffectType.FREEZE: "❄️",
                    StatusEffectType.PARALYZE: "⚡",
                    StatusEffectType.SLEEP: "💤",
                    StatusEffectType.CONFUSION: "😵",
                }.get(eff.status_type, "")
                parts.append(f"+{status_emoji}")
            elif eff.type == EffectType.BUFF:
                parts.append(f"+{eff.stat.upper()}")
            elif eff.type == EffectType.DEBUFF:
                parts.append(f"-{eff.stat.upper()}")
        return " | ".join(parts) if parts else self.description[:30]
    
    def get_natural_language(self) -> str:
        """Generate natural language description of ability"""
        lines = []
        
        # Core effects
        for eff in self.base_effects:
            lines.append(self._effect_to_text(eff))
        
        # Triggers and payoffs
        if self.triggers and self.payoffs:
            trigger_text = self.triggers[0].get_description()
            payoff_texts = [self._effect_to_text(p) for p in self.payoffs]
            lines.append(f"{trigger_text}: {', '.join(payoff_texts)}")
        
        # Costs
        for cost in self.costs:
            if cost.type != CostType.NONE:
                lines.append(f"Cost: {cost.get_description()}")
        
        return " ".join(lines)
    
    def _effect_to_text(self, eff: Effect) -> str:
        """Convert single effect to text"""
        if eff.type == EffectType.DAMAGE:
            base = f"Deal {eff.min_value}-{eff.max_value} damage"
            if eff.bonus_percent:
                base = f"+{eff.bonus_percent}% damage"
            return base
        elif eff.type == EffectType.HEAL:
            return f"Heal {eff.value} HP"
        elif eff.type == EffectType.SHIELD:
            return f"Gain {eff.value} shield"
        elif eff.type == EffectType.STATUS:
            return f"Apply {eff.status_type.value.title()} ({eff.status_chance}%)"
        elif eff.type == EffectType.BUFF:
            return f"+{eff.value} {eff.stat.upper()} ({eff.duration}t)"
        elif eff.type == EffectType.DEBUFF:
            return f"-{eff.value} {eff.stat.upper()} ({eff.duration}t)"
        elif eff.type == EffectType.DRAIN:
            return f"Drain {eff.drain_percent}% of damage"
        elif eff.type == EffectType.MARK:
            return f"Apply {eff.mark_stacks}x {eff.mark_id}"
        elif eff.type == EffectType.SPREAD:
            return f"Spread to {eff.spread_count} enemies"
        return str(eff.type.value)
    
    def get_summary_chips(self) -> str:
        """Get compact chip summary for builder"""
        chips = []
        
        # Core
        for eff in self.base_effects:
            chips.append(self._effect_to_chip(eff))
        
        # Trigger
        if self.triggers:
            t = self.triggers[0]
            chips.append(f"⚡ {t.get_description()[:20]}")
        
        # Payoffs
        for eff in self.payoffs:
            chips.append(f"🎯 {self._effect_to_chip(eff)}")
        
        # Costs
        for cost in self.costs:
            if cost.type != CostType.NONE:
                chips.append(f"💀 {cost.get_description()[:15]}")
        
        return " | ".join(chips[:5])  # Limit for Discord
    
    def _effect_to_chip(self, eff: Effect) -> str:
        """Convert effect to short chip"""
        if eff.type == EffectType.DAMAGE:
            if eff.bonus_percent:
                return f"+{eff.bonus_percent}%"
            return f"{eff.min_value}dmg"
        elif eff.type == EffectType.HEAL:
            return f"+{eff.value}hp"
        elif eff.type == EffectType.STATUS:
            emoji = {"burn": "🔥", "poison": "☠️", "freeze": "❄️", "paralyze": "⚡"}.get(eff.status_type.value, "💫")
            return emoji
        elif eff.type == EffectType.BUFF:
            return f"+{eff.stat[:3].upper()}"
        elif eff.type == EffectType.DEBUFF:
            return f"-{eff.stat[:3].upper()}"
        elif eff.type == EffectType.MARK:
            return f"🏷️{eff.mark_stacks}"
        elif eff.type == EffectType.SPREAD:
            return f"×{eff.spread_count}"
        return eff.type.value[:4]
    
    def calculate_power_budget(self) -> int:
        """Calculate power budget for validation"""
        budget = 0
        
        # Core effects
        for eff in self.base_effects:
            budget += self._effect_power(eff)
        
        # Payoffs (discounted since conditional)
        for eff in self.payoffs:
            budget += int(self._effect_power(eff) * 0.6)
        
        # Costs reduce budget
        for cost in self.costs:
            budget -= self._cost_reduction(cost)
        
        # Cooldown reduces budget
        budget -= self.cooldown * 8
        
        return max(0, budget)
    
    def _effect_power(self, eff: Effect) -> int:
        """Calculate power cost of single effect"""
        if eff.type == EffectType.DAMAGE:
            avg = ((eff.min_value or 0) + (eff.max_value or 0)) // 2
            return avg // 5
        elif eff.type == EffectType.HEAL:
            return (eff.value or 0) // 4
        elif eff.type == EffectType.SHIELD:
            return (eff.value or 0) // 4
        elif eff.type == EffectType.STATUS:
            base = 15
            if eff.status_type in [StatusEffectType.FREEZE, StatusEffectType.SLEEP]:
                base = 25  # CC is stronger
            return int(base * (eff.status_chance or 100) / 100)
        elif eff.type == EffectType.BUFF:
            return (eff.value or 0) * (eff.duration or 1)
        elif eff.type == EffectType.DEBUFF:
            return (eff.value or 0) * (eff.duration or 1)
        elif eff.type == EffectType.DRAIN:
            return 20
        elif eff.type == EffectType.SPREAD:
            return 15 * (eff.spread_count or 1)
        return 5
    
    def _cost_reduction(self, cost: Cost) -> int:
        """Calculate budget reduction from cost"""
        if cost.type == CostType.RECOIL_PERCENT:
            return (cost.recoil_percent or 0) // 2
        elif cost.type == CostType.RECOIL_FLAT:
            return (cost.recoil_flat or 0) // 3
        elif cost.type == CostType.SELF_DEBUFF:
            return (cost.debuff_value or 0) * (cost.debuff_duration or 1)
        elif cost.type == CostType.ACCURACY_PENALTY:
            return (cost.accuracy_penalty or 0) // 2
        elif cost.type == CostType.HP_THRESHOLD:
            return 15  # Risk of not being able to use
        return 0
    
    def validate(self) -> List[str]:
        """Validate ability and return warnings"""
        warnings = []
        
        # Check power budget
        self.power_budget = self.calculate_power_budget()
        if self.power_budget > 100:
            warnings.append(f"⚠️ High power ({self.power_budget}/100) - consider higher CD or add cost")
        
        # Check payoffs without triggers
        if self.payoffs and not self.triggers:
            warnings.append("❌ Payoffs without triggers - bonus will never activate")
        
        # Check triggers without payoffs
        if self.triggers and not self.payoffs:
            warnings.append("⚠️ Trigger without payoffs - consider adding bonus effects")
        
        # Check execute on low CD
        has_execute = any(e.execute_threshold for e in self.base_effects + self.payoffs)
        if has_execute and self.cooldown < 3:
            warnings.append("⚠️ Execute on low CD may feel unfair - suggest CD 3+")
        
        # Recommend CD
        recommended_cd = self._recommended_cd()
        if self.cooldown < recommended_cd - 1:
            warnings.append(f"💡 Recommended CD: {recommended_cd} (current: {self.cooldown})")
        
        return warnings
    
    def _recommended_cd(self) -> int:
        """Calculate recommended cooldown"""
        budget = self.power_budget
        if budget <= 30:
            return 0
        elif budget <= 50:
            return 1
        elif budget <= 70:
            return 2
        elif budget <= 90:
            return 3
        elif budget <= 110:
            return 4
        return 5
    
    def infer_role(self) -> AbilityRole:
        """Infer the role from ability effects if not explicitly set"""
        # Check for specific patterns in base_effects
        has_damage = any(e.type == EffectType.DAMAGE for e in self.base_effects)
        has_heal = any(e.type == EffectType.HEAL for e in self.base_effects)
        has_shield = any(e.type == EffectType.SHIELD for e in self.base_effects)
        has_drain = any(e.type == EffectType.DRAIN for e in self.base_effects)
        has_status = any(e.type == EffectType.STATUS for e in self.base_effects)
        has_buff = any(e.type == EffectType.BUFF for e in self.base_effects)
        has_debuff = any(e.type == EffectType.DEBUFF for e in self.base_effects)
        has_mark = any(e.type == EffectType.MARK for e in self.base_effects)
        
        # Check for CC statuses
        cc_statuses = [StatusEffectType.FREEZE, StatusEffectType.SLEEP, StatusEffectType.PARALYZE]
        has_cc = any(
            e.type == EffectType.STATUS and e.status_type in cc_statuses 
            for e in self.base_effects
        )
        
        # Has execute trigger?
        has_execute = any(t.type == TriggerType.TARGET_HP_BELOW for t in self.triggers) or \
                      any(e.execute_threshold for e in self.base_effects + self.payoffs)
        
        # Determine role based on patterns
        if has_execute:
            return AbilityRole.FINISHER
        elif has_heal or has_shield or has_drain:
            return AbilityRole.SUSTAIN
        elif has_cc:
            return AbilityRole.CONTROL
        elif has_mark or (has_status and not has_cc):
            return AbilityRole.SETUP
        elif has_buff:
            return AbilityRole.UTILITY
        elif has_debuff and not has_damage:
            return AbilityRole.CONTROL
        elif self.triggers and self.payoffs:
            return AbilityRole.COMBO
        elif has_damage:
            # High damage = NUKE, low damage might be setup
            total_dmg = sum(
                ((e.min_value or 0) + (e.max_value or 0)) // 2 
                for e in self.base_effects if e.type == EffectType.DAMAGE
            )
            if total_dmg >= 25:
                return AbilityRole.NUKE
            else:
                return AbilityRole.SETUP
        
        return AbilityRole.UTILITY
    
    def get_display_role(self) -> AbilityRole:
        """Get role for display - uses explicit role if set meaningfully, otherwise infers"""
        # If role was explicitly set to something other than default NUKE, use it
        if self.role != AbilityRole.NUKE:
            return self.role
        # Otherwise infer from effects
        return self.infer_role()


# ==================== ABILITY TEMPLATES ====================

ABILITY_TEMPLATES = {
    "basic_attack": {
        "name": "Basic Attack",
        "role": AbilityRole.NUKE,
        "description": "Simple damage ability",
        "cooldown": 0,
        "base_effects": [{"type": "damage", "min_value": 50, "max_value": 60, "category": "physical"}],
    },
    "burn_starter": {
        "name": "Burn Starter",
        "role": AbilityRole.SETUP,
        "description": "Deal damage and apply Burn for combos",
        "cooldown": 0,
        "base_effects": [
            {"type": "damage", "min_value": 40, "max_value": 50, "category": "physical"},
            {"type": "status", "status_type": "burn", "value": 10, "duration": 3}
        ],
    },
    "execute": {
        "name": "Execute",
        "role": AbilityRole.FINISHER,
        "description": "Bonus damage to low HP targets",
        "cooldown": 3,
        "base_effects": [{"type": "damage", "min_value": 70, "max_value": 80, "category": "physical"}],
        "triggers": [{"type": "target_hp_below", "hp_threshold": 30}],
        "payoffs": [{"type": "damage", "bonus_percent": 100}],
    },
    "heal": {
        "name": "Healing",
        "role": AbilityRole.SUSTAIN,
        "description": "Restore HP",
        "cooldown": 2,
        "base_effects": [{"type": "heal", "value": 60, "target": "self"}],
    },
    "drain": {
        "name": "Life Drain",
        "role": AbilityRole.SUSTAIN,
        "description": "Deal damage and heal",
        "cooldown": 2,
        "base_effects": [
            {"type": "damage", "min_value": 50, "max_value": 60, "category": "special"},
            {"type": "drain", "drain_percent": 50}
        ],
    },
    "stack_builder": {
        "name": "Stack Builder",
        "role": AbilityRole.SETUP,
        "description": "Apply stacks for combo payoff",
        "cooldown": 0,
        "base_effects": [
            {"type": "damage", "min_value": 30, "max_value": 40, "category": "physical"},
            {"type": "mark", "mark_id": "venom", "mark_stacks": 1}
        ],
    },
    "stack_consumer": {
        "name": "Stack Consumer",
        "role": AbilityRole.COMBO,
        "description": "Consume stacks for burst",
        "cooldown": 3,
        "base_effects": [{"type": "damage", "min_value": 20, "max_value": 30, "category": "physical"}],
        "triggers": [{"type": "stack_count", "mark_id": "venom", "required_stacks": 3, "consume_stacks": True}],
        "payoffs": [{"type": "damage", "bonus_percent": 200}],
    },
    "risky_nuke": {
        "name": "Risky Nuke",
        "role": AbilityRole.NUKE,
        "description": "High damage with recoil",
        "cooldown": 1,
        "base_effects": [{"type": "damage", "min_value": 100, "max_value": 120, "category": "physical"}],
        "costs": [{"type": "recoil_percent", "recoil_percent": 25}],
    },
    "control": {
        "name": "Control",
        "role": AbilityRole.CONTROL,
        "description": "Apply crowd control",
        "cooldown": 3,
        "base_effects": [
            {"type": "damage", "min_value": 30, "max_value": 40, "category": "special"},
            {"type": "status", "status_type": "freeze", "status_chance": 80}
        ],
    },
}

# ==================== PASSIVE DEFINITION ====================

@dataclass
class PassiveDefinition:
    """Passive ability (always active)"""
    id: str
    name: str
    description: str
    effect_type: str  # Custom identifiers for engine to handle
    value: Optional[int] = None
    stat: Optional[str] = None
    
    def to_dict(self) -> Dict:
        result = {
            "id": self.id,
            "name": self.name,
            "description": self.description,
            "effect_type": self.effect_type
        }
        if self.value is not None:
            result["value"] = self.value
        if self.stat is not None:
            result["stat"] = self.stat
        return result
    
    @staticmethod
    def from_dict(data: Dict) -> 'PassiveDefinition':
        return PassiveDefinition(
            id=data["id"],
            name=data["name"],
            description=data["description"],
            effect_type=data["effect_type"],
            value=data.get("value"),
            stat=data.get("stat")
        )

# ==================== MONSTER DEFINITION ====================

@dataclass
class MonsterDefinition:
    """Monster species template (admin-created)"""
    id: str
    name: str
    description: str
    type1: ElementType
    type2: Optional[ElementType]
    rarity: MonsterRarity
    status: MonsterStatus
    
    # Base stats
    base_hp: int
    base_atk: int
    base_def: int
    base_matk: int
    base_mdef: int
    base_spd: int
    
    # Abilities (4 ability IDs from library)
    ability_ids: List[str]
    
    # Passive (1 passive ID from library)
    passive_id: Optional[str] = None
    
    # Evolution
    evolves_from: Optional[str] = None
    evolves_to: Optional[str] = None
    evolve_level: Optional[int] = None
    
    # Catch rate modifier (1.0 = normal)
    catch_rate: float = 1.0
    
    def to_dict(self) -> Dict:
        return {
            "id": self.id,
            "name": self.name,
            "description": self.description,
            "type1": self.type1.value,
            "type2": self.type2.value if self.type2 else None,
            "rarity": self.rarity.value,
            "status": self.status.value,
            "base_hp": self.base_hp,
            "base_atk": self.base_atk,
            "base_def": self.base_def,
            "base_matk": self.base_matk,
            "base_mdef": self.base_mdef,
            "base_spd": self.base_spd,
            "ability_ids": self.ability_ids,
            "passive_id": self.passive_id,
            "evolves_from": self.evolves_from,
            "evolves_to": self.evolves_to,
            "evolve_level": self.evolve_level,
            "catch_rate": self.catch_rate
        }
    
    @staticmethod
    def from_dict(data: Dict) -> 'MonsterDefinition':
        return MonsterDefinition(
            id=data["id"],
            name=data["name"],
            description=data["description"],
            type1=ElementType(data["type1"]),
            type2=ElementType(data["type2"]) if data.get("type2") else None,
            rarity=MonsterRarity(data["rarity"]),
            status=MonsterStatus(data["status"]),
            base_hp=data["base_hp"],
            base_atk=data["base_atk"],
            base_def=data["base_def"],
            base_matk=data["base_matk"],
            base_mdef=data["base_mdef"],
            base_spd=data["base_spd"],
            ability_ids=data["ability_ids"],
            passive_id=data.get("passive_id"),
            evolves_from=data.get("evolves_from"),
            evolves_to=data.get("evolves_to"),
            evolve_level=data.get("evolve_level"),
            catch_rate=data.get("catch_rate", 1.0)
        )
    
    def get_type_string(self) -> str:
        if self.type2:
            return f"{self.type1.value}/{self.type2.value}"
        return self.type1.value

# ==================== MONSTER INSTANCE (Caught) ====================

@dataclass
class MonsterInstance:
    """Individual caught monster with unique stats"""
    instance_id: int  # DB primary key
    definition_id: str  # Monster species
    owner_id: int  # Current owner
    original_owner_id: int  # First owner (for trading)
    
    # Level & XP
    level: int = 1
    xp: int = 0
    
    # IVs (Individual Values 0-31, hidden bonus stats)
    iv_hp: int = 0
    iv_atk: int = 0
    iv_def: int = 0
    iv_matk: int = 0
    iv_mdef: int = 0
    iv_spd: int = 0
    
    # Current HP (for healing system)
    current_hp: int = 0
    max_hp: int = 0  # Calculated
    
    # Special flags
    is_shiny: bool = False
    is_in_party: bool = False
    party_slot: int = 0  # 1-6, 0 = not in party
    
    # Trading
    trade_locked: bool = False
    trade_count: int = 0
    
    # Timestamps
    caught_at: str = ""
    
    # Ability cooldowns (runtime, not persisted)
    cooldowns: List[int] = field(default_factory=lambda: [0, 0, 0, 0])
    
    def to_dict(self) -> Dict:
        return {
            "instance_id": self.instance_id,
            "definition_id": self.definition_id,
            "owner_id": self.owner_id,
            "original_owner_id": self.original_owner_id,
            "level": self.level,
            "xp": self.xp,
            "iv_hp": self.iv_hp,
            "iv_atk": self.iv_atk,
            "iv_def": self.iv_def,
            "iv_matk": self.iv_matk,
            "iv_mdef": self.iv_mdef,
            "iv_spd": self.iv_spd,
            "current_hp": self.current_hp,
            "is_shiny": self.is_shiny,
            "is_in_party": self.is_in_party,
            "party_slot": self.party_slot,
            "trade_locked": self.trade_locked,
            "trade_count": self.trade_count,
            "caught_at": self.caught_at
        }

# ==================== TRAINER PROFILE ====================

@dataclass
class TrainerProfile:
    """Player data"""
    user_id: int
    display_name: str = ""
    
    # Currency
    creature_shards: int = 0
    
    # Energy
    energy: int = 10
    max_energy: int = 10
    last_energy_update: str = ""
    
    # Stats
    monsters_caught: int = 0
    unique_species: int = 0
    shinies_caught: int = 0
    evolve_count: int = 0
    wild_battles_won: int = 0
    wild_battles_lost: int = 0
    pvp_wins: int = 0
    pvp_losses: int = 0
    
    # Ranked
    pvp_rating: int = 1000
    pvp_rank: str = "Bronze"
    season_highest_rating: int = 1000
    season_wins: int = 0
    season_losses: int = 0
    win_streak: int = 0
    best_win_streak: int = 0
    last_opponent_id: int = 0
    
    # Flags
    has_chosen_starter: bool = False
    
    # Timestamps
    created_at: str = ""
    last_active: str = ""
    
    def to_dict(self) -> Dict:
        return {
            "user_id": self.user_id,
            "display_name": self.display_name,
            "creature_shards": self.creature_shards,
            "energy": self.energy,
            "max_energy": self.max_energy,
            "last_energy_update": self.last_energy_update,
            "monsters_caught": self.monsters_caught,
            "unique_species": self.unique_species,
            "shinies_caught": self.shinies_caught,
            "evolve_count": self.evolve_count,
            "wild_battles_won": self.wild_battles_won,
            "wild_battles_lost": self.wild_battles_lost,
            "pvp_wins": self.pvp_wins,
            "pvp_losses": self.pvp_losses,
            "pvp_rating": self.pvp_rating,
            "pvp_rank": self.pvp_rank,
            "season_highest_rating": self.season_highest_rating,
            "season_wins": self.season_wins,
            "season_losses": self.season_losses,
            "win_streak": self.win_streak,
            "best_win_streak": self.best_win_streak,
            "last_opponent_id": self.last_opponent_id,
            "has_chosen_starter": self.has_chosen_starter,
            "created_at": self.created_at,
            "last_active": self.last_active
        }

# ==================== INVENTORY ====================

@dataclass
class InventoryItem:
    """Item in player inventory"""
    item_id: str
    quantity: int = 0

@dataclass
class ShopItem:
    """Item available in shop"""
    id: str
    name: str
    description: str
    category: str  # trap, potion, booster
    price: int
    
    # For traps
    catch_multiplier: Optional[float] = None
    
    # For potions
    heal_amount: Optional[int] = None
    heal_percent: Optional[int] = None  # For full heal
    
    # For boosters
    boost_stat: Optional[str] = None
    boost_amount: Optional[int] = None
    boost_battles: Optional[int] = None  # Duration in battles

# Default shop items
DEFAULT_SHOP_ITEMS = [
    # Traps
    ShopItem("basic_trap", "Basic Trap", "Standard capture device", "trap", 10, catch_multiplier=1.0),
    ShopItem("great_trap", "Great Trap", "Improved capture device", "trap", 50, catch_multiplier=1.5),
    ShopItem("ultra_trap", "Ultra Trap", "Advanced capture device", "trap", 150, catch_multiplier=2.0),
    ShopItem("master_trap", "Master Trap", "Premium capture device", "trap", 500, catch_multiplier=3.0),
    
    # Potions
    ShopItem("potion", "Potion", "Heals 30 HP", "potion", 25, heal_amount=30),
    ShopItem("super_potion", "Super Potion", "Heals 75 HP", "potion", 75, heal_amount=75),
    ShopItem("max_potion", "Max Potion", "Full HP restore", "potion", 200, heal_percent=100),
    
    # Boosters
    ShopItem("atk_boost", "Attack Boost", "+10 ATK for 3 battles", "booster", 100, boost_stat="atk", boost_amount=10, boost_battles=3),
    ShopItem("def_boost", "Defense Boost", "+10 DEF for 3 battles", "booster", 100, boost_stat="def", boost_amount=10, boost_battles=3),
    ShopItem("spd_boost", "Speed Boost", "+10 SPD for 3 battles", "booster", 100, boost_stat="spd", boost_amount=10, boost_battles=3),
    
    # Energy
    ShopItem("energy_refill", "Energy Cell", "Restore 1 energy", "energy", 50),
]

# ==================== ACHIEVEMENT ====================

@dataclass 
class AchievementDefinition:
    """Achievement template (mod-created)"""
    id: str
    name: str
    description: str
    trigger: str  # catch_total, catch_shiny, pvp_wins, etc.
    threshold: int
    reward_type: str  # shards, item, title
    reward_amount: Optional[int] = None
    reward_item_id: Optional[str] = None
    badge_emoji: str = "🏅"
    hidden: bool = False  # Secret achievements
    
    def to_dict(self) -> Dict:
        return {
            "id": self.id,
            "name": self.name,
            "description": self.description,
            "trigger": self.trigger,
            "threshold": self.threshold,
            "reward_type": self.reward_type,
            "reward_amount": self.reward_amount,
            "reward_item_id": self.reward_item_id,
            "badge_emoji": self.badge_emoji,
            "hidden": self.hidden
        }
    
    @staticmethod
    def from_dict(data: Dict) -> 'AchievementDefinition':
        return AchievementDefinition(**data)

@dataclass
class PlayerAchievement:
    """Player's progress on an achievement"""
    user_id: int
    achievement_id: str
    progress: int = 0
    completed: bool = False
    completed_at: Optional[str] = None

# ==================== BATTLE STATE ====================

@dataclass
class ActiveStatus:
    """Status effect on a monster during battle"""
    type: StatusEffectType
    remaining_turns: int
    value: int = 0  # For damage/shield/buff amount
    stat: Optional[str] = None  # For buff/debuff
    
@dataclass
class BattleMonsterState:
    """Monster state during a battle"""
    instance: MonsterInstance
    definition: MonsterDefinition
    
    # Current stats (modified by buffs/level)
    current_hp: int = 0
    max_hp: int = 0
    atk: int = 0
    defense: int = 0  # 'def' is reserved
    matk: int = 0
    mdef: int = 0
    spd: int = 0
    
    # Battle state
    statuses: List[ActiveStatus] = field(default_factory=list)
    cooldowns: List[int] = field(default_factory=lambda: [0, 0, 0, 0])
    last_ability_id: Optional[str] = None
    
    # Boosters active
    active_boosters: List[Dict] = field(default_factory=list)

@dataclass
class BattleState:
    """Complete battle state"""
    battle_id: str
    battle_type: str  # "wild", "pvp_casual", "pvp_ranked"
    channel_id: int
    message_id: Optional[int] = None
    
    # Players
    player1_id: int = 0
    player2_id: Optional[int] = None  # None for wild battles
    
    # Teams (for PvP 3v3)
    player1_team: List[BattleMonsterState] = field(default_factory=list)
    player2_team: List[BattleMonsterState] = field(default_factory=list)
    
    # Active monsters (index into team)
    player1_active: int = 0
    player2_active: int = 0
    
    # Wild monster (for wild battles)
    wild_monster: Optional[BattleMonsterState] = None
    
    # Turn management
    current_turn_player: int = 0  # player1_id or player2_id
    turn_number: int = 1
    turn_start_time: Optional[str] = None
    
    # Battle log
    log: List[str] = field(default_factory=list)
    
    # Flags
    is_catch_attempt: bool = False
    battle_ended: bool = False
    winner_id: Optional[int] = None
    
    # For wild encounters from spawns
    encounter_monster_id: Optional[str] = None

# ==================== WILD SPAWN ====================

@dataclass
class WildSpawn:
    """Temporary wild spawn in a channel"""
    spawn_id: str
    channel_id: int
    monster_id: str
    monster_name: str
    rarity: MonsterRarity
    message_id: int
    spawned_at: str
    expires_at: str
    claimed_by: List[int] = field(default_factory=list)  # User IDs who reacted
    winner_id: Optional[int] = None  # RNG winner

# ==================== SEASON ====================

@dataclass
class Season:
    """Ranked PvP season"""
    season_id: int
    name: str
    start_date: str
    end_date: str
    is_active: bool = True
    
    # Rewards tiers
    rewards: Dict[str, Any] = field(default_factory=dict)
    # e.g. {"gold": {"min_rating": 1500, "shards": 500, "monster_id": "season_exclusive"}}

# ==================== HELPER FUNCTIONS ====================

def calculate_stat(base: int, iv: int, level: int) -> int:
    """Calculate actual stat value from base, IV, and level"""
    # Pokemon-like formula simplified
    return int(((2 * base + iv) * level / 50) + 5)

def calculate_hp(base_hp: int, iv_hp: int, level: int) -> int:
    """Calculate HP (different formula)"""
    return int(((2 * base_hp + iv_hp) * level / 50) + level + 10)

def xp_for_level(level: int) -> int:
    """XP required to reach a level"""
    if level <= 1:
        return 0
    # Exponential growth
    return int(100 * (level ** 1.5))

def get_rank_from_rating(rating: int) -> str:
    """Get rank title from rating"""
    if rating >= 2200:
        return "Grandmaster"
    elif rating >= 2000:
        return "Master"
    elif rating >= 1800:
        return "Diamond"
    elif rating >= 1600:
        return "Platinum"
    elif rating >= 1400:
        return "Gold"
    elif rating >= 1200:
        return "Silver"
    elif rating >= 1000:
        return "Bronze"
    else:
        return "Iron"

def get_rank_emoji(rating: int) -> str:
    """Get emoji for rank display"""
    if rating >= 2200:
        return "🏆"  # Grandmaster
    elif rating >= 2000:
        return "👑"  # Master
    elif rating >= 1800:
        return "💎"  # Diamond
    elif rating >= 1600:
        return "💠"  # Platinum
    elif rating >= 1400:
        return "🥇"  # Gold
    elif rating >= 1200:
        return "🥈"  # Silver
    elif rating >= 1000:
        return "🥉"  # Bronze
    else:
        return "⚙️"  # Iron

def get_rank_color(rating: int) -> int:
    """Get Discord color for rank"""
    if rating >= 2200:
        return 0xFF4500  # Grandmaster - Orange Red
    elif rating >= 2000:
        return 0xFFD700  # Master - Gold
    elif rating >= 1800:
        return 0x00BFFF  # Diamond - Deep Sky Blue
    elif rating >= 1600:
        return 0x00CED1  # Platinum - Dark Turquoise
    elif rating >= 1400:
        return 0xFFD700  # Gold
    elif rating >= 1200:
        return 0xC0C0C0  # Silver
    elif rating >= 1000:
        return 0xCD7F32  # Bronze
    else:
        return 0x71797E  # Iron - Gray

def get_rank_progress(rating: int) -> tuple:
    """Get progress to next rank. Returns (current_rank, next_rank, progress_percent, points_needed)"""
    thresholds = [
        (0, "Iron", 1000),
        (1000, "Bronze", 1200),
        (1200, "Silver", 1400),
        (1400, "Gold", 1600),
        (1600, "Platinum", 1800),
        (1800, "Diamond", 2000),
        (2000, "Master", 2200),
        (2200, "Grandmaster", 9999),
    ]
    
    for i, (threshold, rank, next_threshold) in enumerate(thresholds):
        if rating < next_threshold:
            progress = (rating - threshold) / (next_threshold - threshold) * 100
            points_needed = next_threshold - rating
            next_rank = thresholds[i + 1][1] if i + 1 < len(thresholds) else "MAX"
            return (rank, next_rank, min(100, progress), points_needed)
    
    return ("Grandmaster", "MAX", 100, 0)

def get_rarity_emoji(rarity: MonsterRarity) -> str:
    """Get emoji for rarity display"""
    return {
        MonsterRarity.STARTER: "🌟",
        MonsterRarity.COMMON: "⭐",
        MonsterRarity.UNCOMMON: "⭐⭐",
        MonsterRarity.RARE: "⭐⭐⭐",
        MonsterRarity.EPIC: "💜",
        MonsterRarity.LEGENDARY: "🔶",
        MonsterRarity.MYTHIC: "💠",
    }.get(rarity, "⭐")

def get_element_emoji(element: ElementType) -> str:
    """Get emoji for element display"""
    return {
        ElementType.FIRE: "🔥",
        ElementType.WATER: "💧",
        ElementType.ICE: "❄️",
        ElementType.NATURE: "🌿",
        ElementType.EARTH: "🪨",
        ElementType.ELECTRIC: "⚡",
        ElementType.METAL: "⚙️",
        ElementType.LIGHT: "✨",
        ElementType.DARK: "🌑",
        ElementType.CHAOS: "💀",
        ElementType.DRAGON: "🐉",
        ElementType.NORMAL: "⚪",
    }.get(element, "⚪")

def get_status_emoji(status: StatusEffectType) -> str:
    """Get emoji for status effect"""
    return {
        StatusEffectType.BURN: "🔥",
        StatusEffectType.POISON: "☠️",
        StatusEffectType.FREEZE: "❄️",
        StatusEffectType.PARALYZE: "⚡",
        StatusEffectType.SLEEP: "💤",
        StatusEffectType.CONFUSION: "😵",
        StatusEffectType.SHIELD: "🛡️",
        StatusEffectType.BUFF: "⬆️",
        StatusEffectType.DEBUFF: "⬇️",
    }.get(status, "❓")