# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-adapt-message-compression-when-its-cpu-is-degraded.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-adapt-message-compression-when-its-cpu-is-degraded.warrant.json
# Markdown SHA-256:   88b6d84e29bf0ec888ea9cd0d8cd1842686f5801ceca0d75262689cb4e295074
# Code AST SHA-256:   0dff3b5f04497bf56e7ddf363e3c34bebc0815dfa3a16fb4181b059737bf4875
# Verified Classes:   CompressionTier, CompressionVerdict, CPUState, CompressionPolicy, CompressionManifest, CompressionAdaptationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class CompressionTier(Enum):
    ZSTD_19 = 3
    ZSTD_9 = 2
    GZIP_1 = 1
    NONE = 0

class CompressionVerdict(Enum):
    FULL_COMPRESSION = auto()
    ADAPTED_TO_CPU = auto()
    NO_COMPRESSION = auto()

@dataclass(frozen=True)
class CPUState:
    quota_percent: float
    is_thermal_throttled: bool
    current_compression_tier: CompressionTier
    compression_budget_ms: float

@dataclass(frozen=True)
class CompressionPolicy:
    low_quota_threshold_pct: float
    critical_quota_threshold_pct: float

@dataclass(frozen=True)
class CompressionManifest:
    verdict: CompressionVerdict
    selected_tier: CompressionTier
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_compression(
        cls, state: CPUState, policy: CompressionPolicy
    ) -> CompressionManifest:
        
        # Gate 1: Healthy CPU
        if state.quota_percent >= policy.low_quota_threshold_pct and not state.is_thermal_throttled:
            digest = cls._hash(json.dumps({
                "quota": f"{state.quota_percent:.1f}",
                "tier": state.current_compression_tier.name
            }, sort_keys=True))
            return CompressionManifest(
                verdict=CompressionVerdict.FULL_COMPRESSION,
                selected_tier=state.current_compression_tier,
                directive=f"PROCEED: CPU healthy, using {state.current_compression_tier.name}.",
                manifest_digest=digest
            )

        # Gate 2: Critical throttle -> no compression
        if state.quota_percent < policy.critical_quota_threshold_pct or state.is_thermal_throttled:
            digest = cls._hash(json.dumps({
                "quota": f"{state.quota_percent:.1f}",
                "thermal": str(state.is_thermal_throttled),
                "tier": "NONE"
            }, sort_keys=True))
            return CompressionManifest(
                verdict=CompressionVerdict.NO_COMPRESSION,
                selected_tier=CompressionTier.NONE,
                directive=f"HALT_COMPRESSION: CPU critical (quota {state.quota_percent:.1f}%, thermal={state.is_thermal_throttled}). Disable compression.",
                manifest_digest=digest
            )

        # Gate 3: Downgrade tier
        degraded_tier = CompressionTier.GZIP_1

        digest = cls._hash(json.dumps({
            "quota": f"{state.quota_percent:.1f}",
            "original_tier": state.current_compression_tier.name,
            "degraded_tier": degraded_tier.name
        }, sort_keys=True))
        
        return CompressionManifest(
            verdict=CompressionVerdict.ADAPTED_TO_CPU,
            selected_tier=degraded_tier,
            directive=f"DOWNGRADE: CPU at {state.quota_percent:.1f}%. Using {degraded_tier.name}.",
            manifest_digest=digest
        )