from typing import Dict, List, Any, Optional, Set, Tuple
from dataclasses import dataclass, field
from enum import Enum
import ipaddress
import json
import yaml
import asyncio
import logging
from datetime import datetime, timedelta

class VLANType(Enum):
    DATA = "data"
    VOICE = "voice"
    MANAGEMENT = "management"
    STORAGE = "storage"
    IOT = "iot"
    GUEST = "guest"
    DMZ = "dmz"
    QUARANTINE = "quarantine"

class TrunkingProtocol(Enum):
    DOT1Q = "802.1q"
    ISL = "isl"
    QinQ = "802.1ad"

@dataclass
class VLANConfiguration:
    vlan_id: int
    name: str
    vlan_type: VLANType
    description: str
    subnet: Optional[ipaddress.IPv4Network] = None
    gateway: Optional[ipaddress.IPv4Address] = None
    dhcp_pool: Optional[Tuple[ipaddress.IPv4Address, ipaddress.IPv4Address]] = None
    dns_servers: List[ipaddress.IPv4Address] = field(default_factory=list)
    ntp_servers: List[ipaddress.IPv4Address] = field(default_factory=list)
    domain_name: Optional[str] = None
    lease_time: int = 86400  # 24 hours
    enabled: bool = True
    created_at: datetime = field(default_factory=datetime.now)
    modified_at: datetime = field(default_factory=datetime.now)
    tags: List[str] = field(default_factory=list)
    security_policies: List[str] = field(default_factory=list)
    qos_profile: Optional[str] = None
    isolation_level: str = "standard"  # standard, strict, isolated

@dataclass
class InterfaceConfiguration:
    interface_name: str
    switch_name: str
    mode: str  # access, trunk, hybrid
    access_vlan: Optional[int] = None
    allowed_vlans: Set[int] = field(default_factory=set)
    native_vlan: Optional[int] = None
    trunking_protocol: TrunkingProtocol = TrunkingProtocol.DOT1Q
    port_security: bool = False
    max_mac_addresses: int = 1
    storm_control: Dict[str, int] = field(default_factory=dict)
    spanning_tree_portfast: bool = False
    spanning_tree_bpduguard: bool = False
    voice_vlan: Optional[int] = None
    power_over_ethernet: bool = False
    poe_priority: str = "low"
    description: str = ""
    enabled: bool = True

