┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN PROJECT LIFECYCLE                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. IDEATION & STRATEGY                                                    │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Identify business problem/opportunity                             │   │
│  │ • Assess blockchain suitability                                      │   │
│  │ • Define project vision and objectives                              │   │
│  │ • Conduct market research                                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. FEASIBILITY & PLANNING                                                 │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Technical feasibility                                             │   │
│  │ • Economic feasibility                                               │   │
│  │ • Regulatory feasibility                                             │   │
│  │ • Project plan and roadmap                                           │   │
│  │ • Resource allocation                                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. DESIGN & ARCHITECTURE                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • System architecture                                                │   │
│  │ • Smart contract design                                             │   │
│  │ • Tokenomics design                                                 │   │
│  │ • User experience/interface design                                  │   │
│  │ • Security architecture                                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  4. DEVELOPMENT                                                            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Smart contract development                                        │   │
│  │ • Frontend/backend development                                      │   │
│  │ • Integration with external systems                                 │   │
│  │ • Testing (unit, integration, security)                            │   │
│  │ • Auditing                                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  5. DEPLOYMENT                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Testnet deployment                                                │   │
│  │ • Mainnet deployment                                                │   │
│  │ • Verification on explorers                                         │   │
│  │ • Monitoring setup                                                  │   │
│  │ • Launch and marketing                                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  6. OPERATIONS & MAINTENANCE                                               │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Monitoring and alerting                                            │   │
│  │ • Incident response                                                  │   │
│  │ • Governance and upgrades                                           │   │
│  │ • Community management                                              │   │
│  │ • Continuous improvement                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN SYSTEM ARCHITECTURE                           │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    USER INTERFACE                                    │   │
│  │  • Web application                                                   │   │
│  │  • Mobile app                                                        │   │
│  │  • API endpoints                                                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    APPLICATION LAYER                                │   │
│  │  • Backend services                                                  │   │
│  │  • Business logic                                                   │   │
│  │  • Integration with smart contracts                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    SMART CONTRACT LAYER                             │   │
│  │  • Core contracts                                                   │   │
│  │  • Auxiliary contracts                                              │   │
│  │  • Libraries and interfaces                                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BLOCKCHAIN NETWORK                               │   │
│  │  • Consensus mechanism                                              │   │
│  │  • Node infrastructure                                              │   │
│  │  • Data storage                                                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 7, LESSON 1: BLOCKCHAIN PROJECT LIFECYCLE
# ===================================================================

import pandas as pd
import datetime
from typing import Dict, List
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("BLOCKCHAIN PROJECT LIFECYCLE")
print("="*70)

# ----------------------------------------------------------------
# PART A: PROJECT PHASE TRACKING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Blockchain Project Phase Tracker")
print("-"*60)

class BlockchainProject:
    """
    Tracks a blockchain project through its lifecycle phases.
    """
    def __init__(self, name: str, description: str):
        self.name = name
        self.description = description
        self.phases = []
        self.current_phase = None
        self.milestones = []
        self.created_at = datetime.datetime.now()
    
    def add_phase(self, phase: str, status: str, start_date: datetime.datetime, 
                  end_date: datetime.datetime, deliverables: List[str]):
        """Add a project phase."""
        phase_data = {
            'phase': phase,
            'status': status,  # 'not_started', 'in_progress', 'completed', 'delayed'
            'start_date': start_date,
            'end_date': end_date,
            'deliverables': deliverables,
            'completion': 0
        }
        self.phases.append(phase_data)
        if status == 'in_progress':
            self.current_phase = phase
    
    def update_phase(self, phase: str, completion: int, new_status: str = None):
        """Update phase completion status."""
        for p in self.phases:
            if p['phase'] == phase:
                p['completion'] = min(100, completion)
                if new_status:
                    p['status'] = new_status
                elif completion == 100:
                    p['status'] = 'completed'
    
    def add_milestone(self, name: str, date: datetime.datetime, description: str):
        """Add a project milestone."""
        self.milestones.append({
            'name': name,
            'date': date,
            'description': description,
            'achieved': date <= datetime.datetime.now()
        })
    
    def get_summary(self) -> Dict:
        """Get project summary."""
        return {
            'name': self.name,
            'description': self.description,
            'current_phase': self.current_phase,
            'total_phases': len(self.phases),
            'completed_phases': len([p for p in self.phases if p['status'] == 'completed']),
            'milestones': len(self.milestones),
            'achieved_milestones': len([m for m in self.milestones if m['achieved']])
        }

