┌─────────────────────────────────────────────────────────────────────────────┐
│                    SMART CONTRACT DEVELOPMENT LIFE CYCLE                   │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. REQUIREMENTS ANALYSIS                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Define business logic and use cases                                │   │
│  │ • Identify actors (users, contracts, oracles)                       │   │
│  │ • Determine state variables and data structures                     │   │
│  │ • Define access controls and permissions                            │   │
│  │ • Document functional and non-functional requirements               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. DESIGN & ARCHITECTURE                                                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Design contract interfaces and interactions                       │   │
│  │ • Define inheritance and composition patterns                       │   │
│  │ • Determine upgradeability strategy                                 │   │
│  │ • Design state machine (if applicable)                               │   │
│  │ • Plan for gas optimisation                                         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. IMPLEMENTATION                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Write smart contract code (Solidity, Vyper, Rust)                 │   │
│  │ • Follow security patterns and best practices                       │   │
│  │ • Use standard libraries (OpenZeppelin)                             │   │
│  │ • Document code with NatSpec                                        │   │
│  │ • Implement error handling                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  4. TESTING                                                                │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Unit tests (individual functions)                                 │   │
│  │ • Integration tests (interactions)                                  │   │
│  │ • Property-based tests (invariants)                                 │   │
│  │ • Fuzz testing (random inputs)                                      │   │
│  │ • Coverage analysis                                                │   │
│  │ • Gas analysis                                                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  5. AUDIT & REVIEW                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Internal code review                                              │   │
│  │ • External security audit                                           │   │
│  │ • Formal verification                                               │   │
│  │ • Bug bounty program                                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  6. DEPLOYMENT                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Deploy to testnet for validation                                  │   │
│  │ • Deploy to mainnet (production)                                    │   │
│  │ • Verify source code on explorer                                    │   │
│  │ • Set up monitoring and alerts                                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  7. OPERATIONS & MAINTENANCE                                               │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Monitor contract activity                                          │   │
│  │ • Respond to incidents                                              │   │
│  │ • Manage upgrades (if applicable)                                   │   │
│  │ • Regular security reviews                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 4, LESSON 2: SMART CONTRACT DEVELOPMENT
# ===================================================================

import hashlib
import time
import json
from typing import Dict, List, Optional, Any
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("SMART CONTRACT DEVELOPMENT")
print("="*70)

# ----------------------------------------------------------------
# PART A: SIMULATED SMART CONTRACT EXECUTION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Simulated Smart Contract Execution")
print("-"*60)

class EVMSimulation:
    """
    Simplified EVM simulation for educational purposes.
    """
    def __init__(self):
        self.storage: Dict[str, Any] = {}
        self.memory: Dict[str, Any] = {}
        self.calldata: Dict[str, Any] = {}
        self.stack: List[Any] = []
        self.gas_used = 0
        self.gas_limit = 100000
        self.logs = []
    
    def execute_operation(self, opcode: str, params: Dict) -> bool:
        """Execute a simulated EVM operation."""
        gas_cost = self._get_gas_cost(opcode)
        if self.gas_used + gas_cost > self.gas_limit:
            print(f"Out of gas! Used: {self.gas_used}, Limit: {self.gas_limit}")
            return False
        
        self.gas_used += gas_cost
        
        # Simulate operation
        if opcode == "STORAGE_SET":
            key = params.get('key')
            value = params.get('value')
            self.storage[key] = value
            self.logs.append({'op': 'STORAGE_SET', 'key': key, 'value': value})
        
        elif opcode == "STORAGE_GET":
            key = params.get('key')
            return self.storage.get(key)
        
        elif opcode == "ADD":
            a = params.get('a', 0)
            b = params.get('b', 0)
            result = a + b
            self.stack.append(result)
            return result
        
        elif opcode == "TRANSFER":
            sender = params.get('from')
            recipient = params.get('to')
            amount = params.get('amount')
            self.logs.append({'op': 'TRANSFER', 'from': sender, 'to': recipient, 'amount': amount})
        
        elif opcode == "EMIT_EVENT":
            event = params.get('event')
            data = params.get('data')
            self.logs.append({'op': 'EVENT', 'event': event, 'data': data})
        
        return True
    
    def _get_gas_cost(self, opcode: str) -> int:
        """Get gas cost for an operation."""
        costs = {
            "STORAGE_SET": 20000,
            "STORAGE_GET": 2100,
            "ADD": 3,
            "TRANSFER": 3000,
            "EMIT_EVENT": 375
        }
        return costs.get(opcode, 100)
    
    def get_metrics(self) -> Dict:
        return {
            'gas_used': self.gas_used,
            'storage_keys': len(self.storage),
            'memory_entries': len(self.memory),
            'logs_count': len(self.logs)
        }

# Create EVM simulation
evm = EVMSimulation()

print("Smart Contract Execution Simulation:")
print(f"Gas Limit: {evm.gas_limit}")

# Execute operations
evm.execute_operation("STORAGE_SET", {'key': 'balance_alice', 'value': 1000})
evm.execute_operation("STORAGE_SET", {'key': 'balance_bob', 'value': 500})
evm.execute_operation("STORAGE_GET", {'key': 'balance_alice'})
evm.execute_operation("TRANSFER", {'from': 'Alice', 'to': 'Bob', 'amount': 200})
evm.execute_operation("EMIT_EVENT", {'event': 'Transfer', 'data': {'from': 'Alice', 'to': 'Bob', 'amount': 200}})

