┌─────────────────────────────────────────────────────────────────────────────┐
│                    PROTOCOL LAYERING                                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Application Protocol   │  Smart contracts, DApp interfaces                │
│  ─────────────────────┼───────────────────────────────────────────────────│
│  Consensus Protocol    │  Agreement on block state                        │
│  ─────────────────────┼───────────────────────────────────────────────────│
│  Data Protocol         │  Block and transaction formats                   │
│  ─────────────────────┼───────────────────────────────────────────────────│
│  Network Protocol      │  P2P communication, node discovery               │
│  ─────────────────────┼───────────────────────────────────────────────────│
│  Physical Protocol     │  Internet, connections                          │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 4, LESSON 1: BLOCKCHAIN NETWORKS AND PROTOCOLS
# ===================================================================

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

print("="*70)
print("BLOCKCHAIN NETWORKS AND PROTOCOLS")
print("="*70)

# ----------------------------------------------------------------
# PART A: NETWORK NODE SIMULATION
# ----------------------------------------------------------------

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

class BlockchainNode:
    """
    Simulated blockchain network node.
    """
    def __init__(self, node_id: str, node_type: str = 'full'):
        self.node_id = node_id
        self.node_type = node_type  # 'full', 'light', 'validator', 'miner'
        self.peers: Set[str] = set()
        self.transactions: List[Dict] = []
        self.blocks: List[Dict] = []
        self.connected_at = datetime.now()
        self.latency = random.uniform(10, 200)  # ms
        self.is_active = True
    
    def connect_to_peer(self, peer_id: str) -> None:
        """Connect to another node."""
        self.peers.add(peer_id)
        print(f"Node {self.node_id} connected to {peer_id}")
    
    def broadcast_transaction(self, transaction: Dict) -> None:
        """Broadcast a transaction to peers."""
        self.transactions.append(transaction)
        print(f"Node {self.node_id} broadcast transaction: {transaction.get('id', 'unknown')}")
    
    def receive_block(self, block: Dict) -> bool:
        """Receive and validate a block."""
        # Simulate validation
        is_valid = random.random() > 0.05  # 5% chance of invalid
        if is_valid:
            self.blocks.append(block)
            print(f"Node {self.node_id} received block #{block.get('index', '?')}")
        else:
            print(f"Node {self.node_id} rejected invalid block")
        return is_valid
    
    def get_status(self) -> Dict:
        return {
            'node_id': self.node_id,
            'type': self.node_type,
            'peers': len(self.peers),
            'transactions_processed': len(self.transactions),
            'blocks_received': len(self.blocks),
            'latency_ms': self.latency,
            'active': self.is_active
        }

class BlockchainNetwork:
    """
    Simulated blockchain network.
    """
    def __init__(self, network_id: str, network_type: str = 'mainnet'):
        self.network_id = network_id
        self.network_type = network_type  # 'mainnet', 'testnet', 'private'
        self.nodes: Dict[str, BlockchainNode] = {}
        self.blocks: List[Dict] = []
        self.transactions: List[Dict] = []
        self.network_latency = random.uniform(50, 500)  # ms
        self.created_at = datetime.now()
    
    def add_node(self, node_id: str, node_type: str = 'full') -> None:
        """Add a node to the network."""
        node = BlockchainNode(node_id, node_type)
        self.nodes[node_id] = node
        print(f"Added {node_type} node: {node_id}")
    
    def connect_nodes(self, node1_id: str, node2_id: str) -> None:
        """Connect two nodes."""
        if node1_id in self.nodes and node2_id in self.nodes:
            self.nodes[node1_id].connect_to_peer(node2_id)
            self.nodes[node2_id].connect_to_peer(node1_id)
    
    def create_p2p_network(self, connections_per_node: int = 3) -> None:
        """Create a P2P network topology."""
        node_ids = list(self.nodes.keys())
        if len(node_ids) < 2:
            return
        
        for i, node_id in enumerate(node_ids):
            # Connect to next n nodes
            for j in range(1, connections_per_node + 1):
                peer_id = node_ids[(i + j) % len(node_ids)]
                if peer_id != node_id:
                    self.connect_nodes(node_id, peer_id)
    
    def get_network_metrics(self) -> Dict:
        total_nodes = len(self.nodes)
        node_types = {}
        for node in self.nodes.values():
            node_types[node.node_type] = node_types.get(node.node_type, 0) + 1
        
        avg_peers = np.mean([len(n.peers) for n in self.nodes.values()]) if self.nodes else 0
        avg_latency = np.mean([n.latency for n in self.nodes.values()]) if self.nodes else 0
        
        return {
            'network_id': self.network_id,
            'network_type': self.network_type,
            'total_nodes': total_nodes,
            'node_types': node_types,
            'avg_peers_per_node': avg_peers,
            'avg_latency_ms': avg_latency,
            'blocks_produced': len(self.blocks),
            'transactions_processed': len(self.transactions)
        }