# Create project
project = BlockchainProject(
    name="Decentralised Lending Protocol",
    description="A DeFi lending platform with tokenised governance"
)

print(f"Project: {project.name}")
print(f"Description: {project.description}")

# Add phases
phases = [
    ('Ideation', 'completed', datetime.datetime(2024, 1, 1), datetime.datetime(2024, 2, 1), 
     ['Problem statement', 'Market research', 'Initial roadmap']),
    ('Feasibility', 'completed', datetime.datetime(2024, 2, 1), datetime.datetime(2024, 3, 15),
     ['Technical feasibility study', 'Economic analysis', 'Regulatory assessment']),
    ('Design', 'in_progress', datetime.datetime(2024, 3, 15), datetime.datetime(2024, 5, 1),
     ['System architecture', 'Smart contract design', 'Tokenomics design']),
    ('Development', 'not_started', datetime.datetime(2024, 5, 1), datetime.datetime(2024, 8, 1),
     ['Smart contracts', 'Frontend', 'Backend', 'Testing']),
    ('Deployment', 'not_started', datetime.datetime(2024, 8, 1), datetime.datetime(2024, 9, 1),
     ['Testnet deployment', 'Mainnet deployment', 'Launch']),
    ('Operations', 'not_started', datetime.datetime(2024, 9, 1), datetime.datetime(2024, 12, 31),
     ['Monitoring', 'Governance', 'Community management'])
]

for phase, status, start, end, deliverables in phases:
    project.add_phase(phase, status, start, end, deliverables)

# Update design phase completion
project.update_phase('Design', 60)

# Add milestones
milestones = [
    ('Complete Design', datetime.datetime(2024, 5, 1), 'Design phase complete'),
    ('Development Start', datetime.datetime(2024, 5, 15), 'Development begins'),
    ('Testnet Launch', datetime.datetime(2024, 8, 1), 'Deploy to testnet'),
    ('Mainnet Launch', datetime.datetime(2024, 9, 1), 'Deploy to mainnet')
]

for name, date, desc in milestones:
    project.add_milestone(name, date, desc)

# Project summary
summary = project.get_summary()
print(f"\nProject Summary:")
print(f"  Current Phase: {summary['current_phase']}")
print(f"  Completed Phases: {summary['completed_phases']}/{summary['total_phases']}")
print(f"  Milestones: {summary['achieved_milestones']}/{summary['milestones']}")

# Display phases
print(f"\nProject Phases:")
for phase in project.phases:
    status_icon = "✅" if phase['status'] == 'completed' else "🔄" if phase['status'] == 'in_progress' else "⏳"
    print(f"  {status_icon} {phase['phase'].upper()}: {phase['completion']}% complete")

# ----------------------------------------------------------------
# PART B: PROJECT SUITABILITY ASSESSMENT
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Blockchain Suitability Assessment")
print("-"*60)

