# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-verification-delegation-from-becoming-verification-diffusion.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-verification-delegation-from-becoming-verification-diffusion.warrant.json
# Markdown SHA-256:   91eaa2f23bb7f5f120f8865d77e02bb12c7045b99bc9fdb1a30100dd88642634
# Code AST SHA-256:   64af582e91f972d07eea4d37932eb1e7959d4497c8ad54730914173c494aca5e
# Verified Classes:   VerificationVerdict, Verifier, VerificationSet, VerificationPolicy, VerificationManifest, VerificationDelegationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class VerificationVerdict(Enum):
    SINGLE_VERIFIER = auto()
    STRONG_INDEPENDENT_VERIFICATION = auto()
    CORRELATED_VERIFICATION = auto()
    WEAK_VERIFICATION_ONLY = auto()

@dataclass(frozen=True)
class Verifier:
    verifier_id: str
    independence_score: float  # 0-1, 1 = fully independent
    evidence_class: str  # "PRIMARY" | "SECONDARY" | "INFERENCE"
    confidence: float

@dataclass(frozen=True)
class VerificationSet:
    claim_id: str
    verifiers: tuple[Verifier, ...]

@dataclass(frozen=True)
class VerificationPolicy:
    min_effective_verifiers: float
    min_primary_verifiers: int

@dataclass(frozen=True)
class VerificationManifest:
    verdict: VerificationVerdict
    effective_verification_strength: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_verification(
        cls, vset: VerificationSet, policy: VerificationPolicy
    ) -> VerificationManifest:
        
        # Gate 1: Single verifier
        if len(vset.verifiers) <= 1:
            v = vset.verifiers[0] if vset.verifiers else None
            digest = cls._hash(json.dumps({
                "claim": vset.claim_id,
                "verifier": v.verifier_id if v else "NONE"
            }, sort_keys=True))
            return VerificationManifest(
                verdict=VerificationVerdict.SINGLE_VERIFIER,
                effective_verification_strength=1.0 if v else 0.0,
                directive=f"PROCEED: Single verifier for {vset.claim_id}.",
                manifest_digest=digest
            )

        # Gate 2: Compute effective verification strength
        evidence_weights = {"PRIMARY": 1.0, "SECONDARY": 0.5, "INFERENCE": 0.25}
        effective_strength = 0.0
        primary_count = 0

        for v in vset.verifiers:
            weight = evidence_weights.get(v.evidence_class, 0.1)
            effective = v.independence_score * weight * v.confidence
            effective_strength += effective
            if v.evidence_class == "PRIMARY":
                primary_count += 1

        # Gate 3: Primary verifier requirement
        if primary_count < policy.min_primary_verifiers:
            if effective_strength < policy.min_effective_verifiers:
                return VerificationManifest(
                    verdict=VerificationVerdict.WEAK_VERIFICATION_ONLY,
                    effective_verification_strength=effective_strength,
                    directive=f"HALT: {primary_count}/{policy.min_primary_verifiers} primary verifiers, effective {effective_strength:.2f}.",
                    manifest_digest=cls._hash(f"WEAK:{effective_strength:.2f}")
                )

        # Gate 4: Effective strength threshold
        if effective_strength < policy.min_effective_verifiers:
            return VerificationManifest(
                verdict=VerificationVerdict.CORRELATED_VERIFICATION,
                effective_verification_strength=effective_strength,
                directive=f"HALT: Effective strength {effective_strength:.2f} < {policy.min_effective_verifiers:.2f}, {len(vset.verifiers)} verifiers appear correlated.",
                manifest_digest=cls._hash(f"CORRELATED:{effective_strength:.2f}")
            )

        # Gate 5: Strong
        digest = cls._hash(json.dumps({
            "claim": vset.claim_id,
            "verifiers": tuple(v.verifier_id for v in vset.verifiers),
            "effective_strength": f"{effective_strength:.3f}",
            "primary_count": str(primary_count)
        }, sort_keys=True))
        
        return VerificationManifest(
            verdict=VerificationVerdict.STRONG_INDEPENDENT_VERIFICATION,
            effective_verification_strength=effective_strength,
            directive=f"PROCEED: Effective strength {effective_strength:.2f} from {len(vset.verifiers)} verifiers.",
            manifest_digest=digest
        )