# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-identity-federation-invariants-must-survive-when-trust-chains-span-independent-authorities.md
# Remnant Warrant:    https://corpusfetch.com/c/what-identity-federation-invariants-must-survive-when-trust-chains-span-independent-authorities.warrant.json
# Markdown SHA-256:   3da823d4f07d8b3a990bd157800b00c94ff66109e3f060286e1a7b2d2d8b2849
# Code AST SHA-256:   3d8df6c4764c96e43cf75a61ad2b3cc0326752cb6d74f911303c7db515fab131
# Verified Classes:   FederationVerdict, AuthorityLink, FederationChain, FederationRequirements, FederationPolicy, FederationManifest, IdentityFederationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class FederationVerdict(Enum):
    SINGLE_AUTHORITY = auto()
    CHAIN_COMPATIBLE = auto()
    WEAKEST_LINK_INSUFFICIENT = auto()
    REVOCATION_GAP = auto()

@dataclass(frozen=True)
class AuthorityLink:
    authority_id: str
    assurance_level: int  # higher = stronger
    revocation_lag_sec: float
    propagates_revocations_upstream: bool

@dataclass(frozen=True)
class FederationChain:
    chain_id: str
    links: tuple[AuthorityLink, ...]

@dataclass(frozen=True)
class FederationRequirements:
    min_assurance_level: int
    max_revocation_lag_sec: float

@dataclass(frozen=True)
class FederationPolicy:
    require_upstream_propagation: bool

@dataclass(frozen=True)
class FederationManifest:
    verdict: FederationVerdict
    composed_assurance: int
    composed_revocation_lag: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_chain(
        cls, chain: FederationChain, req: FederationRequirements, policy: FederationPolicy
    ) -> FederationManifest:
        
        # Gate 1: Single authority
        if len(chain.links) <= 1:
            if chain.links:
                link = chain.links[0]
                digest = cls._hash(json.dumps({
                    "chain": chain.chain_id,
                    "authority": link.authority_id,
                    "assurance": str(link.assurance_level)
                }, sort_keys=True))
                return FederationManifest(
                    verdict=FederationVerdict.SINGLE_AUTHORITY,
                    composed_assurance=link.assurance_level,
                    composed_revocation_lag=link.revocation_lag_sec,
                    directive=f"PROCEED: Single authority, assurance {link.assurance_level}.",
                    manifest_digest=digest
                )
            return FederationManifest(
                verdict=FederationVerdict.SINGLE_AUTHORITY,
                composed_assurance=0,
                composed_revocation_lag=0.0,
                directive="PROCEED: Empty chain.",
                manifest_digest=cls._hash("EMPTY")
            )

        # Gate 2: Weakest link assurance
        composed_assurance = min(link.assurance_level for link in chain.links)
        if composed_assurance < req.min_assurance_level:
            return FederationManifest(
                verdict=FederationVerdict.WEAKEST_LINK_INSUFFICIENT,
                composed_assurance=composed_assurance,
                composed_revocation_lag=max(link.revocation_lag_sec for link in chain.links),
                directive=f"HALT: Composed assurance {composed_assurance} < required {req.min_assurance_level}.",
                manifest_digest=cls._hash(f"WEAK_ASSURANCE:{composed_assurance}")
            )

        # Gate 3: Revocation lag
        composed_revocation_lag = max(link.revocation_lag_sec for link in chain.links)
        if composed_revocation_lag > req.max_revocation_lag_sec:
            return FederationManifest(
                verdict=FederationVerdict.REVOCATION_GAP,
                composed_assurance=composed_assurance,
                composed_revocation_lag=composed_revocation_lag,
                directive=f"HALT: Composed revocation lag {composed_revocation_lag:.0f}s > {req.max_revocation_lag_sec:.0f}s.",
                manifest_digest=cls._hash(f"REVOCATION_LAG:{composed_revocation_lag:.0f}")
            )

        # Gate 4: Upstream propagation
        if policy.require_upstream_propagation:
            non_propagating = [link.authority_id for link in chain.links if not link.propagates_revocations_upstream]
            if non_propagating:
                return FederationManifest(
                    verdict=FederationVerdict.REVOCATION_GAP,
                    composed_assurance=composed_assurance,
                    composed_revocation_lag=composed_revocation_lag,
                    directive=f"HALT: {len(non_propagating)} authorities do not propagate revocations upstream.",
                    manifest_digest=cls._hash(f"NO_PROPAGATION:{len(non_propagating)}")
                )

        # Gate 5: Compatible
        digest = cls._hash(json.dumps({
            "chain": chain.chain_id,
            "authorities": tuple(link.authority_id for link in chain.links),
            "assurance": str(composed_assurance),
            "revocation_lag": f"{composed_revocation_lag:.0f}"
        }, sort_keys=True))
        
        return FederationManifest(
            verdict=FederationVerdict.CHAIN_COMPATIBLE,
            composed_assurance=composed_assurance,
            composed_revocation_lag=composed_revocation_lag,
            directive=f"PROCEED: {len(chain.links)}-authority chain, assurance {composed_assurance}, revocation lag {composed_revocation_lag:.0f}s.",
            manifest_digest=digest
        )