class SuitabilityAssessment:
    """
    Assesses whether blockchain is suitable for a project.
    """
    def __init__(self):
        self.criteria = {
            'decentralisation_need': {'question': 'Is decentralisation essential?', 'weight': 3},
            'multi_party': {'question': 'Are there multiple parties with conflicting interests?', 'weight': 2},
            'transparency': {'question': 'Is transparency and auditability required?', 'weight': 2},
            'immutability': {'question': 'Is data immutability critical?', 'weight': 2},
            'automation': {'question': 'Can smart contracts automate processes?', 'weight': 2},
            'regulation': {'question': 'Is there regulatory compliance needed?', 'weight': 1}
        }
    
    def assess(self, scores: Dict[str, int]) -> Dict:
        """
        Assess suitability based on scores (1-5).
        """
        total = 0
        max_total = 0
        details = {}
        
        for criterion, score in scores.items():
            if criterion in self.criteria:
                weight = self.criteria[criterion]['weight']
                total += score * weight
                max_total += 5 * weight
                details[criterion] = score
        
        percentage = total / max_total if max_total > 0 else 0
        
        if percentage >= 0.7:
            recommendation = 'Highly Suitable'
            confidence = 'High'
        elif percentage >= 0.4:
            recommendation = 'Potentially Suitable'
            confidence = 'Medium'
        else:
            recommendation = 'Not Suitable'
            confidence = 'Low'
        
        return {
            'score': percentage,
            'recommendation': recommendation,
            'confidence': confidence,
            'details': details
        }

# Run assessment
assessment = SuitabilityAssessment()

# Example: DeFi lending platform
print("Assessing: DeFi Lending Platform")
scores = {
    'decentralisation_need': 5,
    'multi_party': 4,
    'transparency': 5,
    'immutability': 4,
    'automation': 5,
    'regulation': 4
}
result = assessment.assess(scores)

print(f"  Score: {result['score']:.0%}")
print(f"  Recommendation: {result['recommendation']}")
print(f"  Confidence: {result['confidence']}")

# Example: Internal HR system
print("\nAssessing: Internal HR System")
hr_scores = {
    'decentralisation_need': 2,
    'multi_party': 2,
    'transparency': 3,
    'immutability': 2,
    'automation': 2,
    'regulation': 3
}
hr_result = assessment.assess(hr_scores)

print(f"  Score: {hr_result['score']:.0%}")
print(f"  Recommendation: {hr_result['recommendation']}")
print(f"  Confidence: {hr_result['confidence']}")

# ----------------------------------------------------------------
# PART C: PROJECT RISK REGISTER
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Project Risk Register")
print("-"*60)

risks = {
    'Technical Risks': {
        'Smart Contract Bugs': 'High',
        'Scalability Issues': 'Medium',
        'Integration Complexity': 'Medium'
    },
    'Economic Risks': {
        'Token Price Volatility': 'High',
        'Unsustainable Tokenomics': 'High',
        'Market Competition': 'Medium'
    },
    'Regulatory Risks': {
        'Securities Classification': 'High',
        'AML/CFT Compliance': 'High',
        'Data Privacy': 'Medium'
    },
    'Operational Risks': {
        'Team Turnover': 'Medium',
        'Community Disengagement': 'Medium',
        'Security Breach': 'High'
    }
}

for category, items in risks.items():
    print(f"\n{category.upper()}:")
    for risk, severity in items.items():
        icon = "🔴" if severity == "High" else "🟡" if severity == "Medium" else "🟢"
        print(f"  {icon} {risk}: {severity}")

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

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

print("""
Blockchain Project Lifecycle – Key Takeaways:

1. Blockchain projects follow a lifecycle: Ideation → Feasibility → Design → Development → Deployment → Operations.
2. Strategic planning is essential for success.
3. Suitability assessment determines if blockchain is the right solution.
4. Feasibility analysis covers technical, economic, and regulatory aspects.
5. Design considerations: modularity, security, scalability, upgradeability.
6. Development best practices: version control, CI/CD, code review, testing, audits.
7. Deployment requires careful planning and risk mitigation.
8. Operations involve monitoring, governance, and continuous improvement.

Success Factors:
  - Clear vision and objectives
  - Strong technical leadership
  - Adequate funding and resources
  - Community engagement
  - Regulatory compliance
  - Risk management

Common Pitfalls:
  - Blockchain for blockchain's sake
  - Insufficient security auditing
  - Poor tokenomics design
  - Ignoring regulatory requirements
  - Underestimating complexity
  - Lack of community engagement
""")

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