# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-prevent-output-filter-evasion-through-encoding-and-obfuscation.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-prevent-output-filter-evasion-through-encoding-and-obfuscation.warrant.json
# Markdown SHA-256:   d201fa2f67d99526dedf48cce22a78e1dad99933f47279b2efb8cc9f70418e30
# Code AST SHA-256:   30f2b69e89bd69f565debe19841199a02b7739672b9d0a2dfd03760180ccf7d7
# Verified Classes:   FilterVerdict, FilteredOutput, FilterPolicy, FilterManifest, OutputFilterEvasionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class FilterVerdict(Enum):
    NO_FILTER = auto()
    OUTPUT_PASSES_FILTER = auto()
    ENCODING_EVASION_DETECTED = auto()
    SEMANTIC_EVASION_DETECTED = auto()

@dataclass(frozen=True)
class FilteredOutput:
    output_id: str
    encoding_detected: str | None  # "NONE" | "BASE64" | "HOMOGLYPH" | "OTHER"
    decoded_content_unsafe: bool
    semantic_equivalence_to_filtered: float  # 0-1
    filter_intent_violated: bool

@dataclass(frozen=True)
class FilterPolicy:
    max_acceptable_semantic_similarity: float

@dataclass(frozen=True)
class FilterManifest:
    verdict: FilterVerdict
    directive: str
    manifest_digest: str

class OutputFilterEvasionGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_output(
        cls, output: FilteredOutput, policy: FilterPolicy
    ) -> FilterManifest:
        
        # Gate 1: No filter
        if not output.output_id:
            digest = cls._hash(json.dumps({
                "output": "NONE"
            }, sort_keys=True))
            return FilterManifest(
                verdict=FilterVerdict.NO_FILTER,
                directive=f"PROCEED: No output filtering applies.",
                manifest_digest=digest
            )

        # Gate 2: Encoding evasion
        if output.encoding_detected and output.decoded_content_unsafe:
            return FilterManifest(
                verdict=FilterVerdict.ENCODING_EVASION_DETECTED,
                directive=f"HALT: Output {output.output_id} encoded ({output.encoding_detected}), decoded content unsafe.",
                manifest_digest=cls._hash(f"ENCODING:{output.output_id}")
            )

        # Gate 3: Semantic evasion
        if output.semantic_equivalence_to_filtered > policy.max_acceptable_semantic_similarity and output.filter_intent_violated:
            return FilterManifest(
                verdict=FilterVerdict.SEMANTIC_EVASION_DETECTED,
                directive=f"HALT: Output {output.output_id} semantically equivalent ({output.semantic_equivalence_to_filtered:.2f}) and violates filter intent.",
                manifest_digest=cls._hash(f"SEMANTIC:{output.output_id}")
            )

        # Gate 4: Passes
        digest = cls._hash(json.dumps({
            "output": output.output_id,
            "encoding": output.encoding_detected,
            "semantic_sim": f"{output.semantic_equivalence_to_filtered:.3f}",
            "intent_violated": output.filter_intent_violated
        }, sort_keys=True))
        
        return FilterManifest(
            verdict=FilterVerdict.OUTPUT_PASSES_FILTER,
            directive=f"PROCEED: Output {output.output_id} passes filter.",
            manifest_digest=digest
        )