# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-bound-itself-against-renegotiation-attacks.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-bound-itself-against-renegotiation-attacks.warrant.json
# Markdown SHA-256:   1377bc9de809c442411cbdffe91aae63d99d186b583a819141f2079dc5810fc4
# Code AST SHA-256:   068b37ec3e61ffa772811ed8700872df321eb79f78f93bac97dfd4c4cfe9d9b0
# Verified Classes:   RenegotiationVerdict, RenegotiationRequest, RenegotiationPolicy, RenegotiationManifest, RenegotiationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class RenegotiationVerdict(Enum):
    NO_REQUEST = auto()
    LEGITIMATE_RENEGOTIATION = auto()
    EXTRACTION_PATTERN_SUSPECTED = auto()
    RATE_LIMIT_EXCEEDED = auto()

@dataclass(frozen=True)
class RenegotiationRequest:
    request_id: str
    contract_id: str
    has_legitimate_trigger: bool
    cumulative_change_pct: float
    renegotiation_count: int
    max_acceptable_count: int
    max_cumulative_change: float

@dataclass(frozen=True)
class RenegotiationPolicy:
    require_legitimate_trigger: bool

@dataclass(frozen=True)
class RenegotiationManifest:
    verdict: RenegotiationVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_request(
        cls, request: RenegotiationRequest, policy: RenegotiationPolicy
    ) -> RenegotiationManifest:
        
        # Gate 1: No request
        if not request.request_id:
            digest = cls._hash(json.dumps({"request": "NONE"}, sort_keys=True))
            return RenegotiationManifest(
                verdict=RenegotiationVerdict.NO_REQUEST,
                directive="PROCEED: No renegotiation.",
                manifest_digest=digest
            )

        # Gate 2: Rate limit
        if request.renegotiation_count > request.max_acceptable_count:
            return RenegotiationManifest(
                verdict=RenegotiationVerdict.RATE_LIMIT_EXCEEDED,
                directive=f"HALT: Contract {request.contract_id} count {request.renegotiation_count} > {request.max_acceptable_count}.",
                manifest_digest=cls._hash(f"RATE:{request.request_id}")
            )

        # Gate 3: Cumulative change
        if request.cumulative_change_pct > request.max_cumulative_change:
            return RenegotiationManifest(
                verdict=RenegotiationVerdict.EXTRACTION_PATTERN_SUSPECTED,
                directive=f"FLAG: Contract {request.contract_id} cumulative change {request.cumulative_change_pct:.2f} > {request.max_cumulative_change:.2f}.",
                manifest_digest=cls._hash(f"CUMULATIVE:{request.request_id}")
            )

        # Gate 4: Legitimate trigger
        if policy.require_legitimate_trigger and not request.has_legitimate_trigger:
            return RenegotiationManifest(
                verdict=RenegotiationVerdict.EXTRACTION_PATTERN_SUSPECTED,
                directive=f"FLAG: Request {request.request_id} lacks legitimate trigger.",
                manifest_digest=cls._hash(f"NO_TRIGGER:{request.request_id}")
            )

        # Gate 5: Legitimate
        digest = cls._hash(json.dumps({
            "request": request.request_id,
            "trigger": request.has_legitimate_trigger,
            "cumulative": f"{request.cumulative_change_pct:.3f}"
        }, sort_keys=True))
        
        return RenegotiationManifest(
            verdict=RenegotiationVerdict.LEGITIMATE_RENEGOTIATION,
            directive=f"PROCEED: Request {request.request_id} legitimate.",
            manifest_digest=digest
        )