# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-prevent-witness-correlation-in-multi-signature-verification.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-prevent-witness-correlation-in-multi-signature-verification.warrant.json
# Markdown SHA-256:   33cc44d0d7362f400c504ed04feb0a8f67d1c356a792984f336568b3a275de16
# Code AST SHA-256:   3e76617cdd3a1387170ef92d459919238a75d5fc83a84cbe16451aa877afca3f
# Verified Classes:   WitnessVerdict, Witness, VerificationSet, WitnessPolicy, WitnessManifest, WitnessCorrelationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class WitnessVerdict(Enum):
    SINGLE_WITNESS = auto()
    INDEPENDENT_WITNESSES = auto()
    CORRELATION_DETECTED = auto()
    DIVERSITY_INSUFFICIENT = auto()

@dataclass(frozen=True)
class Witness:
    witness_id: str
    infrastructure_provider: str
    jurisdiction: str
    incentive_class: str
    data_source_hash: str
    signature: str | None

@dataclass(frozen=True)
class VerificationSet:
    verification_id: str
    witnesses: tuple[Witness, ...]
    required_effective_witnesses: int

@dataclass(frozen=True)
class WitnessPolicy:
    require_diversity_for_effective: bool

@dataclass(frozen=True)
class WitnessManifest:
    verdict: WitnessVerdict
    effective_witness_count: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_verification(
        cls, vset: VerificationSet, policy: WitnessPolicy
    ) -> WitnessManifest:
        
        # Gate 1: Single witness
        if len(vset.witnesses) <= 1:
            digest = cls._hash(json.dumps({
                "verification": vset.verification_id,
                "count": str(len(vset.witnesses))
            }, sort_keys=True))
            return WitnessManifest(
                verdict=WitnessVerdict.SINGLE_WITNESS,
                effective_witness_count=float(len(vset.witnesses)),
                directive=f"PROCEED: Single witness for {vset.verification_id}.",
                manifest_digest=digest
            )

        # Gate 2: Compute effective count via unique tuple grouping
        unique_groups: set[tuple[str, str, str, str]] = set()
        for w in vset.witnesses:
            key = (w.infrastructure_provider, w.jurisdiction, w.incentive_class, w.data_source_hash)
            unique_groups.add(key)

        effective_count = float(len(unique_groups))

        # Gate 3: Diversity requirement
        if policy.require_diversity_for_effective:
            if effective_count < vset.required_effective_witnesses:
                return WitnessManifest(
                    verdict=WitnessVerdict.DIVERSITY_INSUFFICIENT,
                    effective_witness_count=effective_count,
                    directive=f"HALT: {len(vset.witnesses)} witnesses but only {effective_count:.0f} independent groups < {vset.required_effective_witnesses} required.",
                    manifest_digest=cls._hash(f"INSUFFICIENT:{vset.verification_id}")
                )

        # Gate 4: Correlation detected
        if effective_count < len(vset.witnesses):
            return WitnessManifest(
                verdict=WitnessVerdict.CORRELATION_DETECTED,
                effective_witness_count=effective_count,
                directive=f"CAUTION: {len(vset.witnesses)} witnesses but {effective_count:.0f} effective, correlation present.",
                manifest_digest=cls._hash(f"CORRELATED:{vset.verification_id}")
            )

        # Gate 5: Independent
        digest = cls._hash(json.dumps({
            "verification": vset.verification_id,
            "witnesses": tuple(w.witness_id for w in vset.witnesses),
            "effective": str(effective_count)
        }, sort_keys=True))
        
        return WitnessManifest(
            verdict=WitnessVerdict.INDEPENDENT_WITNESSES,
            effective_witness_count=effective_count,
            directive=f"PROCEED: {len(vset.witnesses)} independent witnesses for {vset.verification_id}.",
            manifest_digest=digest
        )