class CAMTable:
    def __init__(self, max_entries=8192):
        self.table = {}  # MAC -> (port, timestamp)
        self.max_entries = max_entries
        self.aging_time = 300  # 5分
    
    def learn(self, mac_address, port):
        """MACアドレスを学習"""
        current_time = time.time()
        
        # テーブルが満杯の場合、古いエントリを削除
        if len(self.table) >= self.max_entries:
            self.age_out_entries()
        
        self.table[mac_address] = (port, current_time)
    
    def lookup(self, mac_address):
        """MACアドレスから出力ポートを検索"""
        if mac_address in self.table:
            port, timestamp = self.table[mac_address]
            if time.time() - timestamp < self.aging_time:
                return port
            else:
                # エージアウト
                del self.table[mac_address]
        return None  # 不明な場合はフラッディング

class SecurePort:
    def __init__(self, port_number, max_mac_addresses=1):
        self.port_number = port_number
        self.max_mac_addresses = max_mac_addresses
        self.allowed_macs = set()
        self.sticky_macs = set()  # 永続的に記憶
        self.violation_count = 0
    
    def check_mac(self, mac_address):
        """MACアドレスの正当性をチェック"""
        if mac_address in self.allowed_macs:
            return True
        
        if len(self.allowed_macs) < self.max_mac_addresses:
            self.allowed_macs.add(mac_address)
            return True
        
        # 違反検出
        self.violation_count += 1
        return False
    
    def violation_action(self):
        """違反時のアクション"""
        if self.violation_count > 10:
            return "shutdown"  # ポートを無効化
        elif self.violation_count > 5:
            return "restrict"  # 不正なフレームを破棄
        else:
            return "protect"   # ログのみ

class LinkAggregation:
    def __init__(self, member_links):
        self.member_links = member_links
        self.hash_algorithm = 'L3_L4'  # デフォルト
    
    def select_link(self, packet):
        """パケットに基づいてリンクを選択"""
        if self.hash_algorithm == 'L2':
            # MACアドレスベース
            hash_input = packet.src_mac + packet.dst_mac
        elif self.hash_algorithm == 'L3':
            # IPアドレスベース
            hash_input = packet.src_ip + packet.dst_ip
        elif self.hash_algorithm == 'L3_L4':
            # IP + ポート番号
            hash_input = (packet.src_ip + packet.dst_ip + 
                         packet.src_port + packet.dst_port)
        
        hash_value = hash(hash_input)
        link_index = hash_value % len(self.member_links)
        return self.member_links[link_index]

class LAGMonitor:
    def __init__(self, lag_interface):
        self.lag_interface = lag_interface
        self.stats = defaultdict(lambda: {'bytes': 0, 'packets': 0})
    
    def collect_stats(self):
        """各メンバーリンクの使用状況を収集"""
        for link in self.lag_interface.member_links:
            stats = link.get_statistics()
            self.stats[link.name]['bytes'] = stats.tx_bytes
            self.stats[link.name]['packets'] = stats.tx_packets
    
    def calculate_imbalance(self):
        """負荷分散の偏りを計算"""
        total_bytes = sum(s['bytes'] for s in self.stats.values())
        link_count = len(self.stats)
        ideal_bytes = total_bytes / link_count
        
        imbalance = 0
        for link_stats in self.stats.values():
            deviation = abs(link_stats['bytes'] - ideal_bytes)
            imbalance += deviation / ideal_bytes
        
        return imbalance / link_count  # 0が理想、1.0以上は問題