# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-hedge-requests-without-double-paying-for-cancelled-hedges.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-hedge-requests-without-double-paying-for-cancelled-hedges.warrant.json
# Markdown SHA-256:   ae2beaf0b9f6d0ebe221cb8127b83a3e21651f716105257851da4b528e225fbc
# Code AST SHA-256:   f3251f89bf7ff0185e3c8441f3b0dc0d88f9c10dba75ec729f12c7a7f4a5ccef
# Verified Classes:   HedgeVerdict, HedgeRequest, HedgePolicy, HedgeManifest, HedgingAccountingGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class HedgeVerdict(Enum):
    NO_HEDGE = auto()
    HEDGE_VALID = auto()
    HEDGE_WINNER_UNDECLARED = auto()
    HEDGE_CANCELLATION_INCOMPLETE = auto()

@dataclass(frozen=True)
class HedgeRequest:
    request_id: str
    hedge_group_id: str | None
    downstream_idempotency_key: str | None
    is_winner: bool
    winner_signature_sent: bool

@dataclass(frozen=True)
class HedgePolicy:
    require_group_id: bool
    require_cancellation_receipt: bool

@dataclass(frozen=True)
class HedgeManifest:
    verdict: HedgeVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_hedge(
        cls, request: HedgeRequest, policy: HedgePolicy
    ) -> HedgeManifest:
        
        # Gate 1: Not hedged
        if not request.hedge_group_id:
            digest = cls._hash(json.dumps({
                "request": request.request_id,
                "hedge": "NONE"
            }, sort_keys=True))
            return HedgeManifest(
                verdict=HedgeVerdict.NO_HEDGE,
                directive=f"PROCEED: Request {request.request_id} not hedged.",
                manifest_digest=digest
            )

        # Gate 2: Group ID + idempotency key
        if policy.require_group_id:
            if not request.downstream_idempotency_key:
                return HedgeManifest(
                    verdict=HedgeVerdict.HEDGE_WINNER_UNDECLARED,
                    directive=f"HALT: Hedge {request.request_id} lacks downstream idempotency key.",
                    manifest_digest=cls._hash(f"NO_IDEM_KEY:{request.request_id}")
                )

        # Gate 3: Winner signature requirement
        if not request.is_winner and not request.winner_signature_sent:
            if policy.require_cancellation_receipt:
                return HedgeManifest(
                    verdict=HedgeVerdict.HEDGE_CANCELLATION_INCOMPLETE,
                    directive=f"HALT: Losing hedge {request.request_id} has no winner signature. Cannot cancel.",
                    manifest_digest=cls._hash(f"NO_WINNER:{request.request_id}")
                )

        # Gate 4: Valid
        digest = cls._hash(json.dumps({
            "request": request.request_id,
            "group": request.hedge_group_id,
            "idem_key": request.downstream_idempotency_key,
            "winner": str(request.is_winner)
        }, sort_keys=True))
        
        return HedgeManifest(
            verdict=HedgeVerdict.HEDGE_VALID,
            directive=f"PROCEED: Hedge {request.request_id} properly accounted.",
            manifest_digest=digest
        )