┌─────────────────────────────────────────────────────────────────────────────┐
│                    PERFORMANCE DETERMINANTS                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. CONSENSUS OVERHEAD                                                     │
│  • PoW: slow due to mining difficulty                                     │
│  • PoS: faster, but still requires voting rounds                         │
│  • PBFT: fast but requires high network connectivity                     │
│                                                                             │
│  2. BLOCK PARAMETERS                                                       │
│  • Block size limit                                                       │
│  • Block frequency (time between blocks)                                  │
│  • Block gas limit                                                        │
│                                                                             │
│  3. NODE REQUIREMENTS                                                     │
│  • Hardware: CPU, memory, storage                                        │
│  • Bandwidth: upload/download                                             │
│  • Storage: full node vs light node                                      │
│                                                                             │
│  4. NETWORK CONDITIONS                                                    │
│  • Number of nodes                                                        │
│  • Geographical distribution                                              │
│  • Internet latency and packet loss                                      │
│                                                                             │
│  5. TRANSACTION CHARACTERISTICS                                           │
│  • Transaction complexity (smart contract calls vs simple transfers)     │
│  • Transaction size                                                       │
│  • Number of dependent transactions                                      │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

// More efficient: bytes32
// Less efficient: string

// Efficient: uint128 a; uint128 b; // pack into one slot
// Less efficient: uint256 a; uint256 b; // two slots

┌─────────────────────────────────────────────────────────────────────────────┐
│                    SCALING TRILEMMA                                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│                     ┌─────────────────┐                                   │
│                     │   Decentralised  │                                   │
│                     │   (Many nodes)   │                                   │
│                     └────────┬────────┘                                   │
│                              │                                             │
│              ┌───────────────┼───────────────┐                           │
│              │               │               │                           │
│              v               v               v                           │
│   ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐        │
│   │   Secure         │  │   Scalable       │  │   Efficient      │        │
│   │ (Resilient)      │  │ (High TPS)      │  │ (Low Cost)       │        │
│   └──────────────────┘  └──────────────────┘  └──────────────────┘        │
│                                                                             │
│  Trade-offs:                                                                 │
│  • Decentralisation vs Scalability: More nodes = slower consensus           │
│  • Security vs Scalability: Stronger security = more overhead               │
│  • Scalability vs Cost: Higher TPS often means higher infrastructure cost  │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 4, LESSON 6: PERFORMANCE AND SCALABILITY
# ===================================================================

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

print("="*70)
print("PERFORMANCE AND SCALABILITY")
print("="*70)

# ----------------------------------------------------------------
# PART A: TRANSACTION THROUGHPUT SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Transaction Throughput Simulation")
print("-"*60)

class TransactionSimulator:
    """
    Simulate transaction processing performance.
    """
    def __init__(self, block_time: float = 12.0, block_gas_limit: int = 30000000):
        self.block_time = block_time  # seconds
        self.block_gas_limit = block_gas_limit
        self.transactions = []
        self.processed_txs = []
        self.gas_usage = []
    
    def generate_transactions(self, num_txs: int = 1000, avg_gas: int = 50000) -> List[Dict]:
        """Generate random transactions."""
        txs = []
        for i in range(num_txs):
            gas = int(random.gauss(avg_gas, avg_gas * 0.3))
            gas = max(21000, min(self.block_gas_limit, gas))
            txs.append({
                'id': i,
                'gas': gas,
                'timestamp': time.time(),
                'size': random.randint(100, 1000)  # bytes
            })
        self.transactions = txs
        return txs
    
    def process_block(self, transactions: List[Dict]) -> Dict:
        """Simulate processing a block of transactions."""
        start = time.time()
        total_gas = sum(tx['gas'] for tx in transactions)
        # Simulate processing time
        process_time = total_gas / self.block_gas_limit * self.block_time * 0.8
        time.sleep(process_time / 1000)  # scale for simulation
        
        self.processed_txs.extend(transactions)
        self.gas_usage.append(total_gas)
        
        return {
            'tx_count': len(transactions),
            'total_gas': total_gas,
            'time_taken': process_time
        }
    
    def calculate_tps(self, time_window: float = 60.0) -> float:
        """Calculate throughput over time window."""
        if not self.processed_txs:
            return 0
        
        # Find transactions within time window
        now = time.time()
        recent = [tx for tx in self.processed_txs if tx['timestamp'] > now - time_window]
        return len(recent) / time_window
    
    def run_simulation(self, num_blocks: int = 50) -> Dict:
        """Run a full simulation."""
        txs_per_block = 50
        blocks = []
        total_txs = 0
        
        print(f"Simulating {num_blocks} blocks...")
        for block_num in range(num_blocks):
            txs = self.generate_transactions(txs_per_block, avg_gas=50000 + random.randint(-10000, 10000))
            result = self.process_block(txs)
            total_txs += result['tx_count']
            blocks.append(result)
        
        avg_tps = self.calculate_tps()
        
        return {
            'total_blocks': num_blocks,
            'total_transactions': total_txs,
            'avg_tps': avg_tps,
            'avg_txs_per_block': total_txs / num_blocks,
            'avg_gas_per_block': statistics.mean(self.gas_usage) if self.gas_usage else 0
        }

