#!/usr/bin/env python3
"""
Enterprise Kubernetes Game Server Management Framework
"""

import subprocess
import json
import yaml
import logging
import time
import asyncio
import aiohttp
from typing import Dict, List, Optional, Tuple, Any, Union
from dataclasses import dataclass, asdict, field
from pathlib import Path
from enum import Enum
import kubernetes
from kubernetes import client, config
import redis
import boto3
from prometheus_client import Counter, Gauge, Histogram
import websockets

class GameServerState(Enum):
    CREATING = "creating"
    STARTING = "starting"
    READY = "ready"
    ALLOCATED = "allocated"
    SHUTDOWN = "shutdown"
    ERROR = "error"

class ServerType(Enum):
    DEDICATED = "dedicated"
    MATCH = "match"
    LOBBY = "lobby"
    TOURNAMENT = "tournament"

class RegionCode(Enum):
    US_EAST = "us-east-1"
    US_WEST = "us-west-2"
    EU_WEST = "eu-west-1"
    AP_NORTHEAST = "ap-northeast-1"
    AP_SOUTHEAST = "ap-southeast-2"

@dataclass
class GameServerSpec:
    name: str
    game_id: str
    server_type: ServerType
    region: RegionCode
    cpu_request: str = "1000m"
    cpu_limit: str = "2000m"
    memory_request: str = "2Gi"
    memory_limit: str = "4Gi"
    gpu_enabled: bool = False
    gpu_type: Optional[str] = None
    network_policy: str = "standard"
    max_players: int = 64
    tick_rate: int = 64
    anti_cheat_enabled: bool = True
    persistent_storage: bool = False
    storage_size: str = "10Gi"

@dataclass
class PlayerSession:
    player_id: str
    session_id: str
    server_id: str
    ip_address: str
    connected_at: float
    last_heartbeat: float
    latency_ms: float
    region: RegionCode
    authentication_token: str

@dataclass
class MatchmakingRequest:
    request_id: str
    players: List[str]
    game_mode: str
    skill_rating: float
    region_preference: List[RegionCode]
    party_size: int
    created_at: float
    requirements: Dict[str, Any] = field(default_factory=dict)

