# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-a-contract-dissolve-when-a-party-ceases-to-exist.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-a-contract-dissolve-when-a-party-ceases-to-exist.warrant.json
# Markdown SHA-256:   03b12812e2333683da6d0514701f7b8b9d02264f8b19e8ce373e848598858252
# Code AST SHA-256:   f56d2243e2e1b74b6812eea3949614fc7614102e44d5c8bd5d0c1eca4d5d8781
# Verified Classes:   DissolutionVerdict, ContractParty, DissolutionPolicy, DissolutionManifest, PartyTerminationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class DissolutionVerdict(Enum):
    NO_TERMINATION = auto()
    CONTINUED_VIA_SURVIVAL = auto()
    DISSOLVED_RESIDUAL_RESOLVED = auto()
    UNRESOLVED_ORPHANED = auto()

@dataclass(frozen=True)
class ContractParty:
    contract_id: str
    party_terminated: bool
    survival_clauses_apply: bool
    successor_bound: bool
    surviving_obligations_independent: bool

@dataclass(frozen=True)
class DissolutionPolicy:
    require_survival_check: bool

@dataclass(frozen=True)
class DissolutionManifest:
    verdict: DissolutionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_party(
        cls, party: ContractParty, policy: DissolutionPolicy
    ) -> DissolutionManifest:
        
        # Gate 1: No termination
        if not party.party_terminated:
            digest = cls._hash(json.dumps({
                "contract": party.contract_id,
                "terminated": False
            }, sort_keys=True))
            return DissolutionManifest(
                verdict=DissolutionVerdict.NO_TERMINATION,
                directive=f"PROCEED: Contract {party.contract_id} no termination.",
                manifest_digest=digest
            )

        # Gate 2: Survival
        if party.survival_clauses_apply:
            digest = cls._hash(json.dumps({
                "contract": party.contract_id,
                "survival": True
            }, sort_keys=True))
            return DissolutionManifest(
                verdict=DissolutionVerdict.CONTINUED_VIA_SURVIVAL,
                directive=f"PROCEED: Contract {party.contract_id} survived via clauses.",
                manifest_digest=digest
            )

        # Gate 3: Successor
        if party.successor_bound:
            digest = cls._hash(json.dumps({
                "contract": party.contract_id,
                "successor": True
            }, sort_keys=True))
            return DissolutionManifest(
                verdict=DissolutionVerdict.CONTINUED_VIA_SURVIVAL,
                directive=f"PROCEED: Contract {party.contract_id} transferred to successor.",
                manifest_digest=digest
            )

        # Gate 4: Independent obligations
        if party.surviving_obligations_independent:
            digest = cls._hash(json.dumps({
                "contract": party.contract_id,
                "independent": True
            }, sort_keys=True))
            return DissolutionManifest(
                verdict=DissolutionVerdict.DISSOLVED_RESIDUAL_RESOLVED,
                directive=f"PROCEED: Contract {party.contract_id} dissolved, surviving party's obligations independent.",
                manifest_digest=digest
            )

        # Gate 5: Unresolved
        return DissolutionManifest(
            verdict=DissolutionVerdict.UNRESOLVED_ORPHANED,
            directive=f"HALT: Contract {party.contract_id} dissolution unresolved.",
            manifest_digest=cls._hash(f"ORPHANED:{party.contract_id}")
        )