class EnterpriseVLANManager:
    def __init__(self, config_file: str = None):
        self.vlans = {}
        self.interfaces = {}
        self.switches = {}
        self.vlan_templates = {}
        self.auto_provisioning = VLANAutoProvisioning()
        self.compliance_checker = VLANComplianceChecker()
        self.conflict_resolver = VLANConflictResolver()
        self.monitoring = VLANMonitoring()
        self.logger = self._setup_logging()
        
        if config_file:
            self.load_configuration(config_file)
    
    def _setup_logging(self):
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('vlan_manager.log'),
                logging.StreamHandler()
            ]
        )
        return logging.getLogger(__name__)
    
    def create_vlan(self, vlan_config: VLANConfiguration) -> bool:
        """Create new VLAN with comprehensive validation"""
        try:
            # Validate VLAN ID availability
            if vlan_config.vlan_id in self.vlans:
                raise ValueError(f"VLAN {vlan_config.vlan_id} already exists")
            
            # Validate VLAN ID range
            if not (1 <= vlan_config.vlan_id <= 4094):
                raise ValueError(f"Invalid VLAN ID: {vlan_config.vlan_id}")
            
            # Check for subnet conflicts
            if vlan_config.subnet:
                conflicts = self._check_subnet_conflicts(vlan_config.subnet)
                if conflicts:
                    raise ValueError(f"Subnet conflicts detected: {conflicts}")
            
            # Validate security policies
            self._validate_security_policies(vlan_config.security_policies)
            
            # Apply VLAN template if specified
            if vlan_config.vlan_type in self.vlan_templates:
                vlan_config = self._apply_vlan_template(vlan_config)
            
            # Store VLAN configuration
            self.vlans[vlan_config.vlan_id] = vlan_config
            
            # Deploy to switches
            deployment_result = self._deploy_vlan_to_switches(vlan_config)
            
            if deployment_result['success']:
                self.logger.info(f"Successfully created VLAN {vlan_config.vlan_id}: {vlan_config.name}")
                return True
            else:
                # Rollback on deployment failure
                del self.vlans[vlan_config.vlan_id]
                raise RuntimeError(f"VLAN deployment failed: {deployment_result['error']}")
                
        except Exception as e:
            self.logger.error(f"Failed to create VLAN {vlan_config.vlan_id}: {e}")
            return False
    
    def configure_interface(self, interface_config: InterfaceConfiguration) -> bool:
        """Configure interface with advanced validation and optimization"""
        try:
            interface_key = f"{interface_config.switch_name}:{interface_config.interface_name}"
            
            # Validate interface configuration
            validation_result = self._validate_interface_config(interface_config)
            if not validation_result['valid']:
                raise ValueError(f"Invalid interface configuration: {validation_result['errors']}")
            
            # Check for conflicts
            conflicts = self._check_interface_conflicts(interface_config)
            if conflicts:
                resolved_config = self.conflict_resolver.resolve_conflicts(
                    interface_config, conflicts
                )
                if resolved_config:
                    interface_config = resolved_config
                else:
                    raise ValueError(f"Unresolvable interface conflicts: {conflicts}")
            
            # Optimize configuration
            optimized_config = self._optimize_interface_config(interface_config)
            
            # Store configuration
            self.interfaces[interface_key] = optimized_config
            
            # Deploy to switch
            deployment_result = self._deploy_interface_config(optimized_config)
            
            if deployment_result['success']:
                self.logger.info(f"Successfully configured interface {interface_key}")
                return True
            else:
                # Rollback
                if interface_key in self.interfaces:
                    del self.interfaces[interface_key]
                raise RuntimeError(f"Interface deployment failed: {deployment_result['error']}")
                
        except Exception as e:
            self.logger.error(f"Failed to configure interface {interface_key}: {e}")
            return False
    
    def implement_vlan_strategy(self, strategy_config: Dict[str, Any]) -> Dict[str, Any]:
        """Implement comprehensive VLAN strategy"""
        implementation_result = {
            'strategy_id': strategy_config.get('id', 'default'),
            'start_time': datetime.now(),
            'vlans_created': [],
            'interfaces_configured': [],
            'errors': [],
            'warnings': [],
            'rollback_plan': []
        }
        
        try:
            # Phase 1: Validate strategy
            validation_result = self._validate_vlan_strategy(strategy_config)
            if not validation_result['valid']:
                implementation_result['errors'].extend(validation_result['errors'])
                return implementation_result
            
            # Phase 2: Create VLANs
            for vlan_spec in strategy_config.get('vlans', []):
                try:
                    vlan_config = self._create_vlan_from_spec(vlan_spec)
                    if self.create_vlan(vlan_config):
                        implementation_result['vlans_created'].append(vlan_config.vlan_id)
                        implementation_result['rollback_plan'].append({
                            'action': 'delete_vlan',
                            'vlan_id': vlan_config.vlan_id
                        })
                except Exception as e:
                    implementation_result['errors'].append(f"VLAN creation failed: {e}")
            
            # Phase 3: Configure interfaces
            for interface_spec in strategy_config.get('interfaces', []):
                try:
                    interface_config = self._create_interface_from_spec(interface_spec)
                    if self.configure_interface(interface_config):
                        interface_key = f"{interface_config.switch_name}:{interface_config.interface_name}"
                        implementation_result['interfaces_configured'].append(interface_key)
                        implementation_result['rollback_plan'].append({
                            'action': 'restore_interface',
                            'interface_key': interface_key,
                            'original_config': self._get_original_interface_config(interface_key)
                        })
                except Exception as e:
                    implementation_result['errors'].append(f"Interface configuration failed: {e}")
            
            # Phase 4: Implement inter-VLAN routing
            if strategy_config.get('inter_vlan_routing'):
                routing_result = self._implement_inter_vlan_routing(
                    strategy_config['inter_vlan_routing']
                )
                if not routing_result['success']:
                    implementation_result['errors'].extend(routing_result['errors'])
            
            # Phase 5: Apply security policies
            if strategy_config.get('security_policies'):
                security_result = self._apply_security_policies(
                    strategy_config['security_policies']
                )
                if not security_result['success']:
                    implementation_result['warnings'].extend(security_result['warnings'])
            
            implementation_result['success'] = len(implementation_result['errors']) == 0
            implementation_result['end_time'] = datetime.now()
            implementation_result['duration'] = (
                implementation_result['end_time'] - implementation_result['start_time']
            ).total_seconds()
            
        except Exception as e:
            implementation_result['errors'].append(f"Strategy implementation failed: {e}")
            # Execute rollback
            self._execute_rollback(implementation_result['rollback_plan'])
        
        return implementation_result
    
    def _validate_vlan_strategy(self, strategy_config: Dict[str, Any]) -> Dict[str, Any]:
        """Validate VLAN strategy configuration"""
        validation_result = {
            'valid': True,
            'errors': [],
            'warnings': []
        }
        
        # Check for VLAN ID conflicts
        vlan_ids = set()
        for vlan_spec in strategy_config.get('vlans', []):
            vlan_id = vlan_spec.get('vlan_id')
            if vlan_id in vlan_ids:
                validation_result['errors'].append(f"Duplicate VLAN ID: {vlan_id}")
            elif vlan_id in self.vlans:
                validation_result['errors'].append(f"VLAN ID {vlan_id} already exists")
            else:
                vlan_ids.add(vlan_id)
        
        # Check subnet allocations
        subnets = []
        for vlan_spec in strategy_config.get('vlans', []):
            if 'subnet' in vlan_spec:
                subnet = ipaddress.IPv4Network(vlan_spec['subnet'])
                for existing_subnet in subnets:
                    if subnet.overlaps(existing_subnet):
                        validation_result['errors'].append(
                            f"Overlapping subnets: {subnet} and {existing_subnet}"
                        )
                subnets.append(subnet)
        
        # Validate interface assignments
        interface_assignments = {}
        for interface_spec in strategy_config.get('interfaces', []):
            switch_name = interface_spec.get('switch_name')
            interface_name = interface_spec.get('interface_name')
            key = f"{switch_name}:{interface_name}"
            
            if key in interface_assignments:
                validation_result['errors'].append(f"Duplicate interface assignment: {key}")
            else:
                interface_assignments[key] = interface_spec
        
        validation_result['valid'] = len(validation_result['errors']) == 0
        return validation_result