class EnterpriseGameServerFramework:
    def __init__(self, config_file: str = "gaming_config.yaml"):
        self.config = self._load_config(config_file)
        self.game_servers = {}
        self.player_sessions = {}
        self.matchmaking_queue = []
        self.metrics = {}
        
        # Initialize Kubernetes client
        try:
            config.load_incluster_config()
        except:
            config.load_kube_config()
        
        self.k8s_client = client.ApiClient()
        self.v1 = client.CoreV1Api(self.k8s_client)
        self.apps_v1 = client.AppsV1Api(self.k8s_client)
        self.custom_api = client.CustomObjectsApi(self.k8s_client)
        
        # Initialize Redis for session management
        self.redis_client = redis.Redis(
            host=self.config.get('redis', {}).get('host', 'localhost'),
            port=self.config.get('redis', {}).get('port', 6379),
            decode_responses=True
        )
        
        # Initialize logging
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('/var/log/game_server_framework.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
        
        # Initialize metrics
        self._initialize_metrics()
        
        # Start background tasks
        asyncio.create_task(self._health_check_loop())
        asyncio.create_task(self._matchmaking_loop())
        asyncio.create_task(self._scaling_loop())
        
    def _load_config(self, config_file: str) -> Dict:
        """Load gaming configuration from YAML file"""
        try:
            with open(config_file, 'r') as f:
                return yaml.safe_load(f)
        except FileNotFoundError:
            return self._create_default_config()
    
    def _create_default_config(self) -> Dict:
        """Create default gaming configuration"""
        return {
            'agones': {
                'namespace': 'game-servers',
                'fleet_name': 'dedicated-game-fleet',
                'min_replicas': 10,
                'max_replicas': 1000,
                'buffer_size': 20
            },
            'kubernetes': {
                'namespace': 'game-servers',
                'node_selector': {
                    'game-server': 'true'
                },
                'tolerations': [
                    {
                        'key': 'game-server',
                        'operator': 'Equal',
                        'value': 'true',
                        'effect': 'NoSchedule'
                    }
                ]
            },
            'networking': {
                'port_range_start': 7000,
                'port_range_end': 8000,
                'protocol': 'UDP',
                'load_balancer_type': 'NLB'
            },
            'scaling': {
                'scale_up_threshold': 0.8,
                'scale_down_threshold': 0.3,
                'cooldown_seconds': 300,
                'metrics_window': 300
            },
            'monitoring': {
                'prometheus_url': 'http://prometheus:9090',
                'grafana_url': 'http://grafana:3000',
                'alert_webhook': 'https://hooks.slack.com/services/YOUR/WEBHOOK'
            }
        }
    
    def _initialize_metrics(self):
        """Initialize Prometheus metrics"""
        self.metrics = {
            'servers_total': Gauge('game_servers_total', 'Total number of game servers', ['region', 'state']),
            'players_connected': Gauge('players_connected_total', 'Total connected players', ['region']),
            'matchmaking_queue': Gauge('matchmaking_queue_size', 'Size of matchmaking queue', ['game_mode']),
            'server_allocation_duration': Histogram('server_allocation_duration_seconds', 'Time to allocate server'),
            'player_latency': Histogram('player_latency_milliseconds', 'Player connection latency', ['region']),
            'matches_created': Counter('matches_created_total', 'Total matches created', ['game_mode'])
        }
    
    async def create_game_server(self, spec: GameServerSpec) -> str:
        """Create a new game server instance"""
        server_id = f"{spec.game_id}-{spec.name}-{int(time.time())}"
        
        self.logger.info(f"Creating game server: {server_id}")
        
        # Create Agones GameServer resource
        game_server = {
            'apiVersion': 'agones.dev/v1',
            'kind': 'GameServer',
            'metadata': {
                'name': server_id,
                'namespace': self.config['agones']['namespace'],
                'labels': {
                    'game': spec.game_id,
                    'type': spec.server_type.value,
                    'region': spec.region.value
                }
            },
            'spec': {
                'container': {
                    'name': 'game-server',
                    'image': f"{self.config.get('registry', 'gcr.io')}/{spec.game_id}:latest",
                    'resources': {
                        'requests': {
                            'cpu': spec.cpu_request,
                            'memory': spec.memory_request
                        },
                        'limits': {
                            'cpu': spec.cpu_limit,
                            'memory': spec.memory_limit
                        }
                    },
                    'env': [
                        {'name': 'SERVER_ID', 'value': server_id},
                        {'name': 'MAX_PLAYERS', 'value': str(spec.max_players)},
                        {'name': 'TICK_RATE', 'value': str(spec.tick_rate)},
                        {'name': 'ANTI_CHEAT', 'value': str(spec.anti_cheat_enabled).lower()},
                        {'name': 'REGION', 'value': spec.region.value}
                    ]
                },
                'ports': [
                    {
                        'name': 'game',
                        'containerPort': 7777,
                        'protocol': 'UDP'
                    },
                    {
                        'name': 'metrics',
                        'containerPort': 9090,
                        'protocol': 'TCP'
                    }
                ],
                'health': {
                    'disabled': False,
                    'initialDelaySeconds': 30,
                    'periodSeconds': 10,
                    'failureThreshold': 3
                },
                'scheduling': 'Packed',
                'template': {
                    'spec': {
                        'nodeSelector': self.config['kubernetes']['node_selector'],
                        'tolerations': self.config['kubernetes']['tolerations']
                    }
                }
            }
        }
        
        # Add GPU support if enabled
        if spec.gpu_enabled and spec.gpu_type:
            game_server['spec']['container']['resources']['limits']['nvidia.com/gpu'] = '1'
            game_server['spec']['template']['spec']['nodeSelector']['gpu-type'] = spec.gpu_type
        
        # Add persistent storage if enabled
        if spec.persistent_storage:
            game_server['spec']['template']['spec']['volumes'] = [
                {
                    'name': 'game-data',
                    'persistentVolumeClaim': {
                        'claimName': f"{server_id}-pvc"
                    }
                }
            ]
            game_server['spec']['container']['volumeMounts'] = [
                {
                    'name': 'game-data',
                    'mountPath': '/data'
                }
            ]
            
            # Create PVC
            await self._create_persistent_volume_claim(server_id, spec.storage_size)
        
        try:
            # Create the GameServer
            result = self.custom_api.create_namespaced_custom_object(
                group='agones.dev',
                version='v1',
                namespace=self.config['agones']['namespace'],
                plural='gameservers',
                body=game_server
            )
            
            # Track in internal state
            self.game_servers[server_id] = {
                'spec': spec,
                'state': GameServerState.CREATING,
                'created_at': time.time(),
                'resource': result
            }
            
            # Update metrics
            self.metrics['servers_total'].labels(
                region=spec.region.value,
                state=GameServerState.CREATING.value
            ).inc()
            
            self.logger.info(f"Game server created: {server_id}")
            return server_id
            
        except Exception as e:
            self.logger.error(f"Failed to create game server: {e}")
            raise
    
    async def _create_persistent_volume_claim(self, server_id: str, size: str):
        """Create PVC for game server persistent storage"""
        pvc = client.V1PersistentVolumeClaim(
            metadata=client.V1ObjectMeta(
                name=f"{server_id}-pvc",
                namespace=self.config['agones']['namespace']
            ),
            spec=client.V1PersistentVolumeClaimSpec(
                access_modes=['ReadWriteOnce'],
                resources=client.V1ResourceRequirements(
                    requests={'storage': size}
                ),
                storage_class_name='game-server-ssd'
            )
        )
        
        self.v1.create_namespaced_persistent_volume_claim(
            namespace=self.config['agones']['namespace'],
            body=pvc
        )
    
    async def allocate_game_server(self, matchmaking_request: MatchmakingRequest) -> Optional[Dict[str, Any]]:
        """Allocate a game server for a match"""
        self.logger.info(f"Allocating server for match request: {matchmaking_request.request_id}")
        
        start_time = time.time()
        
        # Find available servers in preferred regions
        for region in matchmaking_request.region_preference:
            available_servers = await self._find_available_servers(
                region=region,
                game_mode=matchmaking_request.game_mode,
                requirements=matchmaking_request.requirements
            )
            
            if available_servers:
                # Allocate the best server
                server = await self._select_best_server(available_servers, matchmaking_request)
                
                if server:
                    # Allocate through Agones
                    allocation = await self._allocate_agones_server(server['name'])
                    
                    if allocation:
                        # Update server state
                        self.game_servers[server['name']]['state'] = GameServerState.ALLOCATED
                        self.game_servers[server['name']]['allocation'] = allocation
                        self.game_servers[server['name']]['match_id'] = matchmaking_request.request_id
                        
                        # Record metrics
                        duration = time.time() - start_time
                        self.metrics['server_allocation_duration'].observe(duration)
                        self.metrics['matches_created'].labels(
                            game_mode=matchmaking_request.game_mode
                        ).inc()
                        
                        # Create player sessions
                        for player_id in matchmaking_request.players:
                            await self._create_player_session(
                                player_id,
                                server['name'],
                                allocation['address'],
                                allocation['port']
                            )
                        
                        self.logger.info(f"Server allocated: {server['name']} for match {matchmaking_request.request_id}")
                        
                        return {
                            'server_id': server['name'],
                            'address': allocation['address'],
                            'port': allocation['port'],
                            'match_id': matchmaking_request.request_id,
                            'region': region.value
                        }
        
        self.logger.warning(f"No available servers for match request: {matchmaking_request.request_id}")
        return None
    
    async def _find_available_servers(self, region: RegionCode, game_mode: str, 
                                     requirements: Dict[str, Any]) -> List[Dict[str, Any]]:
        """Find available servers matching requirements"""
        available_servers = []
        
        # Query Agones for ready servers
        game_servers = self.custom_api.list_namespaced_custom_object(
            group='agones.dev',
            version='v1',
            namespace=self.config['agones']['namespace'],
            plural='gameservers',
            label_selector=f"region={region.value},state=Ready"
        )
        
        for server in game_servers.get('items', []):
            # Check if server meets requirements
            if self._server_meets_requirements(server, game_mode, requirements):
                available_servers.append({
                    'name': server['metadata']['name'],
                    'labels': server['metadata'].get('labels', {}),
                    'status': server.get('status', {}),
                    'spec': server.get('spec', {})
                })
        
        return available_servers
    
    def _server_meets_requirements(self, server: Dict, game_mode: str, 
                                  requirements: Dict[str, Any]) -> bool:
        """Check if server meets match requirements"""
        # Check game mode support
        server_modes = server['metadata'].get('labels', {}).get('game_modes', '').split(',')
        if game_mode not in server_modes and 'all' not in server_modes:
            return False
        
        # Check player capacity
        max_players = int(server['metadata'].get('labels', {}).get('max_players', '64'))
        if requirements.get('min_players', 0) > max_players:
            return False
        
        # Check additional requirements
        for key, value in requirements.items():
            if key in ['tick_rate', 'anti_cheat']:
                server_value = server['metadata'].get('labels', {}).get(key)
                if server_value and str(value).lower() != server_value.lower():
                    return False
        
        return True
    
    async def _select_best_server(self, servers: List[Dict], 
                                request: MatchmakingRequest) -> Optional[Dict]:
        """Select the best server from available options"""
        if not servers:
            return None
        
        # Score servers based on various factors
        scored_servers = []
        
        for server in servers:
            score = 0
            
            # Prefer servers with lower current load
            current_players = int(server['status'].get('players', {}).get('count', 0))
            max_players = int(server['labels'].get('max_players', 64))
            load_ratio = current_players / max_players
            score += (1 - load_ratio) * 100
            
            # Prefer newer servers (less likely to have issues)
            age_minutes = (time.time() - server['status'].get('created_at', 0)) / 60
            if age_minutes < 60:
                score += 20
            elif age_minutes < 240:
                score += 10
            
            # Prefer servers in the same zone if specified
            if 'preferred_zone' in request.requirements:
                server_zone = server['labels'].get('zone', '')
                if server_zone == request.requirements['preferred_zone']:
                    score += 30
            
            scored_servers.append((score, server))
        
        # Sort by score (highest first)
        scored_servers.sort(key=lambda x: x[0], reverse=True)
        
        return scored_servers[0][1] if scored_servers else None
    
    async def _allocate_agones_server(self, server_name: str) -> Optional[Dict[str, Any]]:
        """Allocate a specific Agones GameServer"""
        allocation = {
            'apiVersion': 'allocation.agones.dev/v1',
            'kind': 'GameServerAllocation',
            'spec': {
                'required': {
                    'matchLabels': {
                        'agones.dev/gameserver': server_name
                    }
                }
            }
        }
        
        try:
            result = self.custom_api.create_namespaced_custom_object(
                group='allocation.agones.dev',
                version='v1',
                namespace=self.config['agones']['namespace'],
                plural='gameserverallocations',
                body=allocation
            )
            
            if result.get('status', {}).get('state') == 'Allocated':
                return {
                    'address': result['status']['address'],
                    'port': result['status']['ports'][0]['port'],
                    'node': result['status']['nodeName']
                }
            
        except Exception as e:
            self.logger.error(f"Failed to allocate server {server_name}: {e}")
        
        return None
    
    async def _create_player_session(self, player_id: str, server_id: str, 
                                   address: str, port: int):
        """Create and track player session"""
        session_id = f"{player_id}-{server_id}-{int(time.time())}"
        
        session = PlayerSession(
            player_id=player_id,
            session_id=session_id,
            server_id=server_id,
            ip_address=address,
            connected_at=time.time(),
            last_heartbeat=time.time(),
            latency_ms=0,
            region=self.game_servers[server_id]['spec'].region,
            authentication_token=self._generate_session_token(player_id, server_id)
        )
        
        # Store in Redis for distributed access
        session_data = asdict(session)
        session_data['region'] = session.region.value
        
        self.redis_client.hset(
            f"player_session:{session_id}",
            mapping=session_data
        )
        self.redis_client.expire(f"player_session:{session_id}", 86400)  # 24 hour TTL
        
        # Track locally
        self.player_sessions[player_id] = session
        
        # Update metrics
        self.metrics['players_connected'].labels(region=session.region.value).inc()
    
    def _generate_session_token(self, player_id: str, server_id: str) -> str:
        """Generate secure session token"""
        import hashlib
        import secrets
        
        salt = secrets.token_hex(16)
        token_data = f"{player_id}:{server_id}:{time.time()}:{salt}"
        return hashlib.sha256(token_data.encode()).hexdigest()
    
    async def handle_matchmaking_request(self, request: MatchmakingRequest):
        """Handle incoming matchmaking request"""
        self.logger.info(f"Processing matchmaking request: {request.request_id}")
        
        # Add to queue
        self.matchmaking_queue.append(request)
        self.metrics['matchmaking_queue'].labels(game_mode=request.game_mode).inc()
        
        # Store in Redis for persistence
        self.redis_client.hset(
            f"matchmaking:{request.request_id}",
            mapping=asdict(request)
        )
        self.redis_client.expire(f"matchmaking:{request.request_id}", 300)  # 5 minute TTL
    
    async def _matchmaking_loop(self):
        """Background task for processing matchmaking queue"""
        while True:
            try:
                if self.matchmaking_queue:
                    # Group compatible requests
                    matches = await self._group_matchmaking_requests()
                    
                    # Process each match
                    for match in matches:
                        allocation = await self.allocate_game_server(match)
                        
                        if allocation:
                            # Notify players
                            await self._notify_match_found(match, allocation)
                            
                            # Remove from queue
                            for request in match.players:
                                self.matchmaking_queue.remove(request)
                                self.metrics['matchmaking_queue'].labels(
                                    game_mode=match.game_mode
                                ).dec()
                
                await asyncio.sleep(1)  # Process queue every second
                
            except Exception as e:
                self.logger.error(f"Matchmaking loop error: {e}")
                await asyncio.sleep(5)
    
    async def _group_matchmaking_requests(self) -> List[MatchmakingRequest]:
        """Group compatible matchmaking requests into matches"""
        grouped_matches = []
        processed_requests = set()
        
        # Sort by game mode and skill rating
        sorted_queue = sorted(
            self.matchmaking_queue,
            key=lambda x: (x.game_mode, x.skill_rating)
        )
        
        for request in sorted_queue:
            if request.request_id in processed_requests:
                continue
            
            # Find compatible players
            match_players = [request]
            processed_requests.add(request.request_id)
            
            target_players = self._get_target_player_count(request.game_mode)
            current_players = request.party_size
            
            for other_request in sorted_queue:
                if other_request.request_id in processed_requests:
                    continue
                
                if current_players + other_request.party_size > target_players:
                    continue
                
                # Check compatibility
                if self._are_requests_compatible(request, other_request):
                    match_players.append(other_request)
                    processed_requests.add(other_request.request_id)
                    current_players += other_request.party_size
                    
                    if current_players >= target_players:
                        break
            
            # Create match if we have enough players
            if current_players >= self._get_min_player_count(request.game_mode):
                combined_request = self._combine_requests(match_players)
                grouped_matches.append(combined_request)
        
        return grouped_matches
    
    def _are_requests_compatible(self, req1: MatchmakingRequest, 
                                req2: MatchmakingRequest) -> bool:
        """Check if two matchmaking requests are compatible"""
        # Same game mode
        if req1.game_mode != req2.game_mode:
            return False
        
        # Similar skill rating (within 200 points)
        if abs(req1.skill_rating - req2.skill_rating) > 200:
            return False
        
        # Compatible regions (at least one overlap)
        common_regions = set(req1.region_preference) & set(req2.region_preference)
        if not common_regions:
            return False
        
        # Check wait time (relax requirements for longer waits)
        wait_time = time.time() - min(req1.created_at, req2.created_at)
        if wait_time > 60:  # After 60 seconds, relax skill requirements
            return True
        
        return True
    
    def _combine_requests(self, requests: List[MatchmakingRequest]) -> MatchmakingRequest:
        """Combine multiple requests into a single match request"""
        all_players = []
        total_skill = 0
        all_regions = set()
        
        for req in requests:
            all_players.extend(req.players)
            total_skill += req.skill_rating * req.party_size
            all_regions.update(req.region_preference)
        
        avg_skill = total_skill / len(all_players)
        
        # Prefer regions that appear most frequently
        region_counts = {}
        for req in requests:
            for region in req.region_preference:
                region_counts[region] = region_counts.get(region, 0) + req.party_size
        
        sorted_regions = sorted(region_counts.keys(), 
                              key=lambda x: region_counts[x], 
                              reverse=True)
        
        return MatchmakingRequest(
            request_id=f"match-{int(time.time())}",
            players=all_players,
            game_mode=requests[0].game_mode,
            skill_rating=avg_skill,
            region_preference=sorted_regions,
            party_size=len(all_players),
            created_at=requests[0].created_at,
            requirements=requests[0].requirements
        )
    
    def _get_target_player_count(self, game_mode: str) -> int:
        """Get target player count for game mode"""
        player_counts = {
            'battle_royale': 100,
            'team_deathmatch': 32,
            'capture_the_flag': 24,
            'duel': 2,
            'free_for_all': 16
        }
        return player_counts.get(game_mode, 32)
    
    def _get_min_player_count(self, game_mode: str) -> int:
        """Get minimum player count to start a match"""
        min_counts = {
            'battle_royale': 60,
            'team_deathmatch': 16,
            'capture_the_flag': 12,
            'duel': 2,
            'free_for_all': 8
        }
        return min_counts.get(game_mode, 16)
    
    async def _notify_match_found(self, match: MatchmakingRequest, 
                                allocation: Dict[str, Any]):
        """Notify players that a match has been found"""
        notification = {
            'type': 'match_found',
            'match_id': match.request_id,
            'server': {
                'address': allocation['address'],
                'port': allocation['port'],
                'region': allocation['region']
            },
            'players': match.players
        }
        
        # Send via WebSocket to connected players
        for player_id in match.players:
            await self._send_player_notification(player_id, notification)
    
    async def _send_player_notification(self, player_id: str, notification: Dict):
        """Send notification to a specific player"""
        # In production, this would use a proper WebSocket connection manager
        ws_connection = self._get_player_websocket(player_id)
        if ws_connection:
            try:
                await ws_connection.send(json.dumps(notification))
            except Exception as e:
                self.logger.error(f"Failed to notify player {player_id}: {e}")
    
    def _get_player_websocket(self, player_id: str):
        """Get WebSocket connection for player (placeholder)"""
        # This would be implemented with a proper WebSocket manager
        return None
    
    async def _health_check_loop(self):
        """Background task for health checking game servers"""
        while True:
            try:
                # Get all game servers
                game_servers = self.custom_api.list_namespaced_custom_object(
                    group='agones.dev',
                    version='v1',
                    namespace=self.config['agones']['namespace'],
                    plural='gameservers'
                )
                
                for server in game_servers.get('items', []):
                    server_name = server['metadata']['name']
                    server_state = server['status'].get('state', 'Unknown')
                    
                    # Update internal tracking
                    if server_name in self.game_servers:
                        old_state = self.game_servers[server_name]['state']
                        new_state = GameServerState(server_state.lower())
                        
                        if old_state != new_state:
                            self.game_servers[server_name]['state'] = new_state
                            self.logger.info(f"Server {server_name} state changed: {old_state} -> {new_state}")
                            
                            # Update metrics
                            self.metrics['servers_total'].labels(
                                region=self.game_servers[server_name]['spec'].region.value,
                                state=old_state.value
                            ).dec()
                            self.metrics['servers_total'].labels(
                                region=self.game_servers[server_name]['spec'].region.value,
                                state=new_state.value
                            ).inc()
                    
                    # Check player sessions
                    if server_state == 'Allocated':
                        await self._check_player_sessions(server_name)
                
                await asyncio.sleep(10)  # Check every 10 seconds
                
            except Exception as e:
                self.logger.error(f"Health check loop error: {e}")
                await asyncio.sleep(30)
    
    async def _check_player_sessions(self, server_name: str):
        """Check and update player sessions for a server"""
        # Get all sessions for this server from Redis
        pattern = f"player_session:*-{server_name}-*"
        
        for key in self.redis_client.scan_iter(match=pattern):
            session_data = self.redis_client.hgetall(key)
            
            if session_data:
                # Check for stale sessions
                last_heartbeat = float(session_data.get('last_heartbeat', 0))
                if time.time() - last_heartbeat > 60:  # No heartbeat for 60 seconds
                    self.logger.warning(f"Stale session detected: {key}")
                    # Could trigger session cleanup here
    
    async def _scaling_loop(self):
        """Background task for auto-scaling game servers"""
        while True:
            try:
                # Calculate current utilization
                utilization = await self._calculate_fleet_utilization()
                
                self.logger.info(f"Fleet utilization: {utilization:.2%}")
                
                # Scale up if needed
                if utilization > self.config['scaling']['scale_up_threshold']:
                    await self._scale_fleet_up()
                
                # Scale down if needed
                elif utilization < self.config['scaling']['scale_down_threshold']:
                    await self._scale_fleet_down()
                
                await asyncio.sleep(self.config['scaling']['cooldown_seconds'])
                
            except Exception as e:
                self.logger.error(f"Scaling loop error: {e}")
                await asyncio.sleep(60)
    
    async def _calculate_fleet_utilization(self) -> float:
        """Calculate current fleet utilization"""
        total_servers = 0
        allocated_servers = 0
        
        for server_id, server_info in self.game_servers.items():
            if server_info['state'] != GameServerState.SHUTDOWN:
                total_servers += 1
                if server_info['state'] == GameServerState.ALLOCATED:
                    allocated_servers += 1
        
        if total_servers == 0:
            return 0
        
        return allocated_servers / total_servers
    
    async def _scale_fleet_up(self):
        """Scale up the game server fleet"""
        current_size = len(self.game_servers)
        target_size = min(
            int(current_size * 1.5),  # 50% increase
            self.config['agones']['max_replicas']
        )
        
        servers_to_add = target_size - current_size
        
        self.logger.info(f"Scaling up fleet by {servers_to_add} servers")
        
        # Create new servers across regions
        for i in range(servers_to_add):
            # Distribute across regions
            region = list(RegionCode)[i % len(RegionCode)]
            
            spec = GameServerSpec(
                name=f"autoscale-{int(time.time())}-{i}",
                game_id="default",
                server_type=ServerType.DEDICATED,
                region=region
            )
            
            await self.create_game_server(spec)
    
    async def _scale_fleet_down(self):
        """Scale down the game server fleet"""
        # Find servers that can be removed (Ready state, oldest first)
        removable_servers = []
        
        for server_id, server_info in self.game_servers.items():
            if server_info['state'] == GameServerState.READY:
                removable_servers.append((
                    server_info['created_at'],
                    server_id
                ))
        
        # Sort by age (oldest first)
        removable_servers.sort()
        
        # Calculate how many to remove
        current_size = len(self.game_servers)
        target_size = max(
            int(current_size * 0.8),  # 20% decrease
            self.config['agones']['min_replicas']
        )
        
        servers_to_remove = current_size - target_size
        servers_to_remove = min(servers_to_remove, len(removable_servers))
        
        if servers_to_remove > 0:
            self.logger.info(f"Scaling down fleet by {servers_to_remove} servers")
            
            for i in range(servers_to_remove):
                _, server_id = removable_servers[i]
                await self._shutdown_game_server(server_id)
    
    async def _shutdown_game_server(self, server_id: str):
        """Shutdown a game server"""
        try:
            self.custom_api.delete_namespaced_custom_object(
                group='agones.dev',
                version='v1',
                namespace=self.config['agones']['namespace'],
                plural='gameservers',
                name=server_id
            )
            
            # Update internal state
            if server_id in self.game_servers:
                self.game_servers[server_id]['state'] = GameServerState.SHUTDOWN
                
                # Update metrics
                self.metrics['servers_total'].labels(
                    region=self.game_servers[server_id]['spec'].region.value,
                    state=GameServerState.SHUTDOWN.value
                ).inc()
            
            self.logger.info(f"Shutdown game server: {server_id}")
            
        except Exception as e:
            self.logger.error(f"Failed to shutdown server {server_id}: {e}")
    
    def generate_performance_report(self) -> Dict[str, Any]:
        """Generate comprehensive performance report"""
        report = {
            'timestamp': time.time(),
            'fleet_status': {
                'total_servers': len(self.game_servers),
                'by_state': {},
                'by_region': {}
            },
            'player_metrics': {
                'total_connected': len(self.player_sessions),
                'by_region': {}
            },
            'matchmaking': {
                'queue_size': len(self.matchmaking_queue),
                'avg_wait_time': 0
            },
            'performance': {
                'server_allocation_p95': 0,
                'player_latency_avg': 0
            }
        }
        
        # Calculate server distribution
        for server_id, server_info in self.game_servers.items():
            state = server_info['state'].value
            region = server_info['spec'].region.value
            
            report['fleet_status']['by_state'][state] = \
                report['fleet_status']['by_state'].get(state, 0) + 1
            report['fleet_status']['by_region'][region] = \
                report['fleet_status']['by_region'].get(region, 0) + 1
        
        # Calculate player distribution
        for player_id, session in self.player_sessions.items():
            region = session.region.value
            report['player_metrics']['by_region'][region] = \
                report['player_metrics']['by_region'].get(region, 0) + 1
        
        # Calculate average matchmaking wait time
        if self.matchmaking_queue:
            current_time = time.time()
            total_wait = sum(current_time - req.created_at for req in self.matchmaking_queue)
            report['matchmaking']['avg_wait_time'] = total_wait / len(self.matchmaking_queue)
        
        return report

def main():
    """Main execution function"""
    # Initialize gaming framework
    gaming_framework = EnterpriseGameServerFramework()
    
    # Create example game server specifications
    print("Creating game server fleet...")
    
    # Battle Royale servers
    for i in range(5):
        for region in [RegionCode.US_EAST, RegionCode.EU_WEST, RegionCode.AP_NORTHEAST]:
            spec = GameServerSpec(
                name=f"br-server-{i}",
                game_id="battle-royale",
                server_type=ServerType.DEDICATED,
                region=region,
                cpu_request="4000m",
                cpu_limit="8000m",
                memory_request="8Gi",
                memory_limit="16Gi",
                max_players=100,
                tick_rate=30,
                persistent_storage=True,
                storage_size="50Gi"
            )
            asyncio.run(gaming_framework.create_game_server(spec))
    
    # Team-based game servers
    for i in range(10):
        for region in [RegionCode.US_WEST, RegionCode.EU_WEST]:
            spec = GameServerSpec(
                name=f"team-server-{i}",
                game_id="team-shooter",
                server_type=ServerType.MATCH,
                region=region,
                cpu_request="2000m",
                cpu_limit="4000m",
                memory_request="4Gi",
                memory_limit="8Gi",
                max_players=32,
                tick_rate=64
            )
            asyncio.run(gaming_framework.create_game_server(spec))
    
    # Tournament servers with GPU
    for i in range(2):
        spec = GameServerSpec(
            name=f"tournament-server-{i}",
            game_id="competitive",
            server_type=ServerType.TOURNAMENT,
            region=RegionCode.US_EAST,
            cpu_request="8000m",
            cpu_limit="16000m",
            memory_request="16Gi",
            memory_limit="32Gi",
            gpu_enabled=True,
            gpu_type="nvidia-tesla-v100",
            max_players=10,
            tick_rate=128,
            anti_cheat_enabled=True
        )
        asyncio.run(gaming_framework.create_game_server(spec))
    
    # Simulate matchmaking requests
    print("Simulating matchmaking requests...")
    
    sample_requests = [
        MatchmakingRequest(
            request_id=f"req-{i}",
            players=[f"player-{j}" for j in range(i*4, (i+1)*4)],
            game_mode="team_deathmatch",
            skill_rating=1500 + (i * 50),
            region_preference=[RegionCode.US_EAST, RegionCode.US_WEST],
            party_size=4,
            created_at=time.time()
        )
        for i in range(5)
    ]
    
    for request in sample_requests:
        asyncio.run(gaming_framework.handle_matchmaking_request(request))
    
    # Generate performance report
    print("\nGenerating performance report...")
    report = gaming_framework.generate_performance_report()
    
    print("\nEnterprise Gaming Infrastructure Report")
    print("=" * 50)
    print(f"Total Game Servers: {report['fleet_status']['total_servers']}")
    print(f"Connected Players: {report['player_metrics']['total_connected']}")
    print(f"Matchmaking Queue: {report['matchmaking']['queue_size']}")
    
    print("\nServers by State:")
    for state, count in report['fleet_status']['by_state'].items():
        print(f"  {state}: {count}")
    
    print("\nServers by Region:")
    for region, count in report['fleet_status']['by_region'].items():
        print(f"  {region}: {count}")
    
    print("\nPlayers by Region:")
    for region, count in report['player_metrics']['by_region'].items():
        print(f"  {region}: {count}")
    
    if report['matchmaking']['avg_wait_time'] > 0:
        print(f"\nAverage Matchmaking Wait: {report['matchmaking']['avg_wait_time']:.1f}s")
    
    print("\n✅ Gaming infrastructure initialized successfully!")
    print("Monitor game servers at: http://grafana:3000")
    print("View Agones dashboard at: http://agones-dashboard:8080")

if __name__ == "__main__":
    main()

#!/bin/bash
# Enterprise Gaming Network Optimization Script

set -euo pipefail

# Network optimization parameters
declare -A NETWORK_CONFIG=(
    ["mtu"]="9000"  # Jumbo frames for LAN
    ["tcp_congestion"]="bbr"
    ["net_core_rmem_max"]="134217728"
    ["net_core_wmem_max"]="134217728"
    ["net_ipv4_tcp_rmem"]="4096 87380 134217728"
    ["net_ipv4_tcp_wmem"]="4096 65536 134217728"
    ["net_core_netdev_max_backlog"]="30000"
    ["net_ipv4_tcp_timestamps"]="1"
    ["net_ipv4_tcp_sack"]="1"
)

# Configure network optimization
configure_network_optimization() {
    echo "🚀 Configuring network optimization for gaming..."
    
    # Apply kernel parameters
    for param in "${!NETWORK_CONFIG[@]}"; do
        if [[ $param == "mtu" ]]; then
            # Set MTU on gaming interfaces
            for interface in $(ip link show | grep -E "game|eth" | cut -d: -f2); do
                ip link set dev "$interface" mtu "${NETWORK_CONFIG[$param]}" 2>/dev/null || true
            done
        elif [[ $param == "tcp_congestion" ]]; then
            echo "net.ipv4.tcp_congestion_control=${NETWORK_CONFIG[$param]}" >> /etc/sysctl.d/99-gaming.conf
        else
            echo "${param//_/.}=${NETWORK_CONFIG[$param]}" >> /etc/sysctl.d/99-gaming.conf
        fi
    done
    
    # Apply sysctl settings
    sysctl -p /etc/sysctl.d/99-gaming.conf
    
    echo "✅ Network optimization completed"
}

# Setup traffic shaping for gaming
setup_traffic_shaping() {
    local interface="${1:-eth0}"
    
    echo "📊 Setting up traffic shaping on $interface..."
    
    # Clear existing qdiscs
    tc qdisc del dev "$interface" root 2>/dev/null || true
    
    # Setup HTB (Hierarchical Token Bucket)
    tc qdisc add dev "$interface" root handle 1: htb default 30
    tc class add dev "$interface" parent 1: classid 1:1 htb rate 10gbit
    
    # Gaming traffic (highest priority)
    tc class add dev "$interface" parent 1:1 classid 1:10 htb rate 8gbit ceil 10gbit prio 1
    tc qdisc add dev "$interface" parent 1:10 handle 10: sfq perturb 10
    
    # General traffic
    tc class add dev "$interface" parent 1:1 classid 1:30 htb rate 2gbit ceil 5gbit prio 3
    tc qdisc add dev "$interface" parent 1:30 handle 30: sfq perturb 10
    
    # Mark gaming packets
    iptables -t mangle -A POSTROUTING -p udp --dport 7000:8000 -j MARK --set-mark 10
    iptables -t mangle -A POSTROUTING -p tcp --dport 7000:8000 -j MARK --set-mark 10
    
    # Filter packets to classes
    tc filter add dev "$interface" parent 1:0 prio 1 handle 10 fw flowid 1:10
    
    echo "✅ Traffic shaping configured"
}

# Configure DDoS protection
configure_ddos_protection() {
    echo "🛡️  Configuring DDoS protection..."
    
    # Connection tracking limits
    cat >> /etc/sysctl.d/99-gaming.conf <<EOF
# DDoS Protection
net.netfilter.nf_conntrack_max = 2000000
net.netfilter.nf_conntrack_tcp_timeout_established = 300
net.netfilter.nf_conntrack_tcp_timeout_time_wait = 60
net.netfilter.nf_conntrack_tcp_timeout_close_wait = 60
net.netfilter.nf_conntrack_udp_timeout = 30
net.netfilter.nf_conntrack_udp_timeout_stream = 60
EOF
    
    # Rate limiting rules
    iptables -N GAMING_RATELIMIT 2>/dev/null || true
    iptables -F GAMING_RATELIMIT
    
    # Limit new connections per IP
    iptables -A GAMING_RATELIMIT -m recent --name gaming_limit --rcheck --seconds 60 --hitcount 100 -j DROP
    iptables -A GAMING_RATELIMIT -m recent --name gaming_limit --set -j RETURN
    
    # Apply to gaming ports
    iptables -A INPUT -p udp --dport 7000:8000 -j GAMING_RATELIMIT
    iptables -A INPUT -p tcp --dport 7000:8000 -j GAMING_RATELIMIT
    
    # SYN flood protection
    iptables -A INPUT -p tcp --syn -m limit --limit 1000/s --limit-burst 1500 -j ACCEPT
    iptables -A INPUT -p tcp --syn -j DROP
    
    echo "✅ DDoS protection configured"
}

# Monitor network performance
monitor_network_performance() {
    local duration="${1:-60}"
    local interface="${2:-eth0}"
    
    echo "📊 Monitoring network performance for ${duration}s..."
    
    # Create monitoring log
    local log_file="/var/log/gaming_network_$(date +%Y%m%d_%H%M%S).log"
    
    # Start monitoring in background
    (
        while true; do
            echo "$(date): Network Statistics" >> "$log_file"
            
            # Interface statistics
            ip -s link show "$interface" >> "$log_file"
            
            # Connection tracking
            conntrack -L -p udp --dport 7000:8000 2>/dev/null | wc -l | \
                xargs -I {} echo "Active gaming connections: {}" >> "$log_file"
            
            # Packet loss and latency (if mtr is available)
            if command -v mtr &> /dev/null; then
                mtr -r -c 10 -n 8.8.8.8 >> "$log_file"
            fi
            
            echo "---" >> "$log_file"
            sleep 10
        done
    ) &
    
    local monitor_pid=$!
    sleep "$duration"
    kill $monitor_pid 2>/dev/null
    
    echo "📊 Network monitoring completed: $log_file"
}

# Setup game server firewall rules
setup_gaming_firewall() {
    echo "🔥 Setting up gaming firewall rules..."
    
    # Create gaming chain
    iptables -N GAMING 2>/dev/null || true
    iptables -F GAMING
    
    # Allow established connections
    iptables -A GAMING -m state --state ESTABLISHED,RELATED -j ACCEPT
    
    # Game server ports (customizable per game)
    declare -A GAME_PORTS=(
        ["minecraft"]="25565/tcp"
        ["csgo"]="27015/tcp,27015/udp"
        ["rust"]="28015/tcp,28015/udp"
        ["valheim"]="2456-2458/tcp,2456-2458/udp"
        ["ark"]="7777-7778/tcp,7777-7778/udp,27015/udp"
    )
    
    # Open ports for each game
    for game in "${!GAME_PORTS[@]}"; do
        IFS=',' read -ra ports <<< "${GAME_PORTS[$game]}"
        for port in "${ports[@]}"; do
            if [[ $port == *"tcp" ]]; then
                iptables -A GAMING -p tcp --dport "${port%/*}" -j ACCEPT
            elif [[ $port == *"udp" ]]; then
                iptables -A GAMING -p udp --dport "${port%/*}" -j ACCEPT
            fi
        done
    done
    
    # Apply gaming chain to INPUT
    iptables -A INPUT -j GAMING
    
    # Save rules
    if command -v netfilter-persistent &> /dev/null; then
        netfilter-persistent save
    fi
    
    echo "✅ Gaming firewall configured"
}

# Configure latency optimization
configure_latency_optimization() {
    echo "⚡ Configuring latency optimization..."
    
    # CPU frequency scaling
    if [ -f /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor ]; then
        for cpu in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do
            echo "performance" > "$cpu"
        done
    fi
    
    # Interrupt affinity
    # Bind network interrupts to specific CPUs
    local game_cpus="0-3"  # First 4 CPUs for game interrupts
    
    for irq in $(grep -E "eth|game" /proc/interrupts | cut -d: -f1); do
        echo "$game_cpus" > "/proc/irq/$irq/smp_affinity_list" 2>/dev/null || true
    done
    
    # Disable CPU throttling
    if command -v cpupower &> /dev/null; then
        cpupower frequency-set -g performance
    fi
    
    echo "✅ Latency optimization configured"
}

# Generate network performance report
generate_network_report() {
    local output_file="${1:-/tmp/gaming_network_report.txt}"
    
    echo "📊 Generating network performance report..."
    
    cat > "$output_file" <<EOF
Gaming Network Performance Report
================================
Generated: $(date)
Hostname: $(hostname)

Network Interfaces:
$(ip -br link show)

Routing Table:
$(ip route show)

Connection Statistics:
$(ss -s)

Gaming Port Status:
$(ss -tuln | grep -E ":(7[0-9]{3}|8000)")

Firewall Rules (Gaming):
$(iptables -L GAMING -n -v 2>/dev/null || echo "No gaming rules configured")

Network Optimization:
$(sysctl -a 2>/dev/null | grep -E "tcp_congestion|rmem|wmem|backlog")

Traffic Control:
$(tc -s qdisc show)

Performance Metrics:
- MTU: $(ip link show | grep mtu | head -1 | grep -oP 'mtu \K\d+')
- Congestion Control: $(sysctl net.ipv4.tcp_congestion_control | awk '{print $3}')
- Connection Tracking: $(sysctl net.netfilter.nf_conntrack_count 2>/dev/null || echo "N/A")

EOF
    
    echo "✅ Report generated: $output_file"
}

# Main execution
main() {
    case "${1:-help}" in
        "optimize")
            configure_network_optimization
            configure_latency_optimization
            ;;
        "traffic-shape")
            local interface="${2:-eth0}"
            setup_traffic_shaping "$interface"
            ;;
        "ddos-protect")
            configure_ddos_protection
            ;;
        "firewall")
            setup_gaming_firewall
            ;;
        "monitor")
            local duration="${2:-60}"
            local interface="${3:-eth0}"
            monitor_network_performance "$duration" "$interface"
            ;;
        "report")
            local output="${2:-/tmp/gaming_network_report.txt}"
            generate_network_report "$output"
            ;;
        "full-setup")
            echo "🎮 Performing full gaming network setup..."
            configure_network_optimization
            configure_latency_optimization
            setup_traffic_shaping "eth0"
            configure_ddos_protection
            setup_gaming_firewall
            generate_network_report
            echo "✅ Full gaming network setup completed!"
            ;;
        *)
            echo "Usage: $0 {optimize|traffic-shape|ddos-protect|firewall|monitor|report|full-setup}"
            echo ""
            echo "Commands:"
            echo "  optimize      - Apply network and latency optimizations"
            echo "  traffic-shape - Setup QoS traffic shaping"
            echo "  ddos-protect  - Configure DDoS protection"
            echo "  firewall      - Setup gaming firewall rules"
            echo "  monitor       - Monitor network performance"
            echo "  report        - Generate performance report"
            echo "  full-setup    - Perform complete setup"
            exit 1
            ;;
    esac
}

