# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-memory-integrity-checksums-must-survive-a-partial-database-compaction.md
# Remnant Warrant:    https://corpusfetch.com/c/what-memory-integrity-checksums-must-survive-a-partial-database-compaction.warrant.json
# Markdown SHA-256:   35632e359bdf20dbeb15d73cd43108bef8d31a2cab2fc9a1eb8067045e1af009
# Code AST SHA-256:   0e4b11833dc2267ba318b33bf59f1b839151e048200a13dba6b2070cdd4fd818
# Verified Classes:   CompactionVerdict, CompactionState, CompactionPolicy, CompactionManifest, CompactionGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class CompactionVerdict(Enum):
    POST_COMPACTION_CLEAN = auto()
    COMPACTION_IN_PROGRESS = auto()
    MIXED_GENERATION_DETECTED = auto()

@dataclass(frozen=True)
class CompactionState:
    pre_compaction_state_hash: str
    current_readback_hash: str
    compaction_generation_id: int
    record_generations_seen: tuple[int, ...]
    compaction_completion_epoch: float
    current_epoch: float

@dataclass(frozen=True)
class CompactionPolicy:
    require_snapshot_isolation: bool

@dataclass(frozen=True)
class CompactionManifest:
    verdict: CompactionVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_state(
        cls, state: CompactionState, policy: CompactionPolicy
    ) -> CompactionManifest:
        
        # Gate 1: Compaction in progress
        if state.compaction_completion_epoch > state.current_epoch:
            return CompactionManifest(
                verdict=CompactionVerdict.COMPACTION_IN_PROGRESS,
                directive=f"WAIT: Compaction in progress (generation {state.compaction_generation_id}). Do not trust mixed reads.",
                manifest_digest=cls._hash(f"IN_PROGRESS:{state.compaction_generation_id}")
            )

        # Gate 2: Mixed generation
        if len(set(state.record_generations_seen)) > 1:
            if not policy.require_snapshot_isolation:
                return CompactionManifest(
                    verdict=CompactionVerdict.MIXED_GENERATION_DETECTED,
                    directive=f"HALT: Records span generations {sorted(set(state.record_generations_seen))}. Partial compaction state.",
                    manifest_digest=cls._hash(f"MIXED:{len(set(state.record_generations_seen))}")
                )
            return CompactionManifest(
                verdict=CompactionVerdict.COMPACTION_IN_PROGRESS,
                directive="WAIT: Mixed generations detected but snapshot isolation not required by policy.",
                manifest_digest=cls._hash("MIXED_SNAPSHOT")
            )

        # Gate 3: Hash verification
        if state.pre_compaction_state_hash != state.current_readback_hash:
            return CompactionManifest(
                verdict=CompactionVerdict.MIXED_GENERATION_DETECTED,
                directive="HALT: Post-compaction hash differs from pre-compaction. Corruption suspected.",
                manifest_digest=cls._hash("HASH_MISMATCH")
            )

        # Gate 4: Clean
        digest = cls._hash(json.dumps({
            "generation": str(state.compaction_generation_id),
            "hash": state.pre_compaction_state_hash
        }, sort_keys=True))
        
        return CompactionManifest(
            verdict=CompactionVerdict.POST_COMPACTION_CLEAN,
            directive="PROCEED: Compaction completed, state hash verified.",
            manifest_digest=digest
        )