┌─────────────────────────────────────────────────────────────────────────────┐
│                    PROJECT PLANNING ELEMENTS                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. OBJECTIVES                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • SMART goals: Specific, Measurable, Achievable, Relevant, Time-bound │   │
│  │ • Clear success criteria                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  2. SCOPE                                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • What is included in the project                                   │   │
│  │ • What is explicitly excluded                                       │   │
│  │ • Scope creep management                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  3. TIMELINE                                                               │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Milestones and deliverables                                       │   │
│  │ • Phases and schedules                                              │   │
│  │ • Buffer for contingencies                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  4. RESOURCES                                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Technical requirements                                            │   │
│  │ • Tools and platforms                                               │   │
│  │ • Support and mentorship                                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  5. RISKS                                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Technical risks                                                   │   │
│  │ • Resource risks                                                    │   │
│  │ • Mitigation strategies                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    DEVELOPMENT LIFECYCLE                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. PLANNING                                                               │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Define requirements                                               │   │
│  │ • Create backlog                                                    │   │
│  │ • Plan sprints                                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. DEVELOPMENT                                                            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Write code                                                         │   │
│  │ • Build features                                                     │   │
│  │ • Continuous integration                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. TESTING                                                                │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Unit tests                                                         │   │
│  │ • Integration tests                                                  │   │
│  │ • User acceptance testing                                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  4. REVIEW                                                                │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Code review                                                        │   │
│  │ • Feedback                                                          │   │
│  │ • Refinement                                                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  5. DEPLOYMENT                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Deploy to testnet                                                 │   │
│  │ • Documentation                                                    │   │
│  │ • Handover                                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 10, LESSON 2: PROJECT PLANNING AND DEVELOPMENT
# ===================================================================

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

print("="*70)
print("PROJECT PLANNING AND DEVELOPMENT")
print("="*70)

# ----------------------------------------------------------------
# PART A: PROJECT TRACKING SYSTEM
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Project Tracking System")
print("-"*60)

class ProjectTracker:
    """
    Tracks project tasks and progress.
    """
    def __init__(self, name: str):
        self.name = name
        self.tasks = []
        self.sprints = []
        self.start_date = datetime.now()
        self.end_date = None
    
    def add_task(self, task_id: str, description: str, estimate_hours: int, priority: str, category: str):
        self.tasks.append({
            'id': task_id,
            'description': description,
            'estimate_hours': estimate_hours,
            'actual_hours': 0,
            'priority': priority,  # 'Critical', 'High', 'Medium', 'Low'
            'category': category,
            'status': 'todo',  # 'todo', 'in_progress', 'done', 'blocked'
            'dependencies': []
        })
    
    def update_task(self, task_id: str, status: str, actual_hours: int = 0):
        for task in self.tasks:
            if task['id'] == task_id:
                task['status'] = status
                if actual_hours > 0:
                    task['actual_hours'] = actual_hours
                break
    
    def add_dependency(self, task_id: str, depends_on: str):
        for task in self.tasks:
            if task['id'] == task_id:
                task['dependencies'].append(depends_on)
                break
    
    def get_metrics(self) -> Dict:
        total = len(self.tasks)
        done = len([t for t in self.tasks if t['status'] == 'done'])
        in_progress = len([t for t in self.tasks if t['status'] == 'in_progress'])
        blocked = len([t for t in self.tasks if t['status'] == 'blocked'])
        todo = len([t for t in self.tasks if t['status'] == 'todo'])
        
        total_estimated = sum(t['estimate_hours'] for t in self.tasks)
        total_actual = sum(t['actual_hours'] for t in self.tasks)
        
        return {
            'total_tasks': total,
            'done': done,
            'in_progress': in_progress,
            'blocked': blocked,
            'todo': todo,
            'completion_rate': done / total if total > 0 else 0,
            'total_estimated_hours': total_estimated,
            'total_actual_hours': total_actual,
            'hours_remaining': total_estimated - total_actual
        }
    
    def get_task_summary(self) -> pd.DataFrame:
        return pd.DataFrame(self.tasks)

# Create tracker
tracker = ProjectTracker("Blockchain Capstone Project")

# Add tasks
tasks_data = [
    ('T001', 'Project proposal', 8, 'High', 'Planning'),
    ('T002', 'Smart contract design', 12, 'Critical', 'Design'),
    ('T003', 'Implement core contracts', 20, 'Critical', 'Development'),
    ('T004', 'Implement security features', 16, 'High', 'Development'),
    ('T005', 'Write unit tests', 8, 'High', 'Testing'),
    ('T006', 'Integration testing', 8, 'Medium', 'Testing'),
    ('T007', 'Security audit', 8, 'Critical', 'Security'),
    ('T008', 'Frontend development', 16, 'Medium', 'Frontend'),
    ('T009', 'Deployment to testnet', 4, 'High', 'Deployment'),
    ('T010', 'Documentation', 12, 'Medium', 'Documentation'),
    ('T011', 'Presentation preparation', 6, 'Medium', 'Presentation')
]

