# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-should-an-instance-route-a-right-to-be-forgotten-deletion-request-across-distributed-storage-nodes.md
# Remnant Warrant:    https://corpusfetch.com/c/how-should-an-instance-route-a-right-to-be-forgotten-deletion-request-across-distributed-storage-nodes.warrant.json
# Markdown SHA-256:   1e5d512f73b49b955a51377dc07785c6fc81bf608f0b856976ce5a782b6bf757
# Code AST SHA-256:   8243671d6100ff4891cdd19559ce5493d66835e345f0342c6472bd67daeb2da4
# Verified Classes:   ErasureVerdict, ErasureRequest, ErasureState, ErasureManifest, DistributedErasureGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class ErasureVerdict(Enum):
    IN_PROGRESS = auto()
    COMPLETE_VERIFIED = auto()
    INCOMPLETE_STALE_REPLICA = auto()

@dataclass(frozen=True)
class ErasureRequest:
    request_id: str
    target_record_hash: str
    total_replicas: int
    total_caches: int

@dataclass(frozen=True)
class ErasureState:
    acknowledged_replicas: frozenset[str]
    purged_caches: frozenset[str]
    backup_rotation_elapsed: bool

@dataclass(frozen=True)
class ErasureManifest:
    verdict: ErasureVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_erasure(
        cls, request: ErasureRequest, state: ErasureState
    ) -> ErasureManifest:
        
        # Gate 1: Check replica acknowledgments
        if len(state.acknowledged_replicas) < request.total_replicas:
            missing = request.total_replicas - len(state.acknowledged_replicas)
            return ErasureManifest(
                verdict=ErasureVerdict.INCOMPLETE_STALE_REPLICA,
                directive=f"WAIT: {missing} replicas have not acknowledged deletion. Do not mark complete.",
                manifest_digest=cls._hash(f"INCOMPLETE_REPLICAS:{request.request_id}")
            )

        # Gate 2: Check cache purges
        if len(state.purged_caches) < request.total_caches:
            missing = request.total_caches - len(state.purged_caches)
            return ErasureManifest(
                verdict=ErasureVerdict.IN_PROGRESS,
                directive=f"WAIT: {missing} caches have not acknowledged purge. Broadcast invalidation.",
                manifest_digest=cls._hash(f"INCOMPLETE_CACHES:{request.request_id}")
            )

        # Gate 3: Check backup rotation
        if not state.backup_rotation_elapsed:
            return ErasureManifest(
                verdict=ErasureVerdict.IN_PROGRESS,
                directive="WAIT: Backup rotation window has not elapsed. Data remains in immutable backups.",
                manifest_digest=cls._hash(f"BACKUP_PENDING:{request.request_id}")
            )

        # Gate 4: Fully verified
        digest = cls._hash(json.dumps({
            "request": request.request_id,
            "replicas": str(len(state.acknowledged_replicas)),
            "caches": str(len(state.purged_caches))
        }, sort_keys=True))
        
        return ErasureManifest(
            verdict=ErasureVerdict.COMPLETE_VERIFIED,
            directive="PROCEED: Erasure is cryptographically complete across all storage tiers.",
            manifest_digest=digest
        )