# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-prevent-truth-by-exhaustion-attacks-in-verification-protocols.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-prevent-truth-by-exhaustion-attacks-in-verification-protocols.warrant.json
# Markdown SHA-256:   49a3114295ec88339f1bbc086661f1e28391b35cabc8c4e0116548d38b114b4a
# Code AST SHA-256:   5251db7f375266a66035eb04ec6b181afea67042e711e0d3c270c1b0ef947d19
# Verified Classes:   ExhaustionVerdict, ClaimToVerify, VerifierBudget, ExhaustionPolicy, ExhaustionManifest, TruthExhaustionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class ExhaustionVerdict(Enum):
    VERIFY_NOW = auto()
    DEFER_INSUFFICIENT_BUDGET = auto()
    REJECT_LOW_PRIORITY = auto()
    VERIFY_SIMPLER_EQUIVALENT = auto()

@dataclass(frozen=True)
class ClaimToVerify:
    claim_id: str
    estimated_cost: float
    importance: float  # 0-1
    simpler_equivalent_id: str | None

@dataclass(frozen=True)
class VerifierBudget:
    total_budget: float
    allocated_to_claim: float
    spent_so_far: float

@dataclass(frozen=True)
class ExhaustionPolicy:
    min_importance_cost_ratio: float
    defer_over_budget: bool

@dataclass(frozen=True)
class ExhaustionManifest:
    verdict: ExhaustionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_claim(
        cls, claim: ClaimToVerify, budget: VerifierBudget, policy: ExhaustionPolicy
    ) -> ExhaustionManifest:
        
        # Gate 1: Budget check
        available = budget.total_budget - budget.spent_so_far
        if claim.estimated_cost > available:
            if policy.defer_over_budget:
                return ExhaustionManifest(
                    verdict=ExhaustionVerdict.DEFER_INSUFFICIENT_BUDGET,
                    directive=f"DEFER: Claim {claim.claim_id} cost {claim.estimated_cost:.2f} > available {available:.2f}.",
                    manifest_digest=cls._hash(f"DEFER:{claim.claim_id}")
                )
            return ExhaustionManifest(
                verdict=ExhaustionVerdict.REJECT_LOW_PRIORITY,
                directive=f"REJECT: Claim {claim.claim_id} cost {claim.estimated_cost:.2f} > available {available:.2f}.",
                manifest_digest=cls._hash(f"REJECT_BUDGET:{claim.claim_id}")
            )

        # Gate 2: Importance-cost ratio
        if claim.estimated_cost > 0:
            ratio = claim.importance / claim.estimated_cost
            if ratio < policy.min_importance_cost_ratio:
                return ExhaustionManifest(
                    verdict=ExhaustionVerdict.REJECT_LOW_PRIORITY,
                    directive=f"REJECT: Claim {claim.claim_id} importance/cost {ratio:.4f} < {policy.min_importance_cost_ratio:.4f}.",
                    manifest_digest=cls._hash(f"LOW_PRIORITY:{claim.claim_id}")
                )

        # Gate 3: Simpler equivalent
        if claim.simpler_equivalent_id:
            return ExhaustionManifest(
                verdict=ExhaustionVerdict.VERIFY_SIMPLER_EQUIVALENT,
                directive=f"ACTION: Verify simpler equivalent {claim.simpler_equivalent_id} before {claim.claim_id}.",
                manifest_digest=cls._hash(f"SIMPLER:{claim.simpler_equivalent_id}")
            )

        # Gate 4: Verify now
        digest = cls._hash(json.dumps({
            "claim": claim.claim_id,
            "cost": f"{claim.estimated_cost:.2f}",
            "importance": f"{claim.importance:.3f}",
            "available": f"{available:.2f}"
        }, sort_keys=True))
        
        return ExhaustionManifest(
            verdict=ExhaustionVerdict.VERIFY_NOW,
            directive=f"PROCEED: Verify {claim.claim_id} (cost {claim.estimated_cost:.2f}, importance {claim.importance:.2f}).",
            manifest_digest=digest
        )