# Show metrics
metrics = evm.get_metrics()
print(f"\nExecution Metrics:")
print(f"  Gas Used: {metrics['gas_used']}")
print(f"  Storage Keys: {metrics['storage_keys']}")
print(f"  Logs Count: {metrics['logs_count']}")

print("\nExecution Logs:")
for log in evm.logs:
    print(f"  {log}")

# ----------------------------------------------------------------
# PART B: DEVELOPMENT FRAMEWORK COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Development Framework Comparison")
print("-"*60)

framework_data = {
    'Framework': ['Hardhat', 'Foundry', 'Truffle', 'Remix', 'Brownie'],
    'Language': ['JS/TS', 'Solidity/Rust', 'JS', 'Web-based', 'Python'],
    'Testing Speed': ['Medium', 'Fast', 'Slow', 'Medium', 'Medium'],
    'Ease of Use': ['High', 'Medium', 'High', 'Very High', 'Medium'],
    'Ecosystem': ['Large', 'Growing', 'Large', 'Large', 'Medium'],
    'Fuzzing Support': ['Limited', 'Native', 'Limited', 'No', 'Limited']
}

framework_df = pd.DataFrame(framework_data)
print(framework_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: SECURITY VULNERABILITY ANALYSIS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Smart Contract Security Analysis")
print("-"*60)

vulnerability_data = {
    'Vulnerability': [
        'Reentrancy',
        'Overflow/Underflow',
        'Access Control',
        'Front-running',
        'Gas Limitations',
        'Denial of Service',
        'Logic Errors'
    ],
    'Severity': [
        'Critical',
        'Critical',
        'High',
        'High',
        'Medium',
        'Medium-High',
        'High'
    ],
    'Prevalence (%)': [15, 20, 18, 10, 12, 8, 17],
    'Mitigation Ease': [
        'Medium (pattern)',
        'Easy (SafeMath)',
        'Easy (modifiers)',
        'Hard (design)',
        'Easy (optimisation)',
        'Medium (design)',
        'Hard (testing)'
    ]
}

vuln_df = pd.DataFrame(vulnerability_data)
print(vuln_df.to_string(index=False))

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

ax1 = axes[0]
ax1.barh(vuln_df['Vulnerability'], vuln_df['Prevalence (%)'], color='red', alpha=0.7)
ax1.set_xlabel('Prevalence (%)')
ax1.set_title('Smart Contract Vulnerability Prevalence')
ax1.grid(True, alpha=0.3)

ax2 = axes[1]
severity_colors = {'Critical': 'darkred', 'High': 'red', 'Medium': 'orange', 'Medium-High': 'orangered'}
colors = [severity_colors.get(s, 'gray') for s in vuln_df['Severity']]
ax2.barh(vuln_df['Vulnerability'], [1]*len(vuln_df), color=colors, alpha=0.7)
ax2.set_xlabel('Severity')
ax2.set_title('Vulnerability Severity')
ax2.set_xticks([0])
ax2.set_xticklabels([''])
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('smart_contract_security.png', dpi=300, bbox_inches='tight')
plt.show()
print("Security analysis chart saved as 'smart_contract_security.png'")

# ----------------------------------------------------------------
# PART D: DEVELOPMENT LIFE CYCLE
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Development Life Cycle Timeline")
print("-"*60)

lifecycle_data = {
    'Phase': ['Design', 'Implementation', 'Testing', 'Audit', 'Deployment', 'Maintenance'],
    'Duration (weeks)': [2, 4, 3, 3, 1, 8],
    'Effort (%)': [15, 30, 20, 20, 5, 10]
}

lifecycle_df = pd.DataFrame(lifecycle_data)
print(lifecycle_df.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(10, 4))
ax.bar(lifecycle_df['Phase'], lifecycle_df['Duration (weeks)'], color='teal', alpha=0.7)
ax.set_ylabel('Duration (weeks)')
ax.set_title('Smart Contract Development Timeline')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('development_lifecycle.png', dpi=300, bbox_inches='tight')
plt.show()
print("Development lifecycle chart saved as 'development_lifecycle.png'")

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

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

print("""
Smart Contract Development – Key Takeaways:

1. Development lifecycle: Requirements → Design → Implementation → Testing → Audit → Deployment → Maintenance.
2. Contracts run in virtual machines (EVM, WASM, Move VM).
3. Key components: state variables, functions, events, modifiers, libraries.
4. Development frameworks: Hardhat (JS), Foundry (Solidity), Truffle, Remix.
5. Security vulnerabilities: reentrancy, overflow, access control, front-running.
6. Best practices: checks-effects-interactions, SafeMath, role-based access.
7. Testing: unit tests, integration tests, fuzzing, formal verification.

Recommendations:
  - Use established frameworks (Hardhat, Foundry).
  - Implement comprehensive testing (unit + integration + fuzzing).
  - Conduct external audits for production contracts.
  - Follow security patterns and best practices.
  - Monitor contracts post-deployment.
  - Plan for upgradeability if needed.
  - Document contracts thoroughly.
""")