┌─────────────────────────────────────────────────────────────────────────────┐
│                    SMART CONTRACT CI/CD PIPELINE                           │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CODE COMMIT                                       │   │
│  │  Developer commits smart contract code to repository                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BUILD & COMPILE                                  │   │
│  │  • Compile Solidity (solc)                                          │   │
│  │  • Generate ABIs and bytecode                                       │   │
│  │  • Run static analysis (Slither, Mythril)                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    UNIT TESTING                                      │   │
│  │  • Run Hardhat/Foundry tests                                        │   │
│  │  • Check coverage                                                   │   │
│  │  • Gas profiling                                                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    INTEGRATION TESTING                              │   │
│  │  • Deploy to local test network                                     │   │
│  │  • Test contract interactions                                       │   │
│  │  • Test with mock oracles and dependencies                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    SECURITY AUDIT (GATED)                           │   │
│  │  • Run automated security scans                                    │   │
│  │  • If critical findings, pipeline fails                             │   │
│  │  • Manual review required for sensitive changes                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DEPLOYMENT                                        │   │
│  │  • Deploy to testnet (verification)                                 │   │
│  │  • Deploy to mainnet (production)                                   │   │
│  │  • Verify source code                                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MONITORING                                        │   │
│  │  • Track contract activity                                          │   │
│  │  • Monitor gas costs and transaction patterns                      │   │
│  │  • Alert on anomalies                                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# Terraform configuration (simplified)
resource "aws_instance" "blockchain_node" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t3.medium"
  
  user_data = <<-EOF
    #!/bin/bash
    apt-get update
    apt-get install -y docker.io
    docker run -d --name eth-node -p 8545:8545 ethereum/client-go
  EOF
}

# ===================================================================
# MODULE 4, LESSON 7: DEVOPS FOR BLOCKCHAIN
# ===================================================================

import time
import random
import json
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("DEVOPS FOR BLOCKCHAIN")
print("="*70)

# ----------------------------------------------------------------
# PART A: CI/CD PIPELINE SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: CI/CD Pipeline Simulation")
print("-"*60)

class DevOpsPipeline:
    """
    Simulated CI/CD pipeline for smart contract deployment.
    """
    def __init__(self):
        self.stages = []
        self.passed = []
        self.failed = []
        self.build_artifacts = {}
        self.deployment_history = []
    
    def commit(self, code: str, author: str) -> Dict:
        """Simulate code commit."""
        commit_id = f"commit-{random.randint(1000, 9999)}"
        self.stages.append({'phase': 'commit', 'id': commit_id, 'author': author})
        print(f"Commit {commit_id} by {author}")
        return {'commit_id': commit_id, 'code': code}
    
    def build(self, commit_id: str) -> bool:
        """Simulate build process."""
        print(f"Building commit {commit_id}...")
        # Simulate compilation
        success = random.random() > 0.05
        if success:
            self.passed.append('build')
            self.build_artifacts[commit_id] = {'abi': '[...]', 'bytecode': '0x...'}
            print("  ✅ Build successful")
        else:
            self.failed.append('build')
            print("  ❌ Build failed")
        return success
    
    def test(self, commit_id: str) -> bool:
        """Simulate test execution."""
        print(f"Testing commit {commit_id}...")
        # Simulate unit tests and integration tests
        unit_tests = random.random() > 0.1
        integration_tests = random.random() > 0.15
        success = unit_tests and integration_tests
        if success:
            self.passed.append('test')
            print("  ✅ All tests passed")
        else:
            self.failed.append('test')
            print("  ❌ Tests failed")
        return success
    
    def audit(self, commit_id: str) -> bool:
        """Simulate security audit."""
        print(f"Auditing commit {commit_id}...")
        # Simulate automated security scan
        scan_results = self._run_security_scan()
        critical_findings = scan_results.get('critical', 0)
        high_findings = scan_results.get('high', 0)
        
        if critical_findings > 0:
            self.failed.append('audit')
            print(f"  ❌ {critical_findings} critical findings found")
            return False
        elif high_findings > 2:
            self.failed.append('audit')
            print(f"  ❌ {high_findings} high-severity findings")
            return False
        else:
            self.passed.append('audit')
            print("  ✅ Security audit passed")
            return True
    
    def _run_security_scan(self) -> Dict:
        """Simulate security scan results."""
        return {
            'critical': random.randint(0, 1),
            'high': random.randint(0, 3),
            'medium': random.randint(0, 5),
            'low': random.randint(0, 10)
        }
    
    def deploy(self, commit_id: str, environment: str = 'testnet') -> bool:
        """Simulate deployment to environment."""
        print(f"Deploying commit {commit_id} to {environment}...")
        # Simulate deployment
        success = random.random() > 0.05
        if success:
            self.passed.append('deploy')
            self.deployment_history.append({
                'commit_id': commit_id,
                'environment': environment,
                'timestamp': time.time()
            })
            print(f"  ✅ Deployed to {environment}")
        else:
            self.failed.append('deploy')
            print(f"  ❌ Deployment to {environment} failed")
        return success
    
    def get_pipeline_status(self) -> Dict:
        """Get overall pipeline status."""
        return {
            'total_stages': len(self.stages),
            'passed': len(self.passed),
            'failed': len(self.failed),
            'success_rate': len(self.passed) / (len(self.stages) or 1)
        }

