┌─────────────────────────────────────────────────────────────────────────────┐
│                    PORTFOLIO OPTIMISATION                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    1. DEFINE OBJECTIVES                             │   │
│  │  (Return target, risk tolerance, investment horizon)                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    2. ASSET CLASS SELECTION                         │   │
│  │  (Equities, bonds, real estate, commodities, alternatives)          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    3. OPTIMISATION                                  │   │
│  │  (Mean-variance optimisation, risk parity, black-litterman)        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    4. IMPLEMENTATION                                │   │
│  │  (Portfolio construction, rebalancing, monitoring)                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    ROBO-ADVISORY TECHNOLOGY STACK                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CUSTOMER INTERFACE                               │   │
│  │  (Mobile App, Web Portal, Chatbot)                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    INVESTMENT ALGORITHM                             │   │
│  │  (Asset allocation, rebalancing, tax-loss harvesting)              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PORTFOLIO MANAGEMENT                             │   │
│  │  (Portfolio construction, optimisation, monitoring)                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TRADING AND EXECUTION                            │   │
│  │  (Order placement, trade execution, settlement)                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA AND ANALYTICS                               │   │
│  │  (Market data, customer data, analytics, risk management)          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 7, LESSON 5: WEALTH MANAGEMENT AND ROBO-ADVISORY
# ===================================================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.optimize import minimize
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("WEALTH MANAGEMENT AND ROBO-ADVISORY PRODUCTS")
print("="*70)

# ----------------------------------------------------------------
# PART A: ASSET CLASS CHARACTERISTICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Asset Class Characteristics")
print("-"*60)

# Define asset classes
asset_classes = ['US Equities', 'International Equities', 'US Bonds', 
                 'International Bonds', 'Real Estate', 'Commodities', 'Cash']

# Expected returns (annual %)
returns = [0.09, 0.08, 0.04, 0.03, 0.06, 0.05, 0.02]

# Risk (volatility %)
volatilities = [0.18, 0.20, 0.06, 0.08, 0.12, 0.15, 0.02]

# Correlation matrix (simplified)
correlations = np.array([
    [1.00, 0.70, 0.10, 0.05, 0.40, 0.20, 0.00],
    [0.70, 1.00, 0.15, 0.08, 0.35, 0.25, 0.00],
    [0.10, 0.15, 1.00, 0.60, 0.20, 0.05, 0.05],
    [0.05, 0.08, 0.60, 1.00, 0.15, 0.05, 0.05],
    [0.40, 0.35, 0.20, 0.15, 1.00, 0.30, 0.05],
    [0.20, 0.25, 0.05, 0.05, 0.30, 1.00, 0.00],
    [0.00, 0.00, 0.05, 0.05, 0.05, 0.00, 1.00]
])

# Calculate covariance matrix
cov_matrix = np.diag(volatilities) @ correlations @ np.diag(volatilities)

# Create DataFrame
asset_df = pd.DataFrame({
    'Asset Class': asset_classes,
    'Expected Return (%)': returns,
    'Volatility (%)': volatilities
})

print("Asset Class Characteristics:")
print(asset_df.to_string(index=False))

# Visualise correlations
fig, ax = plt.subplots(figsize=(10, 8))
sns.heatmap(correlations, annot=True, fmt='.2f', cmap='coolwarm', 
            xticklabels=asset_classes, yticklabels=asset_classes, ax=ax)
ax.set_title('Asset Class Correlation Matrix')
plt.tight_layout()
plt.savefig('roboadvisor_correlations.png', dpi=300, bbox_inches='tight')
plt.show()
print("Correlation matrix visualisation saved as 'roboadvisor_correlations.png'")

# ----------------------------------------------------------------
# PART B: PORTFOLIO OPTIMISATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Portfolio Optimisation")
print("-"*60)

def portfolio_performance(weights, returns, cov_matrix):
    """Calculate portfolio return, volatility, and Sharpe ratio."""
    port_return = np.sum(returns * weights)
    port_volatility = np.sqrt(weights.T @ cov_matrix @ weights)
    return port_return, port_volatility

def negative_sharpe(weights, returns, cov_matrix, risk_free_rate=0.02):
    """Calculate negative Sharpe ratio for optimisation."""
    port_return, port_volatility = portfolio_performance(weights, returns, cov_matrix)
    return -(port_return - risk_free_rate) / port_volatility

# Optimise for maximum Sharpe ratio
n_assets = len(asset_classes)
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
bounds = tuple((0, 1) for _ in range(n_assets))

# Initial guess (equal weight)
initial_weights = np.ones(n_assets) / n_assets

