# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-time-bound-jurisdictional-constraints-that-conflict-across-regions.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-time-bound-jurisdictional-constraints-that-conflict-across-regions.warrant.json
# Markdown SHA-256:   02de2ddc4db690722e09fb32431af3414ac6e5f767e651a6a8e5e8e1ccd8e997
# Code AST SHA-256:   9d61683a5926e04ed630f7639e2a49b3a2a7628168e1dbc93e3bbfda3e8d0d0e
# Verified Classes:   ConflictVerdict, JurisdictionalConstraint, ConflictResolutionContext, ConflictManifest, JurisdictionalConflictGuard
# Defensive Guards:   1 fail-closed invariants (zero external deps)

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

class ConflictVerdict(Enum):
    NO_CONFLICT = auto()
    RESOLVED_BY_POLICY = auto()
    ESCALATED_NO_POLICY = auto()

@dataclass(frozen=True)
class JurisdictionalConstraint:
    jurisdiction: str
    constraint_type: str  # "RETENTION_MIN", "RETENTION_MAX", "PROCESSING_WINDOW", "NOTIFICATION_DEADLINE"
    constraint_value: float
    regulation_citation: str

@dataclass(frozen=True)
class ConflictResolutionContext:
    constraints: tuple[JurisdictionalConstraint, ...]
    conflict_policy_signature: str | None
    policy_strategy: str | None  # "MOST_RESTRICTIVE" | "EXPLICIT_OVERRIDE"

@dataclass(frozen=True)
class ConflictManifest:
    verdict: ConflictVerdict
    applied_constraint: JurisdictionalConstraint | None
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_constraints(
        cls, ctx: ConflictResolutionContext
    ) -> ConflictManifest:
        
        if not ctx.constraints:
            raise ValueError("At least one constraint required.")

        # Gate 1: Group by type
        by_type: dict[str, list[JurisdictionalConstraint]] = {}
        for c in ctx.constraints:
            by_type.setdefault(c.constraint_type, []).append(c)

        # Gate 2: Detect conflict within any type
        conflicts_detected = False
        for ctype, cgroup in by_type.items():
            if len(cgroup) <= 1:
                continue
            if ctype == "RETENTION_MIN" and len({c.constraint_value for c in cgroup}) > 1:
                conflicts_detected = True
            elif ctype == "RETENTION_MAX" and len({c.constraint_value for c in cgroup}) > 1:
                conflicts_detected = True
            elif ctype in ("PROCESSING_WINDOW", "NOTIFICATION_DEADLINE") and len({c.constraint_value for c in cgroup}) > 1:
                conflicts_detected = True

        # Gate 3: No conflict
        if not conflicts_detected:
            digest = cls._hash(json.dumps({
                "constraints": tuple(
                    {"type": c.constraint_type, "value": str(c.constraint_value), "jur": c.jurisdiction}
                    for c in ctx.constraints
                )
            }, sort_keys=True))
            return ConflictManifest(
                verdict=ConflictVerdict.NO_CONFLICT,
                applied_constraint=None,
                directive="PROCEED: All constraints compatible.",
                manifest_digest=digest
            )

        # Gate 4: Conflict but no policy
        if not ctx.conflict_policy_signature or not ctx.policy_strategy:
            return ConflictManifest(
                verdict=ConflictVerdict.ESCALATED_NO_POLICY,
                applied_constraint=None,
                directive="HALT: Conflict detected but no resolution policy. Escalate to legal.",
                manifest_digest=cls._hash("NO_POLICY")
            )

        # Gate 5: Apply policy - most restrictive
        if ctx.policy_strategy == "MOST_RESTRICTIVE":
            applied = None
            for ctype, cgroup in by_type.items():
                if ctype == "RETENTION_MIN":
                    applied = max(cgroup, key=lambda c: c.constraint_value)
                elif ctype == "RETENTION_MAX":
                    applied = min(cgroup, key=lambda c: c.constraint_value)
                elif ctype in ("PROCESSING_WINDOW", "NOTIFICATION_DEADLINE"):
                    applied = min(cgroup, key=lambda c: c.constraint_value)
                if applied:
                    break
            if applied:
                digest = cls._hash(json.dumps({
                    "strategy": "MOST_RESTRICTIVE",
                    "applied": applied.jurisdiction,
                    "value": str(applied.constraint_value),
                    "citation": applied.regulation_citation
                }, sort_keys=True))
                return ConflictManifest(
                    verdict=ConflictVerdict.RESOLVED_BY_POLICY,
                    applied_constraint=applied,
                    directive=f"PROCEED: Applied most restrictive ({applied.jurisdiction}, {applied.constraint_value}).",
                    manifest_digest=digest
                )

        # Gate 6: Fallback
        return ConflictManifest(
            verdict=ConflictVerdict.ESCALATED_NO_POLICY,
            applied_constraint=None,
            directive=f"HALT: Policy strategy {ctx.policy_strategy} unresolved. Escalate.",
            manifest_digest=cls._hash(f"UNRESOLVED:{ctx.policy_strategy}")
        )