class VLANAutoProvisioning:
    """Automated VLAN provisioning based on policies and discovery"""
    
    def __init__(self):
        self.provisioning_policies = {}
        self.device_classifier = DeviceClassifier()
        self.policy_engine = ProvisioningPolicyEngine()
        
    def auto_provision_device(self, device_info: Dict[str, Any]) -> Dict[str, Any]:
        """Automatically provision VLAN for new device"""
        provisioning_result = {
            'device_id': device_info.get('mac_address'),
            'recommended_vlan': None,
            'confidence_score': 0,
            'policies_applied': [],
            'actions_taken': []
        }
        
        # Classify device
        device_classification = self.device_classifier.classify_device(device_info)
        provisioning_result['device_classification'] = device_classification
        
        # Apply provisioning policies
        for policy_name, policy in self.provisioning_policies.items():
            if self._device_matches_policy(device_info, device_classification, policy):
                policy_result = self.policy_engine.apply_policy(
                    device_info, device_classification, policy
                )
                
                provisioning_result['policies_applied'].append(policy_name)
                
                if policy_result['vlan_assignment']:
                    provisioning_result['recommended_vlan'] = policy_result['vlan_assignment']
                    provisioning_result['confidence_score'] = policy_result['confidence']
                
                provisioning_result['actions_taken'].extend(policy_result['actions'])
        
        return provisioning_result
    
    def create_dynamic_vlan(self, requirements: Dict[str, Any]) -> VLANConfiguration:
        """Create dynamic VLAN based on requirements"""
        # Find available VLAN ID
        vlan_id = self._find_available_vlan_id(requirements.get('vlan_range', (100, 999)))
        
        # Allocate subnet
        subnet = self._allocate_subnet(requirements.get('subnet_size', 24))
        
        # Create VLAN configuration
        vlan_config = VLANConfiguration(
            vlan_id=vlan_id,
            name=requirements.get('name', f"Dynamic-VLAN-{vlan_id}"),
            vlan_type=VLANType(requirements.get('type', 'data')),
            description=requirements.get('description', 'Auto-provisioned VLAN'),
            subnet=subnet,
            gateway=subnet.network_address + 1,
            dhcp_pool=(subnet.network_address + 10, subnet.broadcast_address - 1),
            dns_servers=[ipaddress.IPv4Address(dns) for dns in requirements.get('dns_servers', [])],
            domain_name=requirements.get('domain_name'),
            lease_time=requirements.get('lease_time', 86400),
            security_policies=requirements.get('security_policies', []),
            qos_profile=requirements.get('qos_profile'),
            isolation_level=requirements.get('isolation_level', 'standard'),
            tags=['auto-provisioned'] + requirements.get('tags', [])
        )
        
        return vlan_config

