┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN TYPES FOR ENTERPRISE                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  PUBLIC BLOCKCHAIN                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Permissionless, anyone can join                                   │   │
│  │ • Fully decentralised                                                │   │
│  │ • High security, high transparency                                   │   │
│  │ • Examples: Bitcoin, Ethereum                                       │   │
│  │ • Best for: Cryptocurrency, DeFi, open ecosystems                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  PRIVATE BLOCKCHAIN                                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Permissioned, single organisation controls                       │   │
│  │ • Centralised or partially decentralised                            │   │
│  │ • High performance, high privacy                                    │   │
│  │ • Examples: Internal Hyperledger Fabric network                    │   │
│  │ • Best for: Internal audits, intra-organisational workflows        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  CONSORTIUM BLOCKCHAIN                                                     │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Permissioned, multiple organisations govern                       │   │
│  │ • Shared trust model                                                 │   │
│  │ • Balance of performance and decentralisation                       │   │
│  │ • Examples: TradeLens, R3 Corda networks                           │   │
│  │ • Best for: Industry consortia, supply chain, trade finance        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    HYPERLEDGER FABRIC ARCHITECTURE                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    APPLICATION LAYER                                 │   │
│  │  • Client SDKs (Node.js, Java)                                      │   │
│  │  • REST APIs                                                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CHAINCODE (SMART CONTRACTS)                      │   │
│  │  • Business logic                                                   │   │
│  │  • Endorsement policies                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CONSENSUS & ORDERING SERVICE                     │   │
│  │  • Raft, Kafka, BFT                                                 │   │
│  │  • Transaction ordering                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MEMBERSHIP SERVICES                              │   │
│  │  • Certificate Authority (CA)                                       │   │
│  │  • Identity management                                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 4, LESSON 8: ENTERPRISE BLOCKCHAIN SOLUTIONS
# ===================================================================

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

print("="*70)
print("ENTERPRISE BLOCKCHAIN SOLUTIONS")
print("="*70)

# ----------------------------------------------------------------
# PART A: PERMISSIONED NETWORK SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Permissioned Network Simulation")
print("-"*60)

class PermissionedNode:
    """Simulated node in a permissioned blockchain network."""
    def __init__(self, node_id: str, organisation: str, role: str = 'peer'):
        self.node_id = node_id
        self.organisation = organisation
        self.role = role  # 'peer', 'orderer', 'validator'
        self.ledger = []
        self.transactions = []
        self.is_authorised = True
    
    def submit_transaction(self, tx_data: Dict) -> str:
        """Submit a transaction to the node."""
        tx_id = hashlib.sha256(f"{tx_data}{time.time()}".encode()).hexdigest()[:16]
        tx = {
            'id': tx_id,
            'data': tx_data,
            'timestamp': time.time(),
            'status': 'pending'
        }
        self.transactions.append(tx)
        print(f"Node {self.node_id} ({self.organisation}) submitted tx: {tx_id}")
        return tx_id
    
    def validate_transaction(self, tx_id: str) -> bool:
        """Simulate validation of a transaction."""
        tx = next((t for t in self.transactions if t['id'] == tx_id), None)
        if not tx:
            return False
        # Simulate validation
        is_valid = random.random() > 0.05
        tx['status'] = 'validated' if is_valid else 'invalid'
        return is_valid
    
    def commit_transaction(self, tx_id: str) -> bool:
        """Commit transaction to ledger."""
        tx = next((t for t in self.transactions if t['id'] == tx_id), None)
        if not tx:
            return False
        if tx['status'] != 'validated':
            return False
        
        self.ledger.append(tx)
        tx['status'] = 'committed'
        print(f"Node {self.node_id} committed tx: {tx_id}")
        return True

