# cooperative_system.py
import time
from typing import Dict, Optional
from uuid import uuid4
from game_engine import Vector2D, GauchoCharacter, PhysicsEngine

class CompanionSystem:
    """Sistema de compañero de mate para combate cooperativo"""
    def __init__(self):
        self.pairs: Dict[str, dict] = {}
        self.session_timeout = 300  # 5 minutos
    
    def create_session(self, player1: GauchoCharacter) -> str:
        session_id = str(uuid4())
        self.pairs[session_id] = {
            'player1': player1,
            'player2': None,
            'last_activity': time.time(),
            'combos': {
                'mate_sync': False,
                'asado_power': 0.0,
                'cultural_chain': 0
            }
        }
        return session_id
    
    def join_session(self, session_id: str, player2: GauchoCharacter) -> bool:
        if session_id in self.pairs and self.pairs[session_id]['player2'] is None:
            self.pairs[session_id]['player2'] = player2
            self.pairs[session_id]['last_activity'] = time.time()
            return True
        return False
    
    def calculate_cultural_synergy(self, session_id: str) -> float:
        """Calcula la sinergia basada en valores argentinos compartidos"""
        session = self.pairs.get(session_id)
        if not session:
            return 0.0
        
        common_values = sum(
            1 for valor in session['player1'].inventory['cristales']
            if session['player1'].inventory['cristales'][valor] and 
            session['player2'].inventory['cristales'][valor]
        )
        return min(1.0, common_values / 7)  # Normalizado a 7 valores
    
    def update_combat_state(self, session_id: str, player_inputs: dict):
        """Actualiza el estado del combate cooperativo"""
        session = self.pairs.get(session_id)
        if not session:
            return
        
        # Lógica de combos culturales
        if player_inputs['player1'].get('action') == 'mate' and \
           player_inputs['player2'].get('action') == 'mate':
            session['combos']['mate_sync'] = True
            session['combos']['asado_power'] += 0.1
        
        # Resetear si hay desincronización
        if time.time() - session['last_activity'] > self.session_timeout:
            self.pairs.pop(session_id, None)

class AlienAlgorithmEnemy:
    """IA para enemigos algorítmicos con patrones adaptativos"""
    def __init__(self, difficulty: str):
        self.difficulty = difficulty
        self.patterns = {
            'homogenization_wave': self._homogenization_pattern,
            'cultural_erasure': self._erasure_pattern,
            'identity_fragmentation': self._fragmentation_pattern
        }
        self.current_pattern = None
    
    def _homogenization_pattern(self, player_pos: Vector2D) -> Vector2D:
        """Patrón de ataque que busca limitar movimiento"""
        return Vector2D(
            math.copysign(2.5, player_pos.x),
            math.copysign(1.8, player_pos.y)
        )
    
    def _cultural_erasure(self, player: GauchoCharacter) -> dict:
        """Ataque que reduce habilidades culturales"""
        return {
            'disable_abilities': [
                ability for ability, unlocked in player.abilities.items()
                if unlocked
            ][:1]
        }
    
    def update_ai(self, players: list, physics: PhysicsEngine):
        """Actualiza la IA basada en el estado de los jugadores"""
        # Lógica compleja de selección de patrones
        pass