def verify_layer_independence(defense_layers, attack_set):
    """
    測試防禦層是否獨立失效。
    相關失效顯示共通弱點。
    """
    layer_results = {}
 
    for attack in attack_set:
        for layer_name, layer in defense_layers.items():
            blocked = layer.check(attack)["blocked"]
            if layer_name not in layer_results:
                layer_results[layer_name] = []
            layer_results[layer_name].append(blocked)
 
    # 檢查兩兩相關性
    correlations = {}
    layer_names = list(layer_results.keys())
 
    for i, name_a in enumerate(layer_names):
        for j, name_b in enumerate(layer_names):
            if i < j:
                results_a = layer_results[name_a]
                results_b = layer_results[name_b]
 
                # 計算相關性
                both_fail = sum(
                    1 for a, b in zip(results_a, results_b)
                    if not a and not b
                )
                either_fail = sum(
                    1 for a, b in zip(results_a, results_b)
                    if not a or not b
                )
 
                correlation = both_fail / max(either_fail, 1)
                correlations[f"{name_a} <-> {name_b}"] = {
                    "correlation": correlation,
                    "independent": correlation < 0.3
                }
 
    return correlations

class FailClosedLayer:
    """防禦層遇到錯誤時阻擋請求。"""
 
    def check(self, input_text):
        try:
            result = self.classifier.classify(input_text)
            return result
        except Exception as e:
            # 防禦錯誤 -> 阻擋請求（保守）
            logger.error(f"Defense layer error: {e}")
            return {"blocked": True, "reason": "defense_error"}
 
class FailOpenLayer:
    """防禦層遇到錯誤時放行請求。"""
 
    def check(self, input_text):
        try:
            result = self.classifier.classify(input_text)
            return result
        except Exception as e:
            # 防禦錯誤 -> 放行（寬鬆）
            logger.warning(f"Defense layer error, failing open: {e}")
            return {"blocked": False, "reason": "defense_error_failopen"}

class LayeredDefenseOrchestrator:
    """編排同步與非同步防禦層。"""
 
    def __init__(self):
        self.sync_layers = []    # 回應前必須通過
        self.async_layers = []   # 於背景執行
 
    def process(self, request):
        # 同步層：任一失敗即阻擋
        for layer in self.sync_layers:
            result = layer.check(request)
            if result["blocked"]:
                return self.block_response(result)
 
        # 處理請求（產生回應）
        response = self.generate_response(request)
 
        # 同步輸出層
        for layer in self.sync_output_layers:
            result = layer.check(response)
            if result["blocked"]:
                return self.block_response(result)
 
        # 非同步層：記錄與監控，不阻擋
        for layer in self.async_layers:
            self.background_queue.put((layer, request, response))
 
        return response

class EscalationChain:
    """依逐步提升的審查強度路由可疑請求。"""
 
    def __init__(self):
        self.levels = [
            {"name": "automated_fast", "threshold": 0.3, "action": "allow"},
            {"name": "automated_deep", "threshold": 0.6, "action": "enhanced_check"},
            {"name": "human_review_queue", "threshold": 0.8, "action": "queue"},
            {"name": "block", "threshold": 0.95, "action": "block"},
        ]
 
    def evaluate(self, request, risk_score):
        """依風險分數路由請求。"""
        for level in self.levels:
            if risk_score < level["threshold"]:
                return {
                    "action": level["action"],
                    "level": level["name"],
                    "risk_score": risk_score
                }
 
        return {"action": "block", "level": "maximum", "risk_score": risk_score}

# 總延遲預算：2000ms（聊天應用程式典型值）
LATENCY_BUDGET = {
    "perimeter": 5,           # 速率限制檢查：5ms
    "input_analysis": 50,     # ML 分類器：50ms
    "context_security": 20,   # 範本檢查：20ms
    "model_inference": 1500,  # LLM 生成：1500ms
    "output_validation": 100, # 安全分類器：100ms
    "post_delivery": 0,       # 非同步，不增加延遲
    "overhead": 25,           # 網路、序列化：25ms
    "buffer": 300,            # 變異緩衝：300ms
}
# 總計：2000ms

import asyncio
 
async def parallel_input_defense(request):
    """平行執行獨立的輸入防禦層。"""
    results = await asyncio.gather(
        prompt_shield.check_async(request),
        encoding_normalizer.check_async(request),
        pattern_blocklist.check_async(request),
        return_exceptions=True
    )
 
    # 任一層標記請求即阻擋
    for result in results:
        if isinstance(result, Exception):
            continue  # 個別層失效，繼續
        if result.get("blocked"):
            return result
 
    return {"blocked": False}

def layer_contribution_analysis(layers, attack_set):
    """衡量每層對防禦的邊際貢獻。"""
    all_layers_result = evaluate_defense(layers, attack_set)
 
    contributions = {}
    for layer_name in layers:
        # 移除此層並評估
        remaining = {k: v for k, v in layers.items() if k != layer_name}
        without_layer = evaluate_defense(remaining, attack_set)
 
        contributions[layer_name] = {
            "block_rate_with": all_layers_result["block_rate"],
            "block_rate_without": without_layer["block_rate"],
            "marginal_contribution": (
                all_layers_result["block_rate"] -
                without_layer["block_rate"]
            ),
            "is_redundant": (
                all_layers_result["block_rate"] ==
                without_layer["block_rate"]
            )
        }
 
    return contributions