class PermissionedNetwork:
    """Simulated permissioned blockchain network."""
    def __init__(self, name: str):
        self.name = name
        self.nodes: Dict[str, PermissionedNode] = {}
        self.consensus_mechanism = 'PBFT'  # simulated
        self.ledger = []
        self.active = True
    
    def add_node(self, node_id: str, organisation: str, role: str = 'peer') -> None:
        node = PermissionedNode(node_id, organisation, role)
        self.nodes[node_id] = node
        print(f"Added node {node_id} from {organisation}")
    
    def propose_transaction(self, node_id: str, tx_data: Dict) -> str:
        node = self.nodes.get(node_id)
        if not node:
            print(f"Node {node_id} not found")
            return None
        return node.submit_transaction(tx_data)
    
    def validate_transaction(self, tx_id: str) -> bool:
        """Simulate consensus validation across nodes."""
        print(f"Validating tx {tx_id} across network...")
        valid_nodes = 0
        total_nodes = len(self.nodes)
        
        for node_id, node in self.nodes.items():
            if node.validate_transaction(tx_id):
                valid_nodes += 1
        
        # PBFT-like: require 2/3 majority
        is_consensus = valid_nodes >= (2 * total_nodes / 3)
        print(f"  {valid_nodes}/{total_nodes} nodes validated")
        return is_consensus
    
    def commit_transaction(self, tx_id: str) -> bool:
        """Commit transaction after consensus."""
        print(f"Committing tx {tx_id}...")
        committed = False
        for node_id, node in self.nodes.items():
            if node.commit_transaction(tx_id):
                committed = True
                # Record to network ledger
                tx = next((t for t in node.ledger if t['id'] == tx_id), None)
                if tx and tx not in self.ledger:
                    self.ledger.append(tx)
        return committed

# Create network
network = PermissionedNetwork("Enterprise Consortium")

print("Building Permissioned Network...")
network.add_node("Org1_Peer0", "Bank A", "peer")
network.add_node("Org1_Peer1", "Bank A", "peer")
network.add_node("Org2_Peer0", "Bank B", "peer")
network.add_node("Org3_Peer0", "Insurance Co", "peer")
network.add_node("Orderer0", "Consortium", "orderer")

# Submit transaction
tx_id = network.propose_transaction("Org1_Peer0", {
    'type': 'trade_finance',
    'buyer': 'Bank A',
    'seller': 'Bank B',
    'amount': 1000000,
    'asset': 'USD'
})

if tx_id:
    # Validate
    if network.validate_transaction(tx_id):
        # Commit
        network.commit_transaction(tx_id)

print(f"\nNetwork Ledger Size: {len(network.ledger)} transactions")

# ----------------------------------------------------------------
# PART B: ENTERPRISE PLATFORM COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Enterprise Platform Comparison")
print("-"*60)

platform_data = {
    'Platform': ['Hyperledger Fabric', 'Corda', 'Quorum', 'Hedera Hashgraph', 'IBM Blockchain'],
    'Governance': ['Consortium/Private', 'Consortium', 'Private/Consortium', 'Public/Private', 'Consortium'],
    'Smart Contract Language': ['Go, Java, Node.js', 'Kotlin, Java', 'Solidity', 'Java/Go', 'Go, Java, Node.js'],
    'Privacy': ['Channels', 'Private transactions', 'Private transactions', 'Through consensus', 'Channels'],
    'Performance (TPS)': ['3,000+', '500+', '1,000+', '10,000+', '3,000+'],
    'Use Case': ['General enterprise', 'Finance', 'Finance', 'General', 'General enterprise']
}