class NetworkVirtualizationEngine:
    """Advanced network virtualization using overlay technologies"""
    
    def __init__(self):
        self.overlay_networks = {}
        self.vxlan_manager = VXLANManager()
        self.nvgre_manager = NVGREManager()
        self.sdn_controller = SDNController()
        self.tenant_manager = TenantManager()
        
    def create_overlay_network(self, overlay_config: Dict[str, Any]) -> Dict[str, Any]:
        """Create overlay network with specified technology"""
        overlay_type = overlay_config.get('type', 'vxlan')
        
        if overlay_type == 'vxlan':
            return self._create_vxlan_overlay(overlay_config)
        elif overlay_type == 'nvgre':
            return self._create_nvgre_overlay(overlay_config)
        elif overlay_type == 'geneve':
            return self._create_geneve_overlay(overlay_config)
        else:
            raise ValueError(f"Unsupported overlay type: {overlay_type}")
    
    def _create_vxlan_overlay(self, config: Dict[str, Any]) -> Dict[str, Any]:
        """Create VXLAN overlay network"""
        vxlan_config = {
            'vni': config.get('vni', self._allocate_vni()),
            'multicast_group': config.get('multicast_group'),
            'vtep_endpoints': config.get('vtep_endpoints', []),
            'tenant_id': config.get('tenant_id'),
            'vlan_mapping': config.get('vlan_mapping', {}),
            'flood_mode': config.get('flood_mode', 'multicast'),
            'learning_mode': config.get('learning_mode', 'data_plane'),
            'encapsulation': 'vxlan'
        }
        
        # Configure VTEP endpoints
        vtep_results = []
        for vtep_config in vxlan_config['vtep_endpoints']:
            vtep_result = self.vxlan_manager.configure_vtep(vtep_config)
            vtep_results.append(vtep_result)
        
        # Create VXLAN tunnel
        tunnel_result = self.vxlan_manager.create_vxlan_tunnel(vxlan_config)
        
        # Configure forwarding tables
        forwarding_result = self.vxlan_manager.configure_forwarding(vxlan_config)
        
        overlay_result = {
            'overlay_id': config.get('name', f"vxlan-{vxlan_config['vni']}"),
            'type': 'vxlan',
            'vni': vxlan_config['vni'],
            'vtep_results': vtep_results,
            'tunnel_result': tunnel_result,
            'forwarding_result': forwarding_result,
            'success': all([
                all(r['success'] for r in vtep_results),
                tunnel_result['success'],
                forwarding_result['success']
            ])
        }
        
        if overlay_result['success']:
            self.overlay_networks[overlay_result['overlay_id']] = vxlan_config
        
        return overlay_result

