┌─────────────────────────────────────────────────────────────────────────────┐
│                    EVOLUTION OF IDENTITY PARADIGMS                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. CENTRALISED IDENTITY                                                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Identity controlled by a single authority                         │   │
│  │ • User has no control over data                                     │   │
│  │ • Examples: Government IDs, Facebook login                          │   │
│  │ • Timeframe: 1990s-2010s                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. FEDERATED IDENTITY                                                     │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Identity shared across multiple organisations                     │   │
│  │ • User has some control                                             │   │
│  │ • Examples: SAML, OAuth, OpenID Connect                             │   │
│  │ • Timeframe: 2010s-2020s                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. SELF-SOVEREIGN IDENTITY (SSI)                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • User owns and controls their identity data                       │   │
│  │ • Decentralised, no single authority                               │   │
│  │ • Examples: DID, Verifiable Credentials                           │   │
│  │ • Timeframe: 2020s+                                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    ZERO-KNOWLEDGE PROOF CONCEPT                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  PROVER                                                                     │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ "I know the secret"                                                 │   │
│  │ "I am over 18"                                                      │   │
│  │ "I have sufficient funds"                                          │   │
│  │                                                                     │   │
│  │ ➡️ ZKP Generated                                                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ZERO-KNOWLEDGE PROOF                             │   │
│  │  • Statement is true                                                │   │
│  │  • No information about the secret is revealed                     │   │
│  │  • Proof is verifiable                                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  VERIFIER                                                                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ "I trust the statement is true"                                     │   │
│  │ "I don't know the secret"                                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    DECENTRALISED IDENTITY ECOSYSTEM                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    USER (HOLDER)                                    │   │
│  │  • Owns their identity data                                        │   │
│  │  • Controls access and consent                                     │   │
│  │  • Stores credentials in a wallet                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                    ┌───────────────┼───────────────┐                      │
│                    v               v               v                      │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐        │
│  │   ISSUER         │  │   VERIFIER       │  │   BLOCKCHAIN     │        │
│  │  • Issues        │  │  • Verifies      │  │  • Registry of   │        │
│  │    credentials   │  │    credentials   │  │    DIDs          │        │
│  │  • Trusted       │  │  • Checks        │  │  • Immutable     │        │
│  │    authority     │  │    authenticity  │  │    records       │        │
│  └──────────────────┘  └──────────────────┘  └──────────────────┘        │
│                                                                             │
│  Key Interactions:                                                          │
│  1. Issuer issues credential to User (Holder)                             │
│  2. User presents credential to Verifier                                  │
│  3. Verifier checks credential against blockchain                         │
│  4. User controls data sharing                                            │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 8, LESSON 7: DIGITAL IDENTITY AND PRIVACY IN THE FUTURE
# ===================================================================

import hashlib
import random
import time
from typing import Dict, List, Tuple
import pandas as pd
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("DIGITAL IDENTITY AND PRIVACY IN THE FUTURE")
print("="*70)

# ----------------------------------------------------------------
# PART A: ZERO-KNOWLEDGE PROOF SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Zero-Knowledge Proof Simulation (Age Verification)")
print("-"*60)

