┌─────────────────────────────────────────────────────────────────────────────┐
│                    PROOF OF WORK – MINING PROCESS                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  Block Header                                                        │   │
│  │  ┌──────────────────────────────────────────────────────────────┐    │   │
│  │  │ Version  │ Prev Hash │ Merkle Root │ Timestamp │ Difficulty │    │   │
│  │  └──────────────────────────────────────────────────────────────┘    │   │
│  │                              +                                        │   │
│  │                     ┌────────────────────┐                          │   │
│  │                     │       NONCE        │  ← tweak this            │   │
│  │                     └────────────────────┘                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│                    Hash(Block Header) → must be < Target                   │
│                                                                             │
│  Example: Target = 0x00000000FFFFFFFF... (leading zeros)                   │
│  Miner tries nonce until hash starts with enough zeros.                    │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    CONSENSUS MECHANISM COMPARISON                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Mechanism    │ Permission │ Finality │ TPS │ Energy │ Decentralisation   │
│  ──────────── │ ───────────│──────────│─────│────────│─────────────────── │
│  PoW          │ Permissionless │ Probabilistic │ 10  │ High  │ High      │
│  PoS          │ Permissionless │ Final        │ 100 │ Low   │ Medium    │
│  DPoS         │ Permissionless │ Final        │1000 │ Low   │ Low-Med   │
│  PBFT         │ Permissioned   │ Final       │1000 │ Low   │ Low       │
│  PoA          │ Permissioned   │ Final       │2000 │ Low   │ Very Low  │
│  Avalanche    │ Permissionless │ Final        │4500 │ Low   │ High      │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 1, LESSON 3: CONSENSUS MECHANISMS
# ===================================================================

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

print("="*70)
print("CONSENSUS MECHANISMS")
print("="*70)

# ----------------------------------------------------------------
# PART A: PROOF OF WORK SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Proof of Work Simulation")
print("-"*60)

class PoWBlock:
    def __init__(self, index: int, transactions: List[str], previous_hash: str, difficulty: int):
        self.index = index
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.difficulty = difficulty
        self.nonce = 0
        self.timestamp = time.time()
        self.hash = ""
    
    def calculate_hash(self) -> str:
        data = f"{self.index}{self.transactions}{self.previous_hash}{self.nonce}{self.timestamp}"
        return hashlib.sha256(data.encode()).hexdigest()
    
    def mine_block(self) -> None:
        target = "0" * self.difficulty
        start_time = time.time()
        while True:
            self.hash = self.calculate_hash()
            if self.hash[:self.difficulty] == target:
                break
            self.nonce += 1
        elapsed = time.time() - start_time
        print(f"Block {self.index} mined in {elapsed:.2f} seconds, nonce={self.nonce}, hash={self.hash[:16]}...")
    
    def __repr__(self):
        return f"Block({self.index}, hash={self.hash[:8]}..., nonce={self.nonce})"

def simulate_pow(num_blocks: int = 5, difficulty: int = 3):
    print(f"Simulating PoW with difficulty {difficulty} for {num_blocks} blocks...")
    chain = []
    previous_hash = "0" * 64
    
    for i in range(num_blocks):
        transactions = [f"Tx{i}_{j}" for j in range(3)]
        block = PoWBlock(i, transactions, previous_hash, difficulty)
        block.mine_block()
        chain.append(block)
        previous_hash = block.hash
    
    print(f"Mined {len(chain)} blocks.")
    return chain

chain = simulate_pow(5, difficulty=3)

# Measure impact of difficulty
print("\nImpact of Difficulty on Mining Time:")
difficulties = [2, 3, 4]
times = []
for diff in difficulties:
    start = time.time()
    b = PoWBlock(0, ["test"], "0"*64, diff)
    b.mine_block()
    times.append(time.time() - start)
    print(f"Difficulty {diff}: {times[-1]:.2f} seconds")

# Visualise
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(difficulties, times, marker='o', linestyle='-', color='blue')
ax.set_xlabel('Difficulty (leading zeros)')
ax.set_ylabel('Mining Time (seconds)')
ax.set_title('PoW Mining Time vs Difficulty')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('pow_difficulty.png', dpi=300, bbox_inches='tight')
plt.show()
print("Chart saved as 'pow_difficulty.png'")

# ----------------------------------------------------------------
# PART B: PROOF OF STAKE SIMULATION
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Proof of Stake Simulation")
print("-"*60)

class Validator:
    def __init__(self, id: int, stake: float):
        self.id = id
        self.stake = stake
        self.rewards = 0
        self.slashed = False
    
    def __repr__(self):
        return f"Validator({self.id}, stake={self.stake:.2f})"

