import hashlib
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ed25519

class ZeroTrustNode:
    def __init__(self, node_id, private_key):
        self.node_id = node_id
        self.private_key = private_key
        self.public_key = private_key.public_key()
        self.attestation_log = []

    def sign_update(self, model_update_hash):
        # 모델 업데이트에 대한 암호화 서명 생성
        signature = self.private_key.sign(
            model_update_hash.encode(),
            ed25519.Ed25519Signature()
        )
        return signature.hex()

    def generate_attestation(self, update, metadata):
        # 검증 가능한 로그를 위해 업데이트 해시와 메타데이터를 결합
        attestation_data = f"{self.node_id}:{update}:{metadata}"
        attestation_hash = hashlib.sha256(attestation_data.encode()).hexdigest()
        signature = self.sign_update(attestation_hash)
        self.attestation_log.append({
            'timestamp': metadata['timestamp'],
            'hash': attestation_hash,
            'signature': signature
        })
        return {
            'hash': attestation_hash,
            'signature': signature
        }

    def verify_attestation(self, attestation, public_key):
        # 증명이 주장된 노드로부터 왔는지 검증
        try:
            public_key.verify(
                bytes.fromhex(attestation['signature']),
                attestation['hash'].encode()
            )
            return True
        except:
            return False

import random
from collections import defaultdict

class FederatedActiveLearner:
    def __init__(self, model, num_nodes, confidence_threshold=0.7):
        self.model = model
        self.num_nodes = num_nodes
        self.confidence_threshold = confidence_threshold

def compute_uncertainty(self, predictions):
    # 불확실성 측정 지표로 엔트로피 (Entropy) 사용
    entropy = -np.sum(predictions * np.log(predictions + 1e-10), axis=1)
    return entropy

def secure_query_selection(self, node_predictions):
    """
    각 노드는 암호화된 불확실성 점수를 전송합니다.
    서버는 개별 점수를 확인하지 않고 이를 집계합니다.
    """
    # 동형 암호 (Homomorphic Encryption)를 사용한 보안 집계 (Secure Aggregation) 시뮬레이션
    # 실제 구현 시에는 Paillier 또는 유사한 스킴을 사용합니다.
    aggregated_uncertainties = defaultdict(list)
    for node_id, predictions in node_predictions.items():
        uncertainties = self.compute_uncertainty(predictions)
        for idx, unc in enumerate(uncertainties):
            aggregated_uncertainties[idx].append(unc)

    # 평균 불확실성이 가장 높은 샘플 선택
    mean_uncertainties = {idx: np.mean(uncs) for idx, uncs in aggregated_uncertainties.items()}

    # 불확실성이 임계값 (Threshold)을 초과하는 경우에만 쿼리 수행
    query_candidates = [idx for idx, unc in mean_uncertainties.items() if unc > self.confidence_threshold]

    # 가장 불확실성이 높은 상위 k개 샘플 선택
    k = min(5, len(query_candidates))
    selected = sorted(query_candidates, key=lambda x: mean_uncertainties[x], reverse=True)[:k]

    self.query_history.append({
        'round': len(self.query_history) + 1,
        'selected_indices': selected,
        'mean_uncertainties': {idx: mean_uncertainties[idx] for idx in selected}
    })
    return selected

def update_model(self, new_labels, local_updates):
    # 차분 프라이버시 (Differential Privacy, DP)를 적용한 연합 평균 (Federated Averaging)
    total_weight = 0
    aggregated_gradients = None
    for node_id, gradient in local_updates.items():
        weight = len(new_labels[node_id])
        if aggregated_gradients is None:
            aggregated_gradients = gradient * weight
        else:
            aggregated_gradients += gradient * weight
        total_weight += weight
    
    aggregated_gradients /= total_weight

    # 집계된 업데이트에 DP 적용
    dp_epsilon = 1.0
    dp_delta = 1e-5
    noise_std = (1.0 * np.

def compute_cultural_uncertainty ( self , predictions , sample_indices ):
    base_uncertainty = self . compute_uncertainty ( predictions )
    # 불확실성 점수에 문화적 가중치 적용
    weighted_uncertainty = base_uncertainty . copy ()
    for idx , sample_idx in enumerate ( sample_indices ):
        if sample_idx in self . cultural_weights :
            weight = self . cultural_weights [ sample_idx ]
            weighted_uncertainty [ idx ] *= ( 1 + weight )
    return weighted_uncertainty

def receive_update ( self , node_id , local_model , timestamp ):
    staleness = self . current_round - timestamp
    if staleness <= self .

def mc_dropout_uncertainty ( self , X ):
    # 추론(Inference) 중에도 드롭아웃(Dropout) 활성화
    predictions = []
    for _ in range ( self . num_mc_samples ):
        pred = self . model ( X , training = True ) # 드롭아웃을 활성 상태로 유지
        predictions . append ( pred . numpy ())
    predictions = np . array ( predictions )

    # 인식론적 불확실성 (Epistemic uncertainty, 모델 불확실성) 계산
    mean_pred = np . mean ( predictions , axis = 0 )
    variance = np . var ( predictions , axis = 0 )

    # 총 불확실성 (Total uncertainty) = 데이터 불확실성 (Aleatoric) + 인식론적 불확실성 (Epistemic)
    entropy = - np . sum ( mean_pred * np . log ( mean_pred + 1e-10 ), axis = 1 )
    expected_entropy = np . mean ( - np . sum ( predictions * np .

def get_budget_for_round ( self , model_uncertainty ):
    self . round += 1 # A