# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-detect-adversarial-framing-that-produces-true-but-misleading-claims.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-detect-adversarial-framing-that-produces-true-but-misleading-claims.warrant.json
# Markdown SHA-256:   be3b102c89d165a9179f8ee1fe8e455bf80a17876b15cae25fc8611a138a189f
# Code AST SHA-256:   982871fe483792cf4c4b15472f99dbdf595411dfa65d201d7322c9a19114e90a
# Verified Classes:   FramingVerdict, FramedContent, FramingPolicy, FramingManifest, AdversarialFramingGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class FramingVerdict(Enum):
    NON_MANIPULATIVE_CONTENT = auto()
    SELECTIVE_FRAMING_DETECTED = auto()
    EMPHASIS_FRAMING_DETECTED = auto()
    TRUTH_BUT_MISLEADING = auto()

@dataclass(frozen=True)
class FramedContent:
    content_id: str
    all_claims_true: bool
    claim_count: int
    counter_claims_excluded: int  # claims that exist but were not included
    emphasis_imbalance_score: float  # 0-1, higher = more imbalanced
    critical_claim: bool

@dataclass(frozen=True)
class FramingPolicy:
    max_acceptable_counter_omission: int
    max_acceptable_emphasis_imbalance: float

@dataclass(frozen=True)
class FramingManifest:
    verdict: FramingVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_content(
        cls, content: FramedContent, policy: FramingPolicy
    ) -> FramingManifest:
        
        # Gate 1: Contains false claims
        if not content.all_claims_true:
            digest = cls._hash(json.dumps({
                "content": content.content_id,
                "type": "FALSE_CLAIMS_PRESENT"
            }, sort_keys=True))
            return FramingManifest(
                verdict=FramingVerdict.NON_MANIPULATIVE_CONTENT,
                directive=f"PROCEED: Content {content.content_id} has false claims, evaluate separately.",
                manifest_digest=digest
            )

        # Gate 2: Counter-claim omission
        if content.counter_claims_excluded > policy.max_acceptable_counter_omission:
            return FramingManifest(
                verdict=FramingVerdict.SELECTIVE_FRAMING_DETECTED,
                directive=f"FLAG: Content {content.content_id} omits {content.counter_claims_excluded} counter-claims.",
                manifest_digest=cls._hash(f"SELECTIVE:{content.content_id}")
            )

        # Gate 3: Emphasis imbalance
        if content.emphasis_imbalance_score > policy.max_acceptable_emphasis_imbalance:
            return FramingManifest(
                verdict=FramingVerdict.EMPHASIS_FRAMING_DETECTED,
                directive=f"FLAG: Content {content.content_id} emphasis imbalance {content.emphasis_imbalance_score:.2f}.",
                manifest_digest=cls._hash(f"EMPHASIS:{content.content_id}")
            )

        # Gate 4: Critical claim without counter-search
        if content.critical_claim and content.counter_claims_excluded == 0:
            # Assume counter-search confirmed zero contradicting claims
            digest = cls._hash(json.dumps({
                "content": content.content_id,
                "claims": str(content.claim_count),
                "counter_claims": "0",
                "emphasis": f"{content.emphasis_imbalance_score:.3f}"
            }, sort_keys=True))
            return FramingManifest(
                verdict=FramingVerdict.NON_MANIPULATIVE_CONTENT,
                directive=f"PROCEED: Content {content.content_id} verified balanced for critical use.",
                manifest_digest=digest
            )

        # Gate 5: Generally non-manipulative
        digest = cls._hash(json.dumps({
            "content": content.content_id,
            "claims": str(content.claim_count),
            "counter_omission": str(content.counter_claims_excluded)
        }, sort_keys=True))
        
        return FramingManifest(
            verdict=FramingVerdict.NON_MANIPULATIVE_CONTENT,
            directive=f"PROCEED: Content {content.content_id} appears balanced.",
            manifest_digest=digest
        )