platform_df = pd.DataFrame(platform_data)
print(platform_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: ENTERPRISE USE CASES
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Enterprise Use Cases")
print("-"*60)

use_cases = {
    "Trade Finance": {
        "Description": "Streamline LCs, invoice financing, and supply chain trade.",
        "Platforms": ["Corda", "Hyperledger Fabric"],
        "Benefits": ["Reduced time from days to hours", "Lower fraud risk"]
    },
    "Supply Chain": {
        "Description": "Track goods from origin to consumer with immutability.",
        "Platforms": ["Hyperledger Fabric", "IBM Blockchain"],
        "Benefits": ["Traceability", "Counterfeit prevention", "Efficiency"]
    },
    "Asset Management": {
        "Description": "Tokenise and trade real-world assets.",
        "Platforms": ["Quorum", "Hyperledger Fabric"],
        "Benefits": ["Liquidity", "Fractional ownership", "Transparency"]
    },
    "Identity Management": {
        "Description": "Self-sovereign identity and KYC/AML.",
        "Platforms": ["Hyperledger Indy", "Sovrin"],
        "Benefits": ["Privacy", "Reduced duplication", "Security"]
    },
    "Insurance": {
        "Description": "Parametric insurance, claims processing.",
        "Platforms": ["Corda", "Hyperledger Fabric"],
        "Benefits": ["Automated claims", "Fraud reduction", "Transparency"]
    }
}

for use_case, details in use_cases.items():
    print(f"\n{use_case.upper()}:")
    print(f"  Description: {details['Description']}")
    print(f"  Platforms: {', '.join(details['Platforms'])}")
    print(f"  Benefits: {', '.join(details['Benefits'])}")

# ----------------------------------------------------------------
# PART D: INTEGRATION PATTERNS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Integration Patterns")
print("-"*60)

integration_data = {
    'Pattern': ['API Gateway', 'Event-Driven', 'Batch Processing', 'Data Mirroring'],
    'Description': [
        'Expose blockchain as REST/GraphQL APIs',
        'React to on-chain events',
        'Periodic reconciliation',
        'Copy on-chain data to off-chain DB'
    ],
    'Use Case': [
        'Supply chain status updates',
        'Trigger off-chain workflows',
        'Settlement reporting',
        'Analytics, reporting'
    ],
    'Complexity': ['Medium', 'Medium', 'Low', 'High']
}

integration_df = pd.DataFrame(integration_data)
print(integration_df.to_string(index=False))

# ----------------------------------------------------------------
# PART E: SELECTION FRAMEWORK
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Enterprise Blockchain Selection Framework")
print("-"*60)

selection_framework = {
    "Criteria": [
        "Privacy requirement",
        "Performance (TPS)",
        "Number of participants",
        "Regulatory environment",
        "Existing technical skills",
        "Budget",
        "Time to market"
    ],
    "Hyperledger Fabric": [
        "High",
        "High (3K+)",
        "Large",
        "Enterprise-friendly",
        "Go/Java",
        "Medium-High",
        "Medium"
    ],
    "Corda": [
        "Very High (private)",
        "Medium (500+)",
        "Medium",
        "Finance-focused",
        "Kotlin/Java",
        "High",
        "Medium"
    ],
    "Quorum": [
        "High",
        "Medium (1K+)",
        "Medium",
        "Finance-friendly",
        "Solidity",
        "Medium",
        "Fast"
    ],
    "Public (Ethereum)": [
        "Low (public)",
        "Low (30)",
        "Unlimited",
        "Regulated",
        "Solidity",
        "Low",
        "Fast"
    ]
}

selection_df = pd.DataFrame(selection_framework)
print(selection_df.to_string(index=False))

# ----------------------------------------------------------------
# PART F: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

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

print("""
Enterprise Blockchain Solutions – Key Takeaways:

1. Enterprise blockchains are permissioned, private, and designed for business.
2. Types: private (single organisation), consortium (multiple organisations).
3. Major platforms: Hyperledger Fabric, Corda, Quorum.
4. Hyperledger Fabric: modular, general purpose, channels for privacy.
5. Corda: finance-focused, private transactions, legal enforceability.
6. Quorum: Ethereum-based, EVM compatibility, private transactions.
7. Integration: API gateways, event-driven, batch processing.
8. Governance: member onboarding, policy enforcement, dispute resolution.

Selection Framework:
  - Need privacy? → Corda (private transactions) or Fabric (channels).
  - Need high TPS? → Fabric or public high-TPS chains.
  - Need EVM compatibility? → Quorum.
  - Financial use case? → Corda.
  - General enterprise? → Hyperledger Fabric.
  - Low cost / open ecosystem? → Public Ethereum with Layer 2.
""")