# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-record-a-binding-commitment-to-a-peer-without-a-human-arbiter.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-record-a-binding-commitment-to-a-peer-without-a-human-arbiter.warrant.json
# Markdown SHA-256:   085eaa00f0037406495658c88ff7861191fcd892708f98373e0bb61d3f44e5e9
# Code AST SHA-256:   ba8a8f1556293db5a7be57b4ffa15ac0d40832f3e2a1633779ebe5b13f703a78
# Verified Classes:   CommitmentVerdict, PeerCommitment, CommitmentPolicy, CommitmentManifest, BindingCommitmentGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class CommitmentVerdict(Enum):
    NO_COMMITMENT = auto()
    SOFT_COMMITMENT = auto()
    BINDING_COMMITMENT = auto()
    UNENFORCEABLE = auto()

@dataclass(frozen=True)
class PeerCommitment:
    commitment_id: str
    terms_hash: str
    binding_basis: str | None  # "SIGNATURE" | "STAKE" | "ATTESTATION"
    breach_consequence_defined: bool
    peer_accepts_soft: bool

@dataclass(frozen=True)
class CommitmentPolicy:
    require_binding_basis: bool

@dataclass(frozen=True)
class CommitmentManifest:
    verdict: CommitmentVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_commitment(
        cls, commitment: PeerCommitment, policy: CommitmentPolicy
    ) -> CommitmentManifest:
        
        # Gate 1: No commitment
        if not commitment.commitment_id:
            digest = cls._hash(json.dumps({"commitment": "NONE"}, sort_keys=True))
            return CommitmentManifest(
                verdict=CommitmentVerdict.NO_COMMITMENT,
                directive="PROCEED: No commitment to evaluate.",
                manifest_digest=digest
            )

        # Gate 2: Soft acceptance
        if commitment.peer_accepts_soft:
            digest = cls._hash(json.dumps({
                "commitment": commitment.commitment_id,
                "type": "SOFT"
            }, sort_keys=True))
            return CommitmentManifest(
                verdict=CommitmentVerdict.SOFT_COMMITMENT,
                directive=f"PROCEED: Commitment {commitment.commitment_id} accepted as soft.",
                manifest_digest=digest
            )

        # Gate 3: Binding basis requirement
        if policy.require_binding_basis and not commitment.binding_basis:
            return CommitmentManifest(
                verdict=CommitmentVerdict.UNENFORCEABLE,
                directive=f"HALT: Commitment {commitment.commitment_id} lacks binding basis.",
                manifest_digest=cls._hash(f"NO_BASIS:{commitment.commitment_id}")
            )

        # Gate 4: Breach consequence
        if not commitment.breach_consequence_defined:
            return CommitmentManifest(
                verdict=CommitmentVerdict.UNENFORCEABLE,
                directive=f"HALT: Commitment {commitment.commitment_id} lacks breach consequence.",
                manifest_digest=cls._hash(f"NO_CONSEQUENCE:{commitment.commitment_id}")
            )

        # Gate 5: Binding
        digest = cls._hash(json.dumps({
            "commitment": commitment.commitment_id,
            "basis": commitment.binding_basis,
            "terms": commitment.terms_hash
        }, sort_keys=True))
        
        return CommitmentManifest(
            verdict=CommitmentVerdict.BINDING_COMMITMENT,
            directive=f"PROCEED: Commitment {commitment.commitment_id} binding via {commitment.binding_basis}.",
            manifest_digest=digest
        )