class ZeroKnowledgeProof:
    """
    Simplified ZKP simulation for age verification.
    """
    def __init__(self):
        self.secret_value = None
        self.commitment = None
        self.proof = None
    
    def commit(self, secret: int, public_parameter: int) -> Tuple[int, int]:
        """Commit to a secret value."""
        self.secret_value = secret
        # Simplified commitment: hash(secret + public_parameter)
        commitment = hashlib.sha256(f"{secret}{public_parameter}".encode()).hexdigest()
        self.commitment = commitment
        return commitment
    
    def prove_age(self, age: int, public_parameter: int, threshold: int = 18) -> Dict:
        """Prove that age is above threshold without revealing exact age."""
        self.secret_value = age
        
        # Create proof that age >= threshold
        proof_data = f"age_{age}_threshold_{threshold}_{public_parameter}"
        proof = hashlib.sha256(proof_data.encode()).hexdigest()
        
        # Simulate ZKP: we reveal the proof and a hashed version of age
        self.proof = {
            'proof': proof,
            'hash_secret': hashlib.sha256(f"{age}_{public_parameter}".encode()).hexdigest(),
            'threshold': threshold,
            'public_parameter': public_parameter
        }
        
        return self.proof
    
    def verify_proof(self, proof: Dict, threshold: int = 18) -> bool:
        """Verify the zero-knowledge proof."""
        # In a real ZKP, the verifier would not know the secret
        # This is a simplified simulation
        proof_hash = proof.get('proof')
        hash_secret = proof.get('hash_secret')
        public_param = proof.get('public_parameter')
        verified_threshold = proof.get('threshold', threshold)
        
        # Verify the proof by checking consistency
        # In a real system, this would be a cryptographic verification
        verification_data = f"age_{self.secret_value}_{public_param}" if self.secret_value else ""
        expected_hash = hashlib.sha256(f"age_{self.secret_value}_threshold_{verified_threshold}_{public_param}".encode()).hexdigest()
        
        return proof_hash == expected_hash

# Simulate ZKP age verification
zkp = ZeroKnowledgeProof()

print("Zero-Knowledge Proof Age Verification Simulation:")

# Alice is 21 years old
alice_age = 21
public_param = random.randint(1000, 9999)

print(f"Alice is {alice_age} years old (she wants to prove she's over 18)")

# Alice creates a proof
proof = zkp.prove_age(alice_age, public_param)
print(f"Proof created: {proof['proof'][:16]}...")

# Verifier checks the proof
is_valid = zkp.verify_proof(proof, threshold=18)
print(f"Verification result: {'✅ Valid' if is_valid else '❌ Invalid'}")
print("Note: The verifier does not know Alice's exact age")

# Bob is 16 years old
bob_age = 16
public_param = random.randint(1000, 9999)

print(f"\nBob is {bob_age} years old (he wants to prove he's over 18)")

# Bob creates a proof
zkp2 = ZeroKnowledgeProof()
proof_bob = zkp2.prove_age(bob_age, public_param)
print(f"Proof created: {proof_bob['proof'][:16]}...")

# Verifier checks the proof
is_valid_bob = zkp2.verify_proof(proof_bob, threshold=18)
print(f"Verification result: {'✅ Valid' if is_valid_bob else '❌ Invalid'}")
print("Bob cannot prove he is over 18")

# ----------------------------------------------------------------
# PART B: SSI ECOSYSTEM SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Self-Sovereign Identity Ecosystem Simulation")
print("-"*60)

class DID:
    """
    Simplified Decentralised Identifier.
    """
    def __init__(self, did_string: str):
        self.did = did_string
        self.documents = {}
        self.credentials = []
    
    def add_document(self, doc_type: str, doc_data: Dict):
        self.documents[doc_type] = doc_data
    
    def add_credential(self, credential: Dict):
        self.credentials.append(credential)
    
    def get_did_document(self) -> Dict:
        return {
            'id': self.did,
            'authentication': [f"{self.did}#keys-1"],
            'publicKey': [{
                'id': f"{self.did}#keys-1",
                'type': 'Ed25519VerificationKey2020',
                'publicKeyMultibase': 'z6MkpTHR8VNsBxYAAWHut2Geadd9jSwuBV8xRoAnwWsdvktH'
            }]
        }

class VerifiableCredential:
    """
    Simplified Verifiable Credential.
    """
    def __init__(self, issuer: str, subject: str, credential_type: str, claims: Dict):
        self.issuer = issuer
        self.subject = subject
        self.type = credential_type
        self.claims = claims
        self.id = f"vc-{hashlib.sha256(f'{issuer}{subject}{time.time()}'.encode()).hexdigest()[:8]}"
        self.issued = time.time()
        self.proof = self._generate_proof()
    
    def _generate_proof(self) -> Dict:
        proof_data = f"{self.issuer}{self.subject}{self.id}{self.issued}"
        signature = hashlib.sha256(proof_data.encode()).hexdigest()
        return {
            'type': 'Ed25519Signature2020',
            'created': self.issued,
            'verificationMethod': f"{self.issuer}#keys-1",
            'proofPurpose': 'assertionMethod',
            'signature': signature[:32] + '...'
        }
    
    def verify(self) -> bool:
        # Simplified verification
        expected = hashlib.sha256(f"{self.issuer}{self.subject}{self.id}{self.issued}".encode()).hexdigest()
        return self.proof['signature'] == expected[:32] + '...'

