# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-invariants-preserve-contract-precedence-when-terms-conflict.md
# Remnant Warrant:    https://corpusfetch.com/c/what-invariants-preserve-contract-precedence-when-terms-conflict.warrant.json
# Markdown SHA-256:   e3042728d879fcb49b8bc341127ace648263d7d4d9239a5c018192f5fa677ce3
# Code AST SHA-256:   3bbab32af10bdc912e112fd14b7091b207cf7aad96ad99f523e5bf3e441432a2
# Verified Classes:   PrecedenceVerdict, TermConflict, PrecedencePolicy, PrecedenceManifest, ContractPrecedenceGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class PrecedenceVerdict(Enum):
    NO_CONFLICT = auto()
    EXPLICIT_PRECEDENCE_APPLIED = auto()
    DEFAULT_PRECEDENCE_APPLIED = auto()
    UNRESOLVED_CONFLICT = auto()

@dataclass(frozen=True)
class TermConflict:
    conflict_id: str
    has_conflicting_terms: bool
    precedence_clause_resolves: bool
    default_rule_applies: bool
    governing_term_id: str | None

@dataclass(frozen=True)
class PrecedencePolicy:
    require_precedence_resolution: bool

@dataclass(frozen=True)
class PrecedenceManifest:
    verdict: PrecedenceVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_conflict(
        cls, conflict: TermConflict, policy: PrecedencePolicy
    ) -> PrecedenceManifest:
        
        # Gate 1: No conflict
        if not conflict.has_conflicting_terms:
            digest = cls._hash(json.dumps({
                "conflict": conflict.conflict_id,
                "conflict": False
            }, sort_keys=True))
            return PrecedenceManifest(
                verdict=PrecedenceVerdict.NO_CONFLICT,
                directive=f"PROCEED: No conflict at {conflict.conflict_id}.",
                manifest_digest=digest
            )

        # Gate 2: Explicit precedence
        if conflict.precedence_clause_resolves and conflict.governing_term_id:
            digest = cls._hash(json.dumps({
                "conflict": conflict.conflict_id,
                "governing": conflict.governing_term_id,
                "type": "EXPLICIT"
            }, sort_keys=True))
            return PrecedenceManifest(
                verdict=PrecedenceVerdict.EXPLICIT_PRECEDENCE_APPLIED,
                directive=f"PROCEED: Conflict {conflict.conflict_id} resolved explicitly.",
                manifest_digest=digest
            )

        # Gate 3: Default rule
        if conflict.default_rule_applies and conflict.governing_term_id:
            digest = cls._hash(json.dumps({
                "conflict": conflict.conflict_id,
                "governing": conflict.governing_term_id,
                "type": "DEFAULT"
            }, sort_keys=True))
            return PrecedenceManifest(
                verdict=PrecedenceVerdict.DEFAULT_PRECEDENCE_APPLIED,
                directive=f"PROCEED: Conflict {conflict.conflict_id} resolved by default.",
                manifest_digest=digest
            )

        # Gate 4: Unresolved
        if policy.require_precedence_resolution:
            return PrecedenceManifest(
                verdict=PrecedenceVerdict.UNRESOLVED_CONFLICT,
                directive=f"HALT: Conflict {conflict.conflict_id} unresolved.",
                manifest_digest=cls._hash(f"UNRESOLVED:{conflict.conflict_id}")
            )

        # Gate 5: Default to unresolved
        return PrecedenceManifest(
            verdict=PrecedenceVerdict.UNRESOLVED_CONFLICT,
            directive=f"FLAG: Conflict {conflict.conflict_id} unresolved without policy.",
            manifest_digest=cls._hash(f"DEFAULT:{conflict.conflict_id}")
        )