class VXLANManager:
    """VXLAN overlay network management"""
    
    def __init__(self):
        self.vteps = {}
        self.vxlan_tunnels = {}
        self.vni_allocator = VNIAllocator()
        
    def configure_vtep(self, vtep_config: Dict[str, Any]) -> Dict[str, Any]:
        """Configure VXLAN Tunnel Endpoint"""
        vtep_result = {
            'vtep_id': vtep_config['vtep_id'],
            'ip_address': vtep_config['ip_address'],
            'configuration_commands': [],
            'success': False
        }
        
        try:
            # Generate VTEP configuration
            config_commands = self._generate_vtep_config(vtep_config)
            vtep_result['configuration_commands'] = config_commands
            
            # Apply configuration to device
            deployment_result = self._deploy_vtep_config(
                vtep_config['device_id'], config_commands
            )
            
            if deployment_result['success']:
                self.vteps[vtep_config['vtep_id']] = vtep_config
                vtep_result['success'] = True
            else:
                vtep_result['error'] = deployment_result['error']
                
        except Exception as e:
            vtep_result['error'] = str(e)
        
        return vtep_result
    
    def _generate_vtep_config(self, vtep_config: Dict[str, Any]) -> List[str]:
        """Generate VTEP configuration commands"""
        commands = []
        
        # Configure VTEP interface
        commands.extend([
            f"interface nve1",
            f" no shutdown",
            f" source-interface loopback{vtep_config.get('loopback_id', 0)}",
            f" host-reachability protocol bgp"
        ])
        
        # Configure VXLAN VNIs
        for vni in vtep_config.get('vnis', []):
            commands.extend([
                f" member vni {vni}",
                f"  ingress-replication protocol bgp"
            ])
        
        # Configure EVPN
        if vtep_config.get('evpn_enabled', True):
            commands.extend([
                f"router bgp {vtep_config.get('bgp_asn', 65000)}",
                f" address-family l2vpn evpn",
                f"  advertise-all-vni"
            ])
        
        return commands
    
    def create_vxlan_tunnel(self, vxlan_config: Dict[str, Any]) -> Dict[str, Any]:
        """Create VXLAN tunnel between VTEPs"""
        tunnel_result = {
            'vni': vxlan_config['vni'],
            'tunnel_endpoints': [],
            'success': False
        }
        
        try:
            # Create tunnel configuration for each VTEP pair
            vtep_endpoints = vxlan_config['vtep_endpoints']
            
            for i, vtep1 in enumerate(vtep_endpoints):
                for j, vtep2 in enumerate(vtep_endpoints[i+1:], i+1):
                    tunnel_config = self._create_tunnel_config(
                        vtep1, vtep2, vxlan_config['vni']
                    )
                    
                    # Deploy tunnel configuration
                    tunnel_deployment = self._deploy_tunnel_config(tunnel_config)
                    tunnel_result['tunnel_endpoints'].append(tunnel_deployment)
            
            tunnel_result['success'] = all(
                t['success'] for t in tunnel_result['tunnel_endpoints']
            )
            
        except Exception as e:
            tunnel_result['error'] = str(e)
        
        return tunnel_result