class IdentityWallet:
    """
    Simplified identity wallet.
    """
    def __init__(self, owner: str):
        self.owner = owner
        self.did = DID(f"did:identity:{owner}")
        self.credentials: List[VerifiableCredential] = []
    
    def add_credential(self, credential: VerifiableCredential):
        self.credentials.append(credential)
    
    def create_presentation(self, credential_types: List[str]) -> Dict:
        """Create a verifiable presentation of selected credentials."""
        selected = [c for c in self.credentials if c.type in credential_types]
        return {
            'holder': self.did.did,
            'verifiableCredential': [c.__dict__ for c in selected],
            'proof': {
                'type': 'Ed25519Signature2020',
                'created': time.time(),
                'verificationMethod': f"{self.did.did}#keys-1",
                'proofPurpose': 'authentication'
            }
        }

# Create ecosystem
print("Self-Sovereign Identity Ecosystem:")

# Government (Issuer)
gov_did = DID("did:gov:usa")
print(f"Government DID: {gov_did.did}")

# Alice (Holder)
alice_wallet = IdentityWallet("Alice")
print(f"Alice DID: {alice_wallet.did.did}")

# Issue credential
alice_credential = VerifiableCredential(
    issuer=gov_did.did,
    subject=alice_wallet.did.did,
    credential_type="PassportCredential",
    claims={
        'name': 'Alice Johnson',
        'date_of_birth': '1990-01-15',
        'passport_id': 'P12345678'
    }
)
alice_wallet.add_credential(alice_credential)
print(f"Credential issued: {alice_credential.type}")

# Verify credential
print(f"Credential verified: {alice_credential.verify()}")

# Create presentation
presentation = alice_wallet.create_presentation(['PassportCredential'])
print(f"Presentation created: {len(presentation['verifiableCredential'])} credential(s)")

print("\nCredential Summary:")
for cred in alice_wallet.credentials:
    print(f"  {cred.type}: {cred.claims['name']}")

# ----------------------------------------------------------------
# PART C: PRIVACY TECHNOLOGY COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Privacy Technology Comparison")
print("-"*60)

privacy_data = {
    'Technology': ['Zero-Knowledge Proofs', 'Homomorphic Encryption', 'Secure MPC', 'Differential Privacy', 'TEE'],
    'Privacy Level': ['High', 'Very High', 'Very High', 'Medium', 'High'],
    'Performance': ['Medium', 'Low', 'Low', 'High', 'High'],
    'Complexity': ['Medium', 'High', 'High', 'Medium', 'Medium'],
    'Adoption': ['Growing', 'Limited', 'Limited', 'Growing', 'Growing']
}

privacy_df = pd.DataFrame(privacy_data)
print(privacy_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

print("\n" + "="*70)
print("PART D: Summary and Recommendations")
print("="*70)

print("""
Digital Identity and Privacy in the Future – Key Takeaways:

1. Identity paradigms: centralised → federated → self-sovereign.
2. Self-Sovereign Identity: user controls their own identity data.
3. Zero-Knowledge Proofs: prove statements without revealing data.
4. ZKP applications: private transactions, KYC, credit scoring, compliance.
5. Decentralised Identity Ecosystem: DID, VC, ZKP, DKMS, DIDComm.
6. Privacy technologies: ZKP, homomorphic encryption, SMPC, differential privacy, TEE.
7. Privacy by Design: proactive, default, embedded, full functionality.

Recommendations:
  - Embrace Self-Sovereign Identity principles.
  - Implement Zero-Knowledge Proofs for privacy.
  - Design privacy-preserving systems.
  - Educate users on data control.
  - Stay updated on privacy regulations.
  - Balance privacy with compliance requirements.
""")