# Create network
network = BlockchainNetwork('NET-001', 'testnet')

# Add nodes
print("\nBuilding network topology...")
nodes = ['Node_A', 'Node_B', 'Node_C', 'Node_D', 'Node_E', 'Node_F', 'Node_G', 'Node_H']
node_types = ['full', 'full', 'validator', 'full', 'light', 'validator', 'full', 'light']

for node_id, node_type in zip(nodes, node_types):
    network.add_node(node_id, node_type)

# Create connections
network.create_p2p_network(connections_per_node=3)

# Show network metrics
metrics = network.get_network_metrics()
print("\nNetwork Metrics:")
print(f"  Network ID: {metrics['network_id']}")
print(f"  Network Type: {metrics['network_type']}")
print(f"  Total Nodes: {metrics['total_nodes']}")
print(f"  Node Types: {metrics['node_types']}")
print(f"  Avg Peers per Node: {metrics['avg_peers_per_node']:.1f}")
print(f"  Avg Latency: {metrics['avg_latency_ms']:.0f}ms")

# ----------------------------------------------------------------
# PART B: NETWORK TOPOLOGY VISUALISATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Network Topology Visualisation")
print("-"*60)

# Simulate different topologies
topologies = {
    'Full Mesh': {
        'connections_per_node': len(nodes) - 1,
        'latency': 50,
        'redundancy': 'Very High'
    },
    'Ring': {
        'connections_per_node': 2,
        'latency': 100,
        'redundancy': 'Low'
    },
    'Star': {
        'connections_per_node': 1,  # Actually varies
        'latency': 80,
        'redundancy': 'Medium'
    },
    'Hybrid': {
        'connections_per_node': 4,
        'latency': 70,
        'redundancy': 'High'
    }
}

topology_data = []
for name, details in topologies.items():
    topology_data.append({
        'Topology': name,
        'Connections per Node': details['connections_per_node'],
        'Latency (ms)': details['latency'],
        'Redundancy': details['redundancy']
    })

topology_df = pd.DataFrame(topology_data)
print(topology_df.to_string(index=False))

# Visualise topology metrics
fig, ax = plt.subplots(figsize=(10, 5))
ax.scatter(topology_df['Connections per Node'], topology_df['Latency (ms)'], 
           s=200, c=range(len(topology_df)), cmap='coolwarm')
for i, row in topology_df.iterrows():
    ax.annotate(row['Topology'], (row['Connections per Node'], row['Latency (ms)']),
                xytext=(10, 10), textcoords='offset points', fontsize=10)
ax.set_xlabel('Connections per Node')
ax.set_ylabel('Latency (ms)')
ax.set_title('Network Topology Trade-offs')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('network_topologies.png', dpi=300, bbox_inches='tight')
plt.show()
print("Network topology chart saved as 'network_topologies.png'")

# ----------------------------------------------------------------
# PART C: PROTOCOL COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Blockchain Protocol Comparison")
print("-"*60)

protocol_comparison = pd.DataFrame({
    'Protocol': ['Nakamoto (PoW)', 'Gasper (PoS)', 'HotStuff', 'Avalanche', 'PBFT'],
    'Finality': ['Probabilistic', 'Final', 'Final', 'Final', 'Final'],
    'Block Time': ['10 min', '12 sec', '1-5 sec', '1-2 sec', '1-2 sec'],
    'TPS': ['7', '30-100', '1000+', '4500', '1000+'],
    'Nodes': ['10,000+', '10,000+', '100-1000', '1000+', '10-100'],
    'Fault Tolerance': ['High', 'High', 'Medium', 'High', 'Medium']
})

print(protocol_comparison.to_string(index=False))

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

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

print("""
Blockchain Networks and Protocols – Key Takeaways:

1. Blockchain infrastructure is layered: Network → Consensus → Data → Application → Governance.
2. P2P networks are decentralised, resilient, and self-organising.
3. Network types: mainnet (production), testnet (development), private, and consortium.
4. Protocols define communication, consensus, and data exchange rules.
5. Node types: full, light, validator/miner, and archival.
6. Node-as-a-Service providers simplify infrastructure management.
7. Infrastructure services: APIs, indexing, data availability, Layer 2 solutions.

Infrastructure Selection Framework:
  - Consider: performance needs, security requirements, cost constraints, and technical expertise.
  - Evaluate: latency, throughput, availability, and decentralisation.
  - For production: use reliable NaaS providers with redundancy.
  - For development: use testnets and local environments.
  - For enterprise: consider private or consortium networks.
""")

print("="*70)
print("END OF LESSON 1 – MODULE 4")
print("="*70)