class PoSBlock:
    def __init__(self, index: int, transactions: List[str], previous_hash: str, proposer: Validator):
        self.index = index
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.proposer = proposer
        self.timestamp = time.time()
        self.hash = self.calculate_hash()
    
    def calculate_hash(self) -> str:
        data = f"{self.index}{self.transactions}{self.previous_hash}{self.proposer.id}{self.timestamp}"
        return hashlib.sha256(data.encode()).hexdigest()
    
    def __repr__(self):
        return f"Block({self.index}, proposer={self.proposer.id}, hash={self.hash[:8]}...)"

class PoSSimulation:
    def __init__(self, validators: List[Validator], block_reward: float = 10):
        self.validators = validators
        self.block_reward = block_reward
        self.chain = []
        self.total_stake = sum(v.stake for v in validators)
    
    def select_proposer(self) -> Validator:
        # Weighted random selection by stake
        r = random.random() * self.total_stake
        cumulative = 0
        for v in self.validators:
            if v.slashed:
                continue
            cumulative += v.stake
            if r <= cumulative:
                return v
        return self.validators[-1]  # fallback
    
    def propose_block(self, transactions: List[str], previous_hash: str) -> PoSBlock:
        proposer = self.select_proposer()
        block = PoSBlock(len(self.chain), transactions, previous_hash, proposer)
        # Reward proposer
        proposer.rewards += self.block_reward
        # Simulate slashing with small probability
        if random.random() < 0.02:  # 2% chance of malicious behaviour
            proposer.slashed = True
            proposer.stake *= 0.5  # slash half
            print(f"Validator {proposer.id} slashed!")
        return block
    
    def run(self, num_blocks: int):
        previous_hash = "0" * 64
        for i in range(num_blocks):
            txs = [f"Tx{i}_{j}" for j in range(2)]
            block = self.propose_block(txs, previous_hash)
            self.chain.append(block)
            previous_hash = block.hash
            print(f"Block {i} proposed by validator {block.proposer.id} (stake={block.proposer.stake:.2f})")
    
    def get_metrics(self) -> Dict:
        total_blocks = len(self.chain)
        proposer_counts = {}
        for b in self.chain:
            proposer_counts[b.proposer.id] = proposer_counts.get(b.proposer.id, 0) + 1
        return {
            'total_blocks': total_blocks,
            'proposer_distribution': proposer_counts,
            'total_stake': self.total_stake,
            'reward_distribution': {v.id: v.rewards for v in self.validators}
        }

# Create validators
validators = [Validator(i, random.uniform(10, 100)) for i in range(10)]
print("Initial validators:")
for v in validators:
    print(f"  {v}")

sim = PoSSimulation(validators, block_reward=5)
sim.run(num_blocks=20)

metrics = sim.get_metrics()
print("\nPoS Metrics:")
print(f"Total blocks: {metrics['total_blocks']}")
print("Proposer distribution:")
for v_id, count in metrics['proposer_distribution'].items():
    print(f"  Validator {v_id}: {count} blocks")
print("Rewards:")
for v_id, reward in metrics['reward_distribution'].items():
    print(f"  Validator {v_id}: {reward:.2f}")

# ----------------------------------------------------------------
# PART C: COMPARISON OF CONSENSUS MECHANISMS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Consensus Mechanism Comparison")
print("-"*60)

comparison_data = {
    'Mechanism': ['PoW', 'PoS', 'DPoS', 'PBFT', 'PoA', 'Avalanche'],
    'Permission': ['Permissionless', 'Permissionless', 'Permissionless', 'Permissioned', 'Permissioned', 'Permissionless'],
    'Finality Type': ['Probabilistic', 'Final', 'Final', 'Final', 'Final', 'Final'],
    'TPS (estimate)': [10, 100, 1000, 1000, 2000, 4500],
    'Energy Use': ['Very High', 'Low', 'Low', 'Low', 'Low', 'Low'],
    'Decentralisation': ['High', 'Medium', 'Low-Med', 'Low', 'Very Low', 'High'],
}

comp_df = pd.DataFrame(comparison_data)
print("Consensus Mechanism Comparison:")
print(comp_df.to_string(index=False))

# Visualise TPS and Decentralisation trade-off
fig, ax = plt.subplots(figsize=(10, 6))
decentralisation_score = {'High': 3, 'Medium': 2, 'Low-Med': 1.5, 'Low': 1, 'Very Low': 0.5}
comp_df['Decentralisation Score'] = comp_df['Decentralisation'].map(decentralisation_score)