# Run simulation
simulator = TransactionSimulator(block_time=12, block_gas_limit=30000000)
results = simulator.run_simulation(num_blocks=30)

print("\nPerformance Simulation Results:")
print(f"  Total Blocks: {results['total_blocks']}")
print(f"  Total Transactions: {results['total_transactions']}")
print(f"  Average TPS: {results['avg_tps']:.2f}")
print(f"  Avg Transactions per Block: {results['avg_txs_per_block']:.1f}")
print(f"  Avg Gas per Block: {results['avg_gas_per_block']:,.0f}")

# ----------------------------------------------------------------
# PART B: SCALING SOLUTION COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Scaling Solution Comparison")
print("-"*60)

scaling_data = {
    'Solution': ['Base L1', 'Optimistic Rollup', 'ZK-Rollup', 'State Channels', 'Sidechain', 'Sharding'],
    'TPS (estimate)': [30, 2000, 3000, 10000, 1000, 5000],
    'Finality (sec)': [600, 600, 10, 1, 10, 30],
    'Security': ['Very High', 'High', 'Very High', 'Medium', 'Medium', 'High'],
    'Cost (relative)': ['1x', '0.1x', '0.05x', '0.01x', '0.2x', '0.2x']
}

scaling_df = pd.DataFrame(scaling_data)
print(scaling_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: PERFORMANCE METRICS VISUALISATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Performance Metrics Visualisation")
print("-"*60)

# Simulate TPS growth with scaling
solutions = ['Base L1', '+ Rollup', '+ Sharding', 'Full Scaling']
tps_values = [30, 3000, 6000, 15000]
latency = [10000, 1000, 100, 50]  # ms
decentralisation_score = [10, 8, 7, 6]  # relative

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

ax1 = axes[0]
x = np.arange(len(solutions))
ax1.bar(x, tps_values, color='teal', alpha=0.7)
ax1.set_xticks(x)
ax1.set_xticklabels(solutions)
ax1.set_ylabel('TPS (estimated)')
ax1.set_title('Throughput Improvement')
ax1.grid(True, alpha=0.3)

ax2 = axes[1]
ax2.scatter(decentralisation_score, tps_values, s=200, c=latency, cmap='viridis', alpha=0.8)
for i, sol in enumerate(solutions):
    ax2.annotate(sol, (decentralisation_score[i], tps_values[i]), xytext=(5, 5), textcoords='offset points')
ax2.set_xlabel('Decentralisation Score (higher = more decentralised)')
ax2.set_ylabel('TPS')
ax2.set_title('Scaling Trade-off: Decentralisation vs TPS')
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('performance_scaling.png', dpi=300, bbox_inches='tight')
plt.show()
print("Performance scaling chart saved as 'performance_scaling.png'")

# ----------------------------------------------------------------
# PART D: GAS COST OPTIMISATION
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Gas Cost Optimisation Comparison")
print("-"*60)

gas_optimisation_data = {
    'Technique': ['Unoptimised', 'Batch Operations', 'Packed Variables', 'Custom Errors', 'All Optimisations'],
    'Gas Cost (relative)': [100, 70, 60, 80, 40],
    'Code Complexity': ['Low', 'Medium', 'Medium', 'Low', 'High']
}

opt_df = pd.DataFrame(gas_optimisation_data)
print(opt_df.to_string(index=False))

# ----------------------------------------------------------------
# PART E: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

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

print("""
Performance and Scalability – Key Takeaways:

1. Performance metrics: TPS, latency, finality, block size, gas cost.
2. Factors: consensus overhead, block parameters, node hardware, network conditions.
3. Layer 1 scaling: block size, block time, sharding, consensus improvements.
4. Layer 2 scaling: rollups, state channels, sidechains, Plasma, validiums.
5. Optimisation: gas-efficient code, batch processing, efficient data structures.
6. Benchmarking: use realistic testnets and load patterns.
7. Trade-offs: decentralisation vs scalability, security vs speed, cost vs throughput.

Performance Optimisation Framework:
  - Identify bottlenecks (CPU, network, storage, consensus).
  - Optimise smart contract gas usage.
  - Consider Layer 2 for high-volume applications.
  - Use monitoring and benchmarking to track performance.
  - Plan for scaling from day one.
  - Evaluate trade-offs for your specific use case.
""")