┌─────────────────────────────────────────────────────────────────────────────┐
│                    FEASIBILITY STUDY COMPONENTS                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. TECHNICAL FEASIBILITY                                                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Can the project be built with available technology?               │   │
│  │ • Are the required skills and expertise available?                  │   │
│  │ • What are the technical risks and challenges?                      │   │
│  │ • Is the project scalable?                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  2. ECONOMIC FEASIBILITY                                                    │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • What are the development and operational costs?                   │   │
│  │ • What is the expected revenue and ROI?                             │   │
│  │ • What is the payback period?                                       │   │
│  │ • Is the business model sustainable?                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  3. REGULATORY FEASIBILITY                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Does the project comply with applicable laws?                     │   │
│  │ • What licenses or registrations are required?                      │   │
│  │ • What are the AML/CFT and KYC requirements?                        │   │
│  │ • How might regulation evolve?                                      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  4. OPERATIONAL FEASIBILITY                                                │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Can the organisation support the project?                         │   │
│  │ • Are the governance structures in place?                          │   │
│  │ • What is the impact on existing operations?                       │   │
│  │ • What is the change management requirement?                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  5. STRATEGIC FEASIBILITY                                                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Does the project align with organisational strategy?              │   │
│  │ • What is the competitive advantage?                               │   │
│  │ • What is the risk of not proceeding?                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    COST-BENEFIT ANALYSIS                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  COSTS                                                                     │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  Development Costs:                                                  │   │
│  │  • Smart contract development                                       │   │
│  │  • Frontend/backend development                                     │   │
│  │  • Testing and auditing                                             │   │
│  │  • Project management                                               │   │
│  │                                                                     │   │
│  │  Operational Costs:                                                 │   │
│  │  • Node infrastructure                                               │   │
│  │  • Hosting and cloud services                                        │   │
│  │  • Maintenance and support                                          │   │
│  │  • Compliance and legal                                             │   │
│  │                                                                     │   │
│  │  Marketing Costs:                                                   │   │
│  │  • Community building                                                │   │
│  │  • Marketing and PR                                                │   │
│  │  • Incentives and rewards                                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  BENEFITS                                                                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │  Quantitative Benefits:                                              │   │
│  │  • Revenue from fees                                                │   │
│  │  • Token appreciation                                                │   │
│  │  • Cost savings                                                    │   │
│  │  • Efficiency gains                                                 │   │
│  │                                                                     │   │
│  │  Qualitative Benefits:                                              │   │
│  │  • Improved transparency                                            │   │
│  │  • Increased trust                                                  │   │
│  │  • Competitive advantage                                            │   │
│  │  • Brand reputation                                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 7, LESSON 2: FEASIBILITY STUDY AND ROI ANALYSIS
# ===================================================================

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

print("="*70)
print("FEASIBILITY STUDY AND ROI ANALYSIS")
print("="*70)

# ----------------------------------------------------------------
# PART A: FEASIBILITY ASSESSMENT FRAMEWORK
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Feasibility Assessment Framework")
print("-"*60)

class FeasibilityAssessment:
    """
    Comprehensive feasibility assessment for blockchain projects.
    """
    def __init__(self):
        self.categories = {
            'technical': {
                'technology_maturity': {'question': 'Is the technology mature?', 'weight': 3},
                'scalability': {'question': 'Can it handle expected volume?', 'weight': 3},
                'security': {'question': 'Is security adequately addressed?', 'weight': 4},
                'resources': {'question': 'Are the required skills available?', 'weight': 3},
                'integration': {'question': 'Can it integrate with existing systems?', 'weight': 2}
            },
            'economic': {
                'cost_feasibility': {'question': 'Are development costs acceptable?', 'weight': 4},
                'revenue_model': {'question': 'Is the revenue model sustainable?', 'weight': 4},
                'roi_potential': {'question': 'Is there clear ROI potential?', 'weight': 4},
                'market_demand': {'question': 'Is there market demand?', 'weight': 3}
            },
            'regulatory': {
                'compliance': {'question': 'Can we comply with regulations?', 'weight': 4},
                'licensing': {'question': 'Are required licenses obtainable?', 'weight': 3},
                'cross_border': {'question': 'Are cross-border issues manageable?', 'weight': 2}
            },
            'operational': {
                'governance': {'question': 'Is governance structure in place?', 'weight': 3},
                'team_capacity': {'question': 'Does the team have capacity?', 'weight': 3},
                'change_management': {'question': 'Is change management planned?', 'weight': 2}
            }
        }
    
    def assess(self, scores: Dict[str, Dict[str, int]]) -> Dict:
        """Assess feasibility based on category and criterion scores."""
        category_results = {}
        total_score = 0
        total_weight = 0
        
        for category, criteria in scores.items():
            if category in self.categories:
                category_total = 0
                category_weight = 0
                criterion_results = {}
                
                for criterion, score in criteria.items():
                    if criterion in self.categories[category]:
                        weight = self.categories[category][criterion]['weight']
                        weighted_score = score * weight
                        category_total += weighted_score
                        category_weight += weight
                        criterion_results[criterion] = {
                            'score': score,
                            'weight': weight,
                            'weighted_score': weighted_score
                        }
                
                category_score = category_total / category_weight if category_weight > 0 else 0
                category_results[category] = {
                    'score': category_score,
                    'status': 'High' if category_score >= 3.5 else 'Medium' if category_score >= 2.5 else 'Low'
                }
                total_score += category_total
                total_weight += category_weight
        
        overall_score = total_score / total_weight if total_weight > 0 else 0
        
        if overall_score >= 3.5:
            recommendation = 'Proceed'
        elif overall_score >= 2.5:
            recommendation = 'Proceed with Caution'
        else:
            recommendation = 'Do Not Proceed'
        
        return {
            'overall_score': overall_score,
            'recommendation': recommendation,
            'category_results': category_results,
            'details': scores
        }