scatter = ax.scatter(comp_df['TPS'], comp_df['Decentralisation Score'], 
                     s=comp_df['TPS']/100 + 50, alpha=0.8, c=range(len(comp_df)), cmap='viridis')
for i, row in comp_df.iterrows():
    ax.annotate(row['Mechanism'], (row['TPS'], row['Decentralisation Score']),
                xytext=(5, 5), textcoords='offset points', fontsize=9)
ax.set_xlabel('TPS (estimated)')
ax.set_ylabel('Decentralisation Score (higher = better)')
ax.set_title('Consensus Mechanisms: TPS vs Decentralisation')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('consensus_comparison.png', dpi=300, bbox_inches='tight')
plt.show()
print("Comparison chart saved as 'consensus_comparison.png'")

# ----------------------------------------------------------------
# PART D: FORK SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Fork Simulation (Longest Chain Rule)")
print("-"*60)

class SimpleBlockchain:
    def __init__(self):
        self.chain = [{"index": 0, "hash": "genesis"}]
    
    def add_block(self, block):
        self.chain.append(block)
    
    def length(self):
        return len(self.chain)

def simulate_fork():
    # Create two miners
    chain_a = SimpleBlockchain()
    chain_b = SimpleBlockchain()
    
    # Simulate simultaneous mining
    print("Initial chains: A length = 1, B length = 1")
    
    # Mine blocks simultaneously
    for i in range(1, 4):
        # Both mine a block at same index
        block_a = {"index": i, "hash": hashlib.sha256(f"block_{i}_a".encode()).hexdigest()}
        block_b = {"index": i, "hash": hashlib.sha256(f"block_{i}_b".encode()).hexdigest()}
        chain_a.add_block(block_a)
        chain_b.add_block(block_b)
        print(f"Mined block {i} on both chains")
    
    print(f"Chain A length: {chain_a.length()}, Chain B length: {chain_b.length()}")
    print("Fork exists!")
    
    # Now mine one more on chain A (making it longer)
    block_extra = {"index": 4, "hash": hashlib.sha256("block_4_a".encode()).hexdigest()}
    chain_a.add_block(block_extra)
    print("Mined extra block on chain A.")
    
    # Longest chain rule: chain A wins
    if chain_a.length() > chain_b.length():
        print("Chain A is longer, it becomes the canonical chain.")
        # Orphans chain B
    else:
        print("Chain B is longer, it becomes the canonical chain.")
    
    return chain_a, chain_b

chain_a, chain_b = simulate_fork()

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

print("\n" + "-"*60)
print("PART E: Consensus Selection Decision Framework")
print("-"*60)

decision_framework = {
    "Criteria": [
        "Public vs Permissioned",
        "Speed (TPS) requirement",
        "Energy consumption concern",
        "Need for finality",
        "Risk of centralisation",
        "Regulatory environment",
        "Maturity of technology",
        "Cost of operation"
    ],
    "PoW": [
        "Public",
        "Low (<100)",
        "High (not suitable)",
        "Probabilistic",
        "Medium",
        "Well-accepted",
        "Very mature",
        "High"
    ],
    "PoS": [
        "Public",
        "Medium (100-1000)",
        "Low (suitable)",
        "Final",
        "Medium",
        "Increasing",
        "Mature",
        "Medium"
    ],
    "DPoS": [
        "Public",
        "High (1000+)",
        "Low",
        "Final",
        "Low",
        "Varies",
        "Mature",
        "Medium"
    ],
    "PBFT": [
        "Permissioned",
        "High (1000+)",
        "Low",
        "Final",
        "Low",
        "Well-accepted",
        "Mature",
        "Low"
    ]
}

df_dec = pd.DataFrame(decision_framework)
print("Decision Framework (suitability by mechanism):")
print(df_dec.to_string(index=False))

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

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

print("""
Consensus Mechanisms – Key Takeaways:

1. Consensus is essential for distributed agreement in blockchain.
2. PoW is secure but energy-intensive and slow.
3. PoS is energy-efficient and fast, with economic security.
4. Other mechanisms (DPoS, PBFT, PoA) offer different trade-offs.
5. Forks are resolved by chain selection rules (longest chain, etc.).
6. Finality differs: probabilistic (PoW) vs absolute (PoS, PBFT).
7. Selection depends on use case: public, permissioned, speed, energy, etc.

Recommendations:
  - Choose PoW for high security and decentralisation (e.g., Bitcoin).
  - Choose PoS for scalability and energy efficiency (e.g., Ethereum 2.0).
  - Choose DPoS/PBFT for high throughput applications.
  - Consider regulatory and operational constraints.
  - Stay updated on emerging consensus innovations.
""")

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