class SDNController:
    """Software-Defined Networking controller for virtualization"""
    
    def __init__(self):
        self.flow_tables = {}
        self.network_topology = NetworkTopology()
        self.path_calculator = PathCalculator()
        self.policy_engine = SDNPolicyEngine()
        
    def program_virtual_network(self, virtual_network_config: Dict[str, Any]) -> Dict[str, Any]:
        """Program virtual network using SDN flows"""
        programming_result = {
            'virtual_network_id': virtual_network_config['id'],
            'flows_installed': [],
            'policies_applied': [],
            'success': False
        }
        
        try:
            # Calculate optimal paths
            paths = self.path_calculator.calculate_paths(
                virtual_network_config['endpoints']
            )
            
            # Generate flow rules
            flow_rules = self._generate_flow_rules(virtual_network_config, paths)
            
            # Install flow rules
            for flow_rule in flow_rules:
                installation_result = self._install_flow_rule(flow_rule)
                programming_result['flows_installed'].append(installation_result)
            
            # Apply network policies
            for policy in virtual_network_config.get('policies', []):
                policy_result = self.policy_engine.apply_policy(policy)
                programming_result['policies_applied'].append(policy_result)
            
            programming_result['success'] = all([
                all(f['success'] for f in programming_result['flows_installed']),
                all(p['success'] for p in programming_result['policies_applied'])
            ])
            
        except Exception as e:
            programming_result['error'] = str(e)
        
        return programming_result
    
    def _generate_flow_rules(self, network_config: Dict[str, Any], 
                           paths: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """Generate OpenFlow rules for virtual network"""
        flow_rules = []
        
        for path in paths:
            # Forward direction flows
            forward_flows = self._create_path_flows(
                path['nodes'], 
                network_config['forward_match'],
                network_config['forward_actions']
            )
            flow_rules.extend(forward_flows)
            
            # Reverse direction flows
            reverse_flows = self._create_path_flows(
                list(reversed(path['nodes'])),
                network_config['reverse_match'],
                network_config['reverse_actions']
            )
            flow_rules.extend(reverse_flows)
        
        return flow_rules

class TenantManager:
    """Multi-tenant network virtualization management"""
    
    def __init__(self):
        self.tenants = {}
        self.tenant_networks = {}
        self.resource_allocator = ResourceAllocator()
        self.isolation_enforcer = IsolationEnforcer()
        
    def create_tenant(self, tenant_config: Dict[str, Any]) -> Dict[str, Any]:
        """Create new tenant with isolated resources"""
        tenant_result = {
            'tenant_id': tenant_config['tenant_id'],
            'allocated_resources': {},
            'network_isolation': {},
            'success': False
        }
        
        try:
            # Allocate resources
            resource_allocation = self.resource_allocator.allocate_resources(
                tenant_config['resource_requirements']
            )
            tenant_result['allocated_resources'] = resource_allocation
            
            # Create network isolation
            isolation_config = self.isolation_enforcer.create_isolation(
                tenant_config['tenant_id'],
                resource_allocation
            )
            tenant_result['network_isolation'] = isolation_config
            
            # Store tenant configuration
            self.tenants[tenant_config['tenant_id']] = {
                'config': tenant_config,
                'resources': resource_allocation,
                'isolation': isolation_config,
                'created_at': datetime.now()
            }
            
            tenant_result['success'] = True
            
        except Exception as e:
            tenant_result['error'] = str(e)
        
        return tenant_result
    
    def create_tenant_network(self, tenant_id: str, 
                            network_config: Dict[str, Any]) -> Dict[str, Any]:
        """Create isolated network for tenant"""
        if tenant_id not in self.tenants:
            return {'success': False, 'error': f'Tenant {tenant_id} not found'}
        
        network_result = {
            'tenant_id': tenant_id,
            'network_id': network_config['network_id'],
            'vni': None,
            'subnet': None,
            'success': False
        }
        
        try:
            tenant_info = self.tenants[tenant_id]
            
            # Allocate VNI for tenant network
            vni = self.resource_allocator.allocate_vni(tenant_id)
            network_result['vni'] = vni
            
            # Allocate subnet
            subnet = self.resource_allocator.allocate_subnet(
                tenant_id, network_config.get('subnet_size', 24)
            )
            network_result['subnet'] = str(subnet)
            
            # Create overlay network
            overlay_config = {
                'name': f"{tenant_id}-{network_config['network_id']}",
                'type': 'vxlan',
                'vni': vni,
                'tenant_id': tenant_id,
                'subnet': subnet,
                'isolation_level': tenant_info['config'].get('isolation_level', 'strict')
            }
            
            overlay_result = self._create_tenant_overlay(overlay_config)
            
            if overlay_result['success']:
                # Store network configuration
                network_key = f"{tenant_id}:{network_config['network_id']}"
                self.tenant_networks[network_key] = {
                    'config': network_config,
                    'overlay': overlay_result,
                    'vni': vni,
                    'subnet': subnet,
                    'created_at': datetime.now()
                }
                
                network_result['success'] = True
            else:
                network_result['error'] = overlay_result.get('error', 'Overlay creation failed')
                
        except Exception as e:
            network_result['error'] = str(e)
        
        return network_result

class VLANMonitoring:
    """Advanced VLAN monitoring and analytics"""
    
    def __init__(self):
        self.metrics_collector = VLANMetricsCollector()
        self.performance_analyzer = VLANPerformanceAnalyzer()
        self.security_monitor = VLANSecurityMonitor()
        self.usage_tracker = VLANUsageTracker()
        
    def monitor_vlan_performance(self, vlan_id: int, 
                               time_window: int = 3600) -> Dict[str, Any]:
        """Monitor VLAN performance metrics"""
        performance_data = {
            'vlan_id': vlan_id,
            'time_window': time_window,
            'traffic_stats': {},
            'utilization_metrics': {},
            'performance_issues': [],
            'recommendations': []
        }
        
        # Collect traffic statistics
        performance_data['traffic_stats'] = self.metrics_collector.get_traffic_stats(
            vlan_id, time_window
        )
        
        # Calculate utilization metrics
        performance_data['utilization_metrics'] = self.performance_analyzer.calculate_utilization(
            vlan_id, performance_data['traffic_stats']
        )
        
        # Detect performance issues
        performance_data['performance_issues'] = self.performance_analyzer.detect_issues(
            vlan_id, performance_data['utilization_metrics']
        )
        
        # Generate recommendations
        performance_data['recommendations'] = self.performance_analyzer.generate_recommendations(
            vlan_id, performance_data['performance_issues']
        )
        
        return performance_data
    
    def analyze_vlan_security(self, vlan_id: int) -> Dict[str, Any]:
        """Analyze VLAN security posture"""
        security_analysis = {
            'vlan_id': vlan_id,
            'security_events': [],
            'policy_violations': [],
            'anomalous_traffic': [],
            'risk_score': 0,
            'security_recommendations': []
        }
        
        # Collect security events
        security_analysis['security_events'] = self.security_monitor.get_security_events(vlan_id)
        
        # Check policy violations
        security_analysis['policy_violations'] = self.security_monitor.check_policy_violations(vlan_id)
        
        # Detect anomalous traffic
        security_analysis['anomalous_traffic'] = self.security_monitor.detect_anomalous_traffic(vlan_id)
        
        # Calculate risk score
        security_analysis['risk_score'] = self.security_monitor.calculate_risk_score(
            security_analysis['security_events'],
            security_analysis['policy_violations'],
            security_analysis['anomalous_traffic']
        )
        
        # Generate security recommendations
        security_analysis['security_recommendations'] = self.security_monitor.generate_security_recommendations(
            vlan_id, security_analysis
        )
        
        return security_analysis

class VirtualNetworkOrchestrator:
    """Orchestrate complex virtual network deployments"""
    
    def __init__(self):
        self.vlan_manager = EnterpriseVLANManager()
        self.virtualization_engine = NetworkVirtualizationEngine()
        self.tenant_manager = TenantManager()
        self.policy_engine = NetworkPolicyEngine()
        
    async def deploy_virtual_infrastructure(self, infrastructure_spec: Dict[str, Any]) -> Dict[str, Any]:
        """Deploy complete virtual network infrastructure"""
        deployment_result = {
            'deployment_id': infrastructure_spec.get('id', 'default'),
            'start_time': datetime.now(),
            'tenants_created': [],
            'networks_created': [],
            'policies_applied': [],
            'success': False,
            'rollback_plan': []
        }
        
        try:
            # Phase 1: Create tenants
            for tenant_spec in infrastructure_spec.get('tenants', []):
                tenant_result = self.tenant_manager.create_tenant(tenant_spec)
                if tenant_result['success']:
                    deployment_result['tenants_created'].append(tenant_spec['tenant_id'])
                    deployment_result['rollback_plan'].append({
                        'action': 'delete_tenant',
                        'tenant_id': tenant_spec['tenant_id']
                    })
                else:
                    raise Exception(f"Tenant creation failed: {tenant_result.get('error')}")
            
            # Phase 2: Create virtual networks
            for network_spec in infrastructure_spec.get('networks', []):
                if network_spec.get('type') == 'overlay':
                    network_result = self.virtualization_engine.create_overlay_network(network_spec)
                else:
                    vlan_config = self._convert_spec_to_vlan_config(network_spec)
                    network_result = {'success': self.vlan_manager.create_vlan(vlan_config)}
                
                if network_result['success']:
                    deployment_result['networks_created'].append(network_spec['id'])
                    deployment_result['rollback_plan'].append({
                        'action': 'delete_network',
                        'network_id': network_spec['id'],
                        'network_type': network_spec.get('type', 'vlan')
                    })
                else:
                    raise Exception(f"Network creation failed: {network_result.get('error')}")
            
            # Phase 3: Apply network policies
            for policy_spec in infrastructure_spec.get('policies', []):
                policy_result = self.policy_engine.apply_policy(policy_spec)
                if policy_result['success']:
                    deployment_result['policies_applied'].append(policy_spec['id'])
                    deployment_result['rollback_plan'].append({
                        'action': 'remove_policy',
                        'policy_id': policy_spec['id']
                    })
                else:
                    raise Exception(f"Policy application failed: {policy_result.get('error')}")
            
            deployment_result['success'] = True
            deployment_result['end_time'] = datetime.now()
            deployment_result['duration'] = (
                deployment_result['end_time'] - deployment_result['start_time']
            ).total_seconds()
            
        except Exception as e:
            deployment_result['error'] = str(e)
            # Execute rollback
            await self._execute_rollback(deployment_result['rollback_plan'])
        
        return deployment_result
    
    async def _execute_rollback(self, rollback_plan: List[Dict[str, Any]]):
        """Execute rollback plan in reverse order"""
        for action in reversed(rollback_plan):
            try:
                if action['action'] == 'delete_tenant':
                    self.tenant_manager.delete_tenant(action['tenant_id'])
                elif action['action'] == 'delete_network':
                    if action['network_type'] == 'overlay':
                        self.virtualization_engine.delete_overlay_network(action['network_id'])
                    else:
                        self.vlan_manager.delete_vlan(action['network_id'])
                elif action['action'] == 'remove_policy':
                    self.policy_engine.remove_policy(action['policy_id'])
            except Exception as e:
                # Log rollback failures but continue
                logging.error(f"Rollback action failed: {action}, error: {e}")