# Run feasibility assessment
assessment = FeasibilityAssessment()

# Example: DeFi Lending Platform
scores = {
    'technical': {
        'technology_maturity': 4,
        'scalability': 3,
        'security': 4,
        'resources': 3,
        'integration': 3
    },
    'economic': {
        'cost_feasibility': 3,
        'revenue_model': 4,
        'roi_potential': 4,
        'market_demand': 4
    },
    'regulatory': {
        'compliance': 3,
        'licensing': 3,
        'cross_border': 3
    },
    'operational': {
        'governance': 3,
        'team_capacity': 4,
        'change_management': 3
    }
}

result = assessment.assess(scores)

print("Feasibility Assessment Results:")
print(f"  Overall Score: {result['overall_score']:.1f}/5.0")
print(f"  Recommendation: {result['recommendation']}")
print("\nCategory Scores:")
for category, details in result['category_results'].items():
    print(f"  {category}: {details['score']:.1f}/5.0 ({details['status']})")

# ----------------------------------------------------------------
# PART B: ROI ANALYSIS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: ROI Analysis")
print("-"*60)

class ROIAnalyzer:
    """
    ROI analysis for blockchain projects.
    """
    def __init__(self, name: str):
        self.name = name
        self.costs = {}
        self.revenue = {}
        self.assumptions = {}
        self.years = 5
    
    def add_cost(self, category: str, amount: float, description: str):
        """Add a cost item."""
        self.costs[category] = {
            'amount': amount,
            'description': description
        }
    
    def add_revenue(self, category: str, annual_amount: float, description: str):
        """Add a revenue item."""
        self.revenue[category] = {
            'annual_amount': annual_amount,
            'description': description
        }
    
    def set_assumption(self, key: str, value: str):
        """Set an assumption."""
        self.assumptions[key] = value
    
    def calculate_roi(self) -> Dict:
        """Calculate ROI metrics."""
        total_cost = sum(c['amount'] for c in self.costs.values())
        annual_revenue = sum(r['annual_amount'] for r in self.revenue.values())
        total_revenue = annual_revenue * self.years
        net_profit = total_revenue - total_cost
        roi = (net_profit / total_cost) * 100 if total_cost > 0 else 0
        payback_period = total_cost / annual_revenue if annual_revenue > 0 else float('inf')
        
        return {
            'total_cost': total_cost,
            'annual_revenue': annual_revenue,
            'total_revenue': total_revenue,
            'net_profit': net_profit,
            'roi': roi,
            'payback_period_years': payback_period
        }

# Create ROI analysis
roi = ROIAnalyzer("DeFi Lending Platform")

# Add costs
roi.add_cost('Development', 500000, 'Smart contract and application development')
roi.add_cost('Audits', 200000, 'Security audits (internal and external)')
roi.add_cost('Infrastructure', 50000, 'Node infrastructure and hosting')
roi.add_cost('Legal', 150000, 'Legal and compliance')
roi.add_cost('Marketing', 100000, 'Marketing and community building')
roi.add_cost('Other', 50000, 'Contingency and other costs')