for task_id, desc, hours, priority, category in tasks_data:
    tracker.add_task(task_id, desc, hours, priority, category)

# Update task progress
tracker.update_task('T001', 'done', 6)
tracker.update_task('T002', 'done', 10)
tracker.update_task('T003', 'in_progress', 12)
tracker.update_task('T005', 'in_progress', 4)

# Get metrics
metrics = tracker.get_metrics()
print(f"Project: {tracker.name}")
print(f"  Total Tasks: {metrics['total_tasks']}")
print(f"  Completed: {metrics['done']}")
print(f"  In Progress: {metrics['in_progress']}")
print(f"  To Do: {metrics['todo']}")
print(f"  Completion Rate: {metrics['completion_rate']:.1%}")
print(f"  Est. Hours Remaining: {metrics['hours_remaining']}")

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

ax1 = axes[0]
status_counts = [metrics['done'], metrics['in_progress'], metrics['todo'], metrics['blocked']]
status_labels = ['Done', 'In Progress', 'Todo', 'Blocked']
colors = ['green', 'orange', 'blue', 'red']
ax1.pie(status_counts, labels=status_labels, autopct='%1.1f%%', startangle=90, colors=colors)
ax1.set_title('Task Status Distribution')

ax2 = axes[1]
task_df = tracker.get_task_summary()
priority_colors = {'Critical': 'red', 'High': 'orange', 'Medium': 'yellow', 'Low': 'green'}
colors = [priority_colors.get(p, 'gray') for p in task_df['priority']]
ax2.barh(task_df['id'], task_df['estimate_hours'], color=colors, alpha=0.7)
ax2.set_xlabel('Estimated Hours')
ax2.set_title('Tasks by Estimated Hours')
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('project_tracking.png', dpi=300, bbox_inches='tight')
plt.show()
print("Project tracking chart saved as 'project_tracking.png'")

# ----------------------------------------------------------------
# PART B: DEVELOPMENT TOOL COMPARISON
# ----------------------------------------------------------------

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

tool_data = {
    'Tool': ['Hardhat', 'Foundry', 'Truffle', 'Remix', 'Web3.js', 'Ethers.js'],
    'Type': ['Framework', 'Framework', 'Framework', 'IDE', 'Library', 'Library'],
    'Language': ['JavaScript/TS', 'Solidity/Rust', 'JavaScript', 'Web-Based', 'JavaScript', 'JavaScript/TS'],
    'Ease of Use': ['High', 'Medium', 'High', 'Very High', 'Medium', 'High'],
    'Features': ['Testing, Deployment', 'Fuzzing, Speed', 'Comprehensive', 'Quick Prototyping', 'Core Integration', 'Modern API']
}

tool_df = pd.DataFrame(tool_data)
print(tool_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: RESOURCE PLANNING
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Resource Planning")
print("-"*60)

resource_data = {
    'Resource': ['Smart Contract Development', 'Frontend Development', 'Testing', 'Documentation', 'Research'],
    'Tools': ['Hardhat, Solidity', 'React, Web3.js', 'Mocha, Chai', 'Markdown, Notion', 'Academic databases'],
    'Estimated Hours': [40, 30, 20, 15, 10],
    'Priority': ['Critical', 'High', 'High', 'Medium', 'Medium']
}

resource_df = pd.DataFrame(resource_data)
print(resource_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: RISK REGISTER
# -----------------------------------------------------------------

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

risk_data = {
    'Risk': ['Scope Creep', 'Technical Issues', 'Time Constraints', 'Resource Limitations', 'Security Vulnerabilities'],
    'Likelihood': ['Medium', 'Medium', 'High', 'Medium', 'Low'],
    'Impact': ['High', 'High', 'High', 'Medium', 'Very High'],
    'Mitigation': [
        'Clear scope definition, regular reviews',
        'Research, mentorship, contingency planning',
        'Prioritisation, MVP approach, time management',
        'Leverage open-source, focus on essential features',
        'Security audits, best practices, testing'
    ]
}

risk_df = pd.DataFrame(risk_data)
print(risk_df.to_string(index=False))

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

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

print("""
Project Planning and Development – Key Takeaways:

1. Project planning ensures direction, resource management, and quality.
2. Key planning elements: objectives, scope, timeline, resources, risks.
3. Development approaches: agile, waterfall, MVP, prototyping, incremental.
4. Development lifecycle: planning → development → testing → review → deployment.
5. Tools: Hardhat, Foundry, Truffle, Web3.js, Ethers.js, GitHub, Notion.
6. Resources: Ethereum.org, OpenZeppelin, Hardhat, Infura, Etherscan.

Recommendations:
  - Create a detailed project plan with clear milestones.
  - Use agile development for flexibility.
  - Track progress regularly.
  - Identify and mitigate risks early.
  - Use appropriate tools for development.
  - Seek feedback and iterate.
  - Document your work thoroughly.
  - Prepare for presentation and submission.
""")