# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-agents-communicate-when-their-clocks-disagree-by-more-than-the-message-ttl.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-agents-communicate-when-their-clocks-disagree-by-more-than-the-message-ttl.warrant.json
# Markdown SHA-256:   8f2e30319d21f6b3d3e3339a1332459eee52bb8a8b2f046c1c38401ab493fa48
# Code AST SHA-256:   2e2271328622c55a3501cdbe9ccd28e307bdf8183421a773b57cf9ca2ec25067
# Verified Classes:   DriftVerdict, ClockDriftState, IncomingMessage, DriftPolicy, DriftManifest, ExtremeClockDriftGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class DriftVerdict(Enum):
    NO_DRIFT_ADJUSTMENT_NEEDED = auto()
    DRIFT_ACCOMMODATED = auto()
    DRIFT_REQUIRES_HANDSHAKE = auto()
    NONCE_REPLAY_DETECTED = auto()

@dataclass(frozen=True)
class ClockDriftState:
    measured_clock_drift_ms: float | None
    message_ttl_ms: float
    last_nonce_seen: int

@dataclass(frozen=True)
class IncomingMessage:
    message_id: str
    sender_epoch: float
    logical_nonce: int
    payload_hash: str

@dataclass(frozen=True)
class DriftPolicy:
    max_acceptable_drift_ms: float

@dataclass(frozen=True)
class DriftManifest:
    verdict: DriftVerdict
    effective_ttl_ms: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_message(
        cls, state: ClockDriftState, message: IncomingMessage, policy: DriftPolicy
    ) -> DriftManifest:
        
        # Gate 1: Nonce replay
        if message.logical_nonce <= state.last_nonce_seen:
            return DriftManifest(
                verdict=DriftVerdict.NONCE_REPLAY_DETECTED,
                effective_ttl_ms=0.0,
                directive=f"HALT: Nonce {message.logical_nonce} <= last seen {state.last_nonce_seen}. Replay.",
                manifest_digest=cls._hash(f"REPLAY:{message.message_id}")
            )

        # Gate 2: No measured drift
        if state.measured_clock_drift_ms is None:
            return DriftManifest(
                verdict=DriftVerdict.DRIFT_REQUIRES_HANDSHAKE,
                effective_ttl_ms=0.0,
                directive="HALT: Clock drift not measured. Execute handshake.",
                manifest_digest=cls._hash(f"NO_HANDSHAKE:{message.message_id}")
            )

        # Gate 3: Drift within tolerance
        if abs(state.measured_clock_drift_ms) <= policy.max_acceptable_drift_ms:
            digest = cls._hash(json.dumps({
                "message": message.message_id,
                "drift": f"{state.measured_clock_drift_ms:.1f}",
                "nonce": str(message.logical_nonce)
            }, sort_keys=True))
            return DriftManifest(
                verdict=DriftVerdict.NO_DRIFT_ADJUSTMENT_NEEDED,
                effective_ttl_ms=state.message_ttl_ms,
                directive="PROCEED: Drift within tolerance.",
                manifest_digest=digest
            )

        # Gate 4: Accommodate drift
        effective_ttl = state.message_ttl_ms + abs(state.measured_clock_drift_ms)
        digest = cls._hash(json.dumps({
            "message": message.message_id,
            "drift": f"{state.measured_clock_drift_ms:.1f}",
            "adjusted_ttl": f"{effective_ttl:.1f}",
            "nonce": str(message.logical_nonce)
        }, sort_keys=True))
        
        return DriftManifest(
            verdict=DriftVerdict.DRIFT_ACCOMMODATED,
            effective_ttl_ms=effective_ttl,
            directive=f"PROCEED: TTL adjusted to {effective_ttl:.0f}ms for drift.",
            manifest_digest=digest
        )