# Add revenue
roi.add_revenue('Transaction Fees', 400000, '0.05% fee on transactions')
roi.add_revenue('Lending Interest', 200000, 'Interest from lending protocol')
roi.add_revenue('Staking Revenue', 100000, 'Fees from staking')
roi.add_revenue('Other Revenue', 50000, 'Miscellaneous revenue')

# Calculate ROI
metrics = roi.calculate_roi()

print(f"ROI Analysis: {roi.name}")
print(f"  Total Development Cost: ${metrics['total_cost']:,.0f}")
print(f"  Annual Revenue: ${metrics['annual_revenue']:,.0f}")
print(f"  Total Revenue (5 years): ${metrics['total_revenue']:,.0f}")
print(f"  Net Profit (5 years): ${metrics['net_profit']:,.0f}")
print(f"  ROI: {metrics['roi']:.1f}%")
print(f"  Payback Period: {metrics['payback_period_years']:.1f} years")

# ----------------------------------------------------------------
# PART C: SENSITIVITY ANALYSIS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Sensitivity Analysis")
print("-"*60)

# Simulate different scenarios
scenarios = {
    'Best Case': {'revenue_multiplier': 1.5, 'cost_multiplier': 0.8},
    'Base Case': {'revenue_multiplier': 1.0, 'cost_multiplier': 1.0},
    'Worst Case': {'revenue_multiplier': 0.6, 'cost_multiplier': 1.2}
}

results = []
for scenario, factors in scenarios.items():
    adjusted_revenue = metrics['annual_revenue'] * factors['revenue_multiplier']
    adjusted_cost = metrics['total_cost'] * factors['cost_multiplier']
    adjusted_roi = ((adjusted_revenue * roi.years - adjusted_cost) / adjusted_cost) * 100
    
    results.append({
        'Scenario': scenario,
        'Revenue (Annual)': adjusted_revenue,
        'Total Cost': adjusted_cost,
        'ROI': adjusted_roi
    })

results_df = pd.DataFrame(results)
print("Sensitivity Analysis:")
print(results_df.to_string(index=False))

# Visualise sensitivity analysis
fig, ax = plt.subplots(figsize=(10, 5))
scenario_names = ['Best Case', 'Base Case', 'Worst Case']
roi_values = [r['ROI'] for r in results]
colors = ['green', 'blue', 'red']

ax.bar(scenario_names, roi_values, color=colors, alpha=0.7)
ax.axhline(y=0, color='black', linestyle='-', alpha=0.5)
ax.set_ylabel('ROI (%)')
ax.set_title('ROI Sensitivity Analysis by Scenario')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('roi_sensitivity.png', dpi=300, bbox_inches='tight')
plt.show()
print("ROI sensitivity chart saved as 'roi_sensitivity.png'")

# ----------------------------------------------------------------
# PART D: COST-BENEFIT SUMMARY
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Cost-Benefit Summary")
print("-"*60)

cost_benefit = {
    'Category': ['Development', 'Audits', 'Infrastructure', 'Legal', 'Marketing', 'Other', 'TOTAL COSTS'],
    'Amount': [500000, 200000, 50000, 150000, 100000, 50000, 1050000]
}

benefit = {
    'Category': ['Transaction Fees', 'Lending Interest', 'Staking Revenue', 'Other Revenue', 'TOTAL BENEFITS'],
    'Annual': [400000, 200000, 100000, 50000, 750000]
}

cost_df = pd.DataFrame(cost_benefit)
benefit_df = pd.DataFrame(benefit)

print("Costs:")
print(cost_df.to_string(index=False))
print("\nBenefits (Annual):")
print(benefit_df.to_string(index=False))

print(f"\nNet Annual Benefit: ${benefit_df.iloc[-1]['Annual'] - 1050000:,.0f}")

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

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

print("""
Feasibility Study and ROI Analysis – Key Takeaways:

1. Feasibility study components: technical, economic, regulatory, operational, strategic.
2. Technical feasibility: technology maturity, scalability, security, resources, integration.
3. Economic feasibility: costs, revenue, ROI, payback period, NPV.
4. Regulatory feasibility: compliance, licensing, cross-border considerations.
5. ROI analysis: costs, benefits, ROI, payback period, sensitivity analysis.
6. Key drivers: adoption rate, transaction volume, fee structure, token performance.

Recommendations:
  - Conduct comprehensive feasibility study before committing resources.
  - Use multiple scenarios for ROI analysis (best, base, worst case).
  - Engage legal counsel early for regulatory assessment.
  - Build compliance into the product from the start.
  - Monitor key assumptions and update analysis.
  - Consider qualitative benefits alongside quantitative metrics.
  - Develop a clear risk mitigation plan.
""")