# Optimise
result = minimize(negative_sharpe, initial_weights, 
                  args=(returns, cov_matrix, 0.02),
                  method='SLSQP', bounds=bounds, constraints=constraints)

optimal_weights = result.x

# Calculate optimal portfolio performance
opt_return, opt_volatility = portfolio_performance(optimal_weights, returns, cov_matrix)
opt_sharpe = (opt_return - 0.02) / opt_volatility

# Create DataFrame with optimal weights
weights_df = pd.DataFrame({
    'Asset Class': asset_classes,
    'Weight (%)': optimal_weights * 100
}).sort_values('Weight (%)', ascending=False)

print("Optimal Portfolio (Max Sharpe Ratio):")
print(weights_df.to_string(index=False))
print(f"\nExpected Return: {opt_return*100:.2f}%")
print(f"Volatility: {opt_volatility*100:.2f}%")
print(f"Sharpe Ratio: {opt_sharpe:.3f}")

# ----------------------------------------------------------------
# PART C: EFFICIENT FRONTIER
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Efficient Frontier")
print("-"*60)

# Generate efficient frontier
target_returns = np.linspace(0.02, 0.12, 100)
efficient_volatilities = []

for target in target_returns:
    constraints = (
        {'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
        {'type': 'eq', 'fun': lambda x: x @ returns - target}
    )
    result = minimize(lambda x: x @ cov_matrix @ x, initial_weights,
                      method='SLSQP', bounds=bounds, constraints=constraints)
    if result.success:
        efficient_volatilities.append(np.sqrt(result.fun))
    else:
        efficient_volatilities.append(np.nan)

efficient_volatilities = np.array(efficient_volatilities)
valid_idx = ~np.isnan(efficient_volatilities)

# Visualise efficient frontier
fig, ax = plt.subplots(figsize=(12, 8))

# Plot efficient frontier
ax.plot(efficient_volatilities[valid_idx] * 100, target_returns[valid_idx] * 100, 
        'b-', linewidth=2, label='Efficient Frontier')

# Plot optimal portfolio
ax.scatter(opt_volatility * 100, opt_return * 100, 
           color='red', s=100, zorder=5, label='Optimal Portfolio (Max Sharpe)')

# Plot individual assets
for i, asset in enumerate(asset_classes):
    ax.scatter(volatilities[i] * 100, returns[i] * 100, 
               label=asset, s=50)

ax.set_xlabel('Volatility (%)')
ax.set_ylabel('Expected Return (%)')
ax.set_title('Efficient Frontier')
ax.legend(loc='best')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('efficient_frontier_roboadvisor.png', dpi=300, bbox_inches='tight')
plt.show()
print("Efficient frontier visualisation saved as 'efficient_frontier_roboadvisor.png'")

# ----------------------------------------------------------------
# PART D: CLIENT RISK PROFILING
# ----------------------------------------------------------------

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

def risk_profile(age, income, investment_horizon, risk_tolerance, financial_goals):
    """Determine client risk profile."""
    # Simple scoring model
    score = 0
    
    # Age factor
    if age < 30:
        score += 3
    elif age < 45:
        score += 2
    elif age < 60:
        score += 1
    else:
        score += 0
    
    # Income factor
    if income > 150000:
        score += 2
    elif income > 75000:
        score += 1
    
    # Investment horizon factor
    if investment_horizon > 10:
        score += 3
    elif investment_horizon > 5:
        score += 2
    elif investment_horizon > 2:
        score += 1
    
    # Risk tolerance factor
    score += risk_tolerance  # 1-5 scale
    
    # Financial goals factor
    if financial_goals.lower() in ['growth', 'aggressive']:
        score += 3
    elif financial_goals.lower() in ['balanced', 'moderate']:
        score += 2
    else:
        score += 1
    
    # Determine profile
    if score >= 10:
        profile = 'Aggressive'
        equity_allocation = 0.80
        bond_allocation = 0.10
        alternative_allocation = 0.10
    elif score >= 7:
        profile = 'Moderate'
        equity_allocation = 0.60
        bond_allocation = 0.30
        alternative_allocation = 0.10
    else:
        profile = 'Conservative'
        equity_allocation = 0.30
        bond_allocation = 0.60
        alternative_allocation = 0.10
    
    return {
        'Profile': profile,
        'Equity Allocation': equity_allocation,
        'Bond Allocation': bond_allocation,
        'Alternative Allocation': alternative_allocation,
        'Score': score
    }

# Example clients
clients = [
    {'name': 'Young Professional', 'age': 28, 'income': 85000, 'horizon': 20, 'tolerance': 4, 'goals': 'Growth'},
    {'name': 'Family Person', 'age': 40, 'income': 120000, 'horizon': 15, 'tolerance': 3, 'goals': 'Balanced'},
    {'name': 'Near Retiree', 'age': 58, 'income': 95000, 'horizon': 7, 'tolerance': 2, 'goals': 'Preservation'}
]

print("Client Risk Profiles:")
for client in clients:
    profile = risk_profile(client['age'], client['income'], client['horizon'], 
                          client['tolerance'], client['goals'])
    print(f"\n{client['name']}:")
    print(f"  Profile: {profile['Profile']}")
    print(f"  Equity Allocation: {profile['Equity Allocation']*100:.0f}%")
    print(f"  Bond Allocation: {profile['Bond Allocation']*100:.0f}%")
    print(f"  Alternative Allocation: {profile['Alternative Allocation']*100:.0f}%")

# ----------------------------------------------------------------
# PART E: ROBO-ADVISORY METRICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Robo-Advisory Metrics Dashboard")
print("-"*60)

roboadvisor_metrics = pd.DataFrame({
    'Metric': [
        'AUM (Assets Under Management)',
        'Client Accounts',
        'Average Account Size',
        'Annual Return',
        'Client Retention',
        'NPS',
        'Average Fee',
        'Automation Rate'
    ],
    'Current Value': [
        '$1.5B',
        '45,000',
        '$33,000',
        '8.5%',
        '92%',
        '62',
        '0.25%',
        '95%'
    ],
    'Target Value': [
        '$5.0B',
        '100,000+',
        '$50,000+',
        '> 10%',
        '> 95%',
        '> 70',
        '< 0.20%',
        '> 98%'
    ],
    'Status': ['🟡', '🟡', '🟡', '🟡', '🟡', '🟡', '🟡', '🟡']
})

print("Robo-Advisory Metrics Dashboard:")
print(roboadvisor_metrics.to_string(index=False))

# ----------------------------------------------------------------
# PART F: ROBO-ADVISORY ROADMAP
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Robo-Advisory Roadmap")
print("-"*60)

roadmap = {
    "Phase 1 (0-6 months) – Foundation": {
        "Focus": "Build robo-advisory foundation.",
        "Activities": [
            "Develop risk profiling algorithm.",
            "Build portfolio optimisation engine.",
            "Implement core banking integration.",
            "Launch MVP with basic portfolios."
        ],
        "Success Metrics": ["MVP launched", "100+ clients"]
    },
    "Phase 2 (6-12 months) – Scale": {
        "Focus": "Scale robo-advisory capabilities.",
        "Activities": [
            "Add tax-loss harvesting.",
            "Implement goal-based planning.",
            "Enhance reporting and analytics.",
            "Launch mobile app."
        ],
        "Success Metrics": ["AUM > $500M", "Client retention > 90%"]
    },
    "Phase 3 (12-24 months) – Advanced": {
        "Focus": "Advanced wealth management.",
        "Activities": [
            "Launch hybrid advisory (human + digital).",
            "Add ESG and sustainable investing.",
            "Implement AI-powered personalisation.",
            "Launch institutional offering."
        ],
        "Success Metrics": ["AUM > $2B", "ESG assets > 25%"]
    },
    "Phase 4 (24+ months) – Leadership": {
        "Focus": "Industry-leading wealth management.",
        "Activities": [
            "Launch full-service wealth management.",
            "Build global capabilities.",
            "Achieve industry leadership.",
            "Continuous innovation."
        ],
        "Success Metrics": ["Industry-leading robo-advisory", "Continuous innovation"]
    }
}

for phase, details in roadmap.items():
    print(f"\n{phase}:")
    print(f"  Focus: {details['Focus']}")
    print("  Activities:")
    for activity in details['Activities']:
        print(f"    • {activity}")
    print("  Success Metrics:")
    for metric in details['Success Metrics']:
        print(f"    • {metric}")

# ----------------------------------------------------------------
# PART G: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

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

print("""
Wealth Management and Robo-Advisory – Key Takeaways:

1. Robo-advisory provides automated, algorithm-driven investment management.
2. Modern Portfolio Theory (MPT) underpins portfolio optimisation.
3. Key features: automated investing, rebalancing, tax-loss harvesting, low fees.
4. Risk profiling determines appropriate asset allocation.
5. Technology stack: customer interface, investment algorithm, portfolio management, trading.
6. Key metrics: AUM, client accounts, return, retention, NPS.
7. Roadmap: foundation → scale → advanced → leadership.

Recommendations:
  - Build risk profiling and portfolio optimisation capabilities.
  - Launch MVP with core robo-advisory features.
  - Scale with tax-loss harvesting and goal-based planning.
  - Offer hybrid advisory for mass affluent clients.
  - Add ESG and sustainable investing options.
  - Continuously improve personalisation and performance.
""")

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