# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-identity-fragmentation-when-the-same-principal-appears-under-multiple-ids.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-identity-fragmentation-when-the-same-principal-appears-under-multiple-ids.warrant.json
# Markdown SHA-256:   12af617c63258928ccbe861da6cf0fc94bff1d782e2b31176e63600e2e19e327
# Code AST SHA-256:   c46e67e4d5836b2878f0c412d91d6f142d1d3d4eac19b4d9d65fe0ce20c8f3d0
# Verified Classes:   IdentityVerdict, IdentityRecord, IdentityContext, IdentityPolicy, IdentityManifest, IdentityFragmentationGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

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

class IdentityVerdict(Enum):
    DISTINCT_PRINCIPAL = auto()
    UNIFIED_WITH_HISTORY = auto()
    FRAGMENTATION_ATTACK_RISK = auto()
    UNVERIFIED_BINDING = auto()

@dataclass(frozen=True)
class IdentityRecord:
    identity_string: str
    principal_id: str | None
    binding_receipt: str | None
    transition_chain: tuple[str, ...]
    scope_attestation: str | None

@dataclass(frozen=True)
class IdentityContext:
    existing_identities_for_principal: frozenset[str]
    prior_trust_score: float

@dataclass(frozen=True)
class IdentityPolicy:
    require_binding: bool
    min_identities_for_attack_flag: int

@dataclass(frozen=True)
class IdentityManifest:
    verdict: IdentityVerdict
    unified_trust_score: float
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_identity(
        cls, record: IdentityRecord, ctx: IdentityContext, policy: IdentityPolicy
    ) -> IdentityManifest:
        
        # Gate 1: No binding
        if policy.require_binding and not record.binding_receipt:
            return IdentityManifest(
                verdict=IdentityVerdict.UNVERIFIED_BINDING,
                unified_trust_score=0.0,
                directive=f"HALT: Identity {record.identity_string} lacks binding receipt.",
                manifest_digest=cls._hash(f"NO_BINDING:{record.identity_string}")
            )

        # Gate 2: No principal
        if not record.principal_id:
            digest = cls._hash(json.dumps({
                "identity": record.identity_string,
                "principal": "UNKNOWN"
            }, sort_keys=True))
            return IdentityManifest(
                verdict=IdentityVerdict.DISTINCT_PRINCIPAL,
                unified_trust_score=0.0,
                directive=f"PROCEED: Identity {record.identity_string} treated as distinct principal.",
                manifest_digest=digest
            )

        # Gate 3: Fragmentation attack detection
        identity_count = len(ctx.existing_identities_for_principal) + 1
        if identity_count > policy.min_identities_for_attack_flag:
            if not record.transition_chain:
                return IdentityManifest(
                    verdict=IdentityVerdict.FRAGMENTATION_ATTACK_RISK,
                    unified_trust_score=0.0,
                    directive=f"HALT: Principal {record.principal_id} has {identity_count} identities without transition chains.",
                    manifest_digest=cls._hash(f"ATTACK_RISK:{record.principal_id}")
                )

        # Gate 4: Unified
        unified_trust = ctx.prior_trust_score  # Preserved across identities
        digest = cls._hash(json.dumps({
            "identity": record.identity_string,
            "principal": record.principal_id,
            "prior_identities": tuple(sorted(ctx.existing_identities_for_principal)),
            "unified_trust": f"{unified_trust:.3f}"
        }, sort_keys=True))
        
        return IdentityManifest(
            verdict=IdentityVerdict.UNIFIED_WITH_HISTORY,
            unified_trust_score=unified_trust,
            directive=f"PROCEED: Identity {record.identity_string} unified with principal {record.principal_id}, trust {unified_trust:.2f}.",
            manifest_digest=digest
        )