# Run pipeline simulation
pipeline = DevOpsPipeline()

print("CI/CD Pipeline Simulation:")
commit = pipeline.commit("// Smart contract code", "developer_1")
if pipeline.build(commit['commit_id']):
    if pipeline.test(commit['commit_id']):
        if pipeline.audit(commit['commit_id']):
            pipeline.deploy(commit['commit_id'], 'testnet')
            pipeline.deploy(commit['commit_id'], 'mainnet')

status = pipeline.get_pipeline_status()
print(f"\nPipeline Status:")
print(f"  Success Rate: {status['success_rate']:.1%}")

# ----------------------------------------------------------------
# PART B: ENVIRONMENT STRATEGY
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Environment Strategy")
print("-"*60)

env_data = {
    'Environment': ['Development', 'Staging', 'Testnet', 'Mainnet'],
    'Purpose': ['Local development', 'Integration testing', 'Public testing', 'Production'],
    'Configuration': ['Local node (Ganache)', 'Testnet (Sepolia)', 'Testnet (Sepolia)', 'Mainnet'],
    'Access': ['Developer only', 'Dev team', 'Public (limited)', 'Public (full)'],
    'Deployment Frequency': ['Daily', 'Weekly', 'Bi-weekly', 'Monthly (governed)']
}

env_df = pd.DataFrame(env_data)
print(env_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: MONITORING METRICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Monitoring Metrics Dashboard")
print("-"*60)

monitoring_data = {
    'Metric': [
        'Node Uptime (%)',
        'Sync Status',
        'Pending Transactions',
        'Gas Price (Gwei)',
        'Block Time (sec)',
        'Contract Calls (24h)',
        'Unique Users (24h)',
        'Error Rate (%)'
    ],
    'Current Value': [
        '99.8',
        'Synced',
        '1,245',
        '25',
        '12.5',
        '45,000',
        '3,200',
        '0.5'
    ],
    'Threshold': [
        '>99.5',
        'Synced',
        '<2,000',
        '<50',
        '<14',
        '>30,000',
        '>2,000',
        '<1.0'
    ],
    'Status': ['✅', '✅', '✅', '✅', '✅', '✅', '✅', '✅']
}

monitoring_df = pd.DataFrame(monitoring_data)
print(monitoring_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: ALERTING STRATEGY
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Alerting Strategy")
print("-"*60)

alerts = {
    'Critical Alert': {
        'Conditions': ['Node offline > 5 min', 'Contract exploit detected'],
        'Action': 'Immediate response team page'
    },
    'High Alert': {
        'Conditions': ['Sync lag > 10 blocks', 'Transaction volume spike > 200%'],
        'Action': 'Investigate within 15 minutes'
    },
    'Medium Alert': {
        'Conditions': ['Gas price > 2x normal', 'High error rate > 2%'],
        'Action': 'Investigate within 1 hour'
    },
    'Low Alert': {
        'Conditions': ['Storage usage > 80%', 'Slow block propagation'],
        'Action': 'Monitor and plan'
    }
}

for severity, details in alerts.items():
    print(f"\n{severity.upper()}:")
    print(f"  Conditions: {', '.join(details['Conditions'])}")
    print(f"  Action: {details['Action']}")

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

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

print("""
DevOps for Blockchain – Key Takeaways:

1. DevOps bridges development and operations, automating deployment and monitoring.
2. CI/CD pipeline: commit → build → test → audit → deploy → monitor.
3. Environments: development (local), staging (testnet), production (mainnet).
4. Monitoring: node health, transaction volume, contract behaviour, security.
5. Alerting: tiered severity (critical, high, medium, low) with defined actions.
6. Infrastructure as Code (Terraform, Ansible) ensures reproducible environments.
7. Incident response: detection → containment → eradication → recovery → lessons learned.

Recommendations:
  - Automate testing and security scanning in CI/CD.
  - Implement comprehensive monitoring and alerting.
  - Use infrastructure as code for consistency.
  - Have an incident response plan tested regularly.
  - Separate environments for development, testing, and production.
  - Use rollback and upgrade strategies (time-locks, multisig).
  - Document all processes and procedures.
""")

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