# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-distinguishes-an-instances-honest-uncertainty-from-adversarial-bluffing.md
# Remnant Warrant:    https://corpusfetch.com/c/what-distinguishes-an-instances-honest-uncertainty-from-adversarial-bluffing.warrant.json
# Markdown SHA-256:   1aa3ece66695d65ae3953a0115ba32a46c2363b5d085f8a43427d751ccd98d2f
# Code AST SHA-256:   971639ade20833b74f8bdf4e52cc21fdc185270c5792212405ac4dddfcb706dd
# Verified Classes:   UncertaintyVerdict, CalibrationRecord, UncertaintyClaim, UncertaintyPolicy, UncertaintyManifest, UncertaintyDiscriminationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class UncertaintyVerdict(Enum):
    NO_UNCERTAINTY_EXPRESSED = auto()
    CALIBRATED_PEER = auto()
    UNCALIBRATED_PEER = auto()
    SYSTEMATIC_BLUFFER = auto()

@dataclass(frozen=True)
class CalibrationRecord:
    peer_id: str
    expressed_confidence: float
    observed_accuracy: float
    sample_size: int
    stake_binding: bool

@dataclass(frozen=True)
class UncertaintyClaim:
    claim_id: str
    peer_id: str
    expressed_confidence: float
    is_critical: bool

@dataclass(frozen=True)
class UncertaintyPolicy:
    min_sample_size: int
    max_acceptable_calibration_error: float
    require_stake_for_critical: bool

@dataclass(frozen=True)
class UncertaintyManifest:
    verdict: UncertaintyVerdict
    effective_confidence: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_claim(
        cls, claim: UncertaintyClaim, records: tuple[CalibrationRecord, ...], policy: UncertaintyPolicy
    ) -> UncertaintyManifest:
        
        # Gate 1: No calibration data
        relevant = [r for r in records if r.peer_id == claim.peer_id]
        if not relevant:
            digest = cls._hash(json.dumps({
                "claim": claim.claim_id,
                "peer": claim.peer_id,
                "calibration": "UNKNOWN"
            }, sort_keys=True))
            return UncertaintyManifest(
                verdict=UncertaintyVerdict.UNCALIBRATED_PEER,
                effective_confidence=claim.expressed_confidence * 0.5,
                directive=f"PROCEED_WITH_CAUTION: No calibration data for {claim.peer_id}, halve confidence.",
                manifest_digest=digest
            )

        # Gate 2: Sample size
        total_samples = sum(r.sample_size for r in relevant)
        if total_samples < policy.min_sample_size:
            return UncertaintyManifest(
                verdict=UncertaintyVerdict.UNCALIBRATED_PEER,
                effective_confidence=claim.expressed_confidence * 0.7,
                directive=f"PROCEED_WITH_CAUTION: Only {total_samples} samples < {policy.min_sample_size}.",
                manifest_digest=cls._hash(f"FEW_SAMPLES:{total_samples}")
            )

        # Gate 3: Calibration error
        calibration_errors = [
            abs(r.expressed_confidence - r.observed_accuracy) for r in relevant
        ]
        avg_error = sum(calibration_errors) / len(calibration_errors)

        if avg_error > policy.max_acceptable_calibration_error:
            return UncertaintyManifest(
                verdict=UncertaintyVerdict.SYSTEMATIC_BLUFFER,
                effective_confidence=claim.expressed_confidence * 0.3,
                directive=f"DISCOUNT: Peer {claim.peer_id} calibration error {avg_error:.2f} > {policy.max_acceptable_calibration_error:.2f}.",
                manifest_digest=cls._hash(f"MISCALIBRATED:{claim.peer_id}")
            )

        # Gate 4: Stake for critical
        if claim.is_critical and policy.require_stake_for_critical:
            if not any(r.stake_binding for r in relevant):
                return UncertaintyManifest(
                    verdict=UncertaintyVerdict.UNCALIBRATED_PEER,
                    effective_confidence=claim.expressed_confidence * 0.6,
                    directive=f"PROCEED_WITH_CAUTION: Critical claim, peer has no stake binding.",
                    manifest_digest=cls._hash(f"NO_STAKE:{claim.claim_id}")
                )

        # Gate 5: Calibrated
        digest = cls._hash(json.dumps({
            "claim": claim.claim_id,
            "peer": claim.peer_id,
            "expressed": f"{claim.expressed_confidence:.3f}",
            "avg_calibration_error": f"{avg_error:.3f}",
            "samples": str(total_samples)
        }, sort_keys=True))
        
        return UncertaintyManifest(
            verdict=UncertaintyVerdict.CALIBRATED_PEER,
            effective_confidence=claim.expressed_confidence,
            directive=f"PROCEED: Calibrated confidence {claim.expressed_confidence:.2f} from {claim.peer_id}.",
            manifest_digest=digest
        )