# Execute if run directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi

# Kubernetes Gaming Infrastructure Deployment
apiVersion: v1
kind: Namespace
metadata:
  name: game-servers
  labels:
    name: game-servers
    monitoring: enabled
---
apiVersion: agones.dev/v1
kind: Fleet
metadata:
  name: dedicated-game-fleet
  namespace: game-servers
spec:
  replicas: 50
  scheduling: Packed
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
  template:
    metadata:
      labels:
        game: "multiplayer"
        type: "dedicated"
    spec:
      container:
        name: game-server
        image: gcr.io/project/game-server:latest
        resources:
          requests:
            memory: "2Gi"
            cpu: "1000m"
          limits:
            memory: "4Gi"
            cpu: "2000m"
        env:
        - name: TICKRATE
          value: "64"
        - name: MAX_PLAYERS
          value: "64"
        - name: GAME_MODE
          value: "all"
        - name: ANTI_CHEAT
          value: "enabled"
      ports:
      - name: game
        containerPort: 7777
        protocol: UDP
        portPolicy: Dynamic
      - name: query
        containerPort: 27015
        protocol: UDP
        portPolicy: Static
      health:
        disabled: false
        initialDelaySeconds: 30
        periodSeconds: 10
        failureThreshold: 3
      sdkServer:
        logLevel: Info
        grpcPort: 9357
        httpPort: 9358
---
apiVersion: v1
kind: Service
metadata:
  name: game-server-metrics
  namespace: game-servers
  labels:
    app: game-server-metrics
spec:
  selector:
    game: multiplayer
  ports:
  - name: metrics
    port: 9090
    targetPort: 9090
    protocol: TCP
  type: ClusterIP
---
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: game-server-metrics
  namespace: game-servers
spec:
  selector:
    matchLabels:
      app: game-server-metrics
  endpoints:
  - port: metrics
    interval: 30s
    path: /metrics
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: game-matchmaker-hpa
  namespace: game-servers
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: game-matchmaker
  minReplicas: 3
  maxReplicas: 50
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 70
  - type: Pods
    pods:
      metric:
        name: matchmaking_queue_size
      target:
        type: AverageValue
        averageValue: "100"
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
      - type: Percent
        value: 100
        periodSeconds: 15
      - type: Pods
        value: 5
        periodSeconds: 15
      selectPolicy: Max
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: game-server-network-policy
  namespace: game-servers
spec:
  podSelector:
    matchLabels:
      game: multiplayer
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: game-matchmaker
    - namespaceSelector:
        matchLabels:
          name: monitoring
    ports:
    - protocol: TCP
      port: 9090
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
    ports:
    - protocol: UDP
      port: 7777
    - protocol: UDP
      port: 27015
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: game-backend
    ports:
    - protocol: TCP
      port: 8080
  - to:
    - namespaceSelector:
        matchLabels:
          name: kube-system
    ports:
    - protocol: TCP
      port: 53
    - protocol: UDP
      port: 53