┌─────────────────────────────────────────────────────────────────────────────┐
│                    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)          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    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)                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

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

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

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

# ----------------------------------------------------------------
# PART A: ASSET CLASS RETURNS AND RISKS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Asset Class Returns and Risks")
print("-"*60)

# Define asset classes and their characteristics
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 DataFrames
returns_df = pd.DataFrame({
    'Asset Class': asset_classes,
    'Expected Return (%)': returns,
    'Volatility (%)': volatilities
})

print("Asset Class Characteristics:")
print(returns_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('asset_correlations.png', dpi=300, bbox_inches='tight')
plt.show()
print("Asset correlation visualisation saved as 'asset_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.png', dpi=300, bbox_inches='tight')
plt.show()
print("Efficient frontier visualisation saved as 'efficient_frontier.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: ROBOT PORTFOLIO GENERATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Robo-Portfolio Generation")
print("-"*60)

def generate_robot_portfolio(risk_profile, asset_classes, returns, cov_matrix):
    """Generate a portfolio based on risk profile."""
    # Define asset allocation based on risk profile
    if risk_profile == 'Aggressive':
        allocations = [0.35, 0.25, 0.10, 0.05, 0.15, 0.08, 0.02]  # US Equities, Intl Equities, US Bonds, Intl Bonds, Real Estate, Commodities, Cash
    elif risk_profile == 'Moderate':
        allocations = [0.25, 0.20, 0.20, 0.10, 0.10, 0.10, 0.05]
    else:  # Conservative
        allocations = [0.10, 0.10, 0.35, 0.20, 0.05, 0.05, 0.15]
    
    # Normalise
    allocations = np.array(allocations) / np.sum(allocations)
    
    # Calculate portfolio performance
    port_return, port_volatility = portfolio_performance(allocations, returns, cov_matrix)
    sharpe = (port_return - 0.02) / port_volatility
    
    # Create DataFrame
    portfolio_df = pd.DataFrame({
        'Asset Class': asset_classes,
        'Allocation (%)': allocations * 100
    })
    
    return {
        'Allocations': portfolio_df,
        'Expected Return': port_return,
        'Volatility': port_volatility,
        'Sharpe Ratio': sharpe
    }

# Generate portfolios for different risk profiles
for profile in ['Aggressive', 'Moderate', 'Conservative']:
    print(f"\n{profile} Portfolio:")
    portfolio = generate_robot_portfolio(profile, asset_classes, returns, cov_matrix)
    print(portfolio['Allocations'].to_string(index=False))
    print(f"Expected Return: {portfolio['Expected Return']*100:.2f}%")
    print(f"Volatility: {portfolio['Volatility']*100:.2f}%")
    print(f"Sharpe Ratio: {portfolio['Sharpe Ratio']:.3f}")

# ----------------------------------------------------------------
# PART F: ROBO-ADVISORY BUSINESS MODEL
# ----------------------------------------------------------------

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

# Simulate a robo-advisory business model
client_segments = ['Mass Market', 'Mass Affluent', 'High-Net-Worth']
client_counts = [10000, 2000, 200]
avg_assets = [10000, 100000, 1000000]
fee_rates = [0.0025, 0.0035, 0.0050]
acquisition_cost = [50, 200, 500]
operating_cost = [10, 30, 100]

business_model = []
for i, segment in enumerate(client_segments):
    total_assets = client_counts[i] * avg_assets[i]
    revenue = total_assets * fee_rates[i]
    acq_cost = client_counts[i] * acquisition_cost[i]
    op_cost = client_counts[i] * operating_cost[i]
    profit = revenue - acq_cost - op_cost
    
    business_model.append({
        'Segment': segment,
        'Clients': client_counts[i],
        'Average Assets': f'${avg_assets[i]:,}',
        'Total Assets': f'${total_assets:,.0f}',
        'Fee Rate': f'{fee_rates[i]*100:.2f}%',
        'Revenue': f'${revenue:,.0f}',
        'Profit': f'${profit:,.0f}'
    })

bm_df = pd.DataFrame(business_model)
print("Robo-Advisory Business Model:")
print(bm_df.to_string(index=False))

# ----------------------------------------------------------------
# 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. Wealth management has evolved from traditional to digital and AI-powered.
2. Robo-advisory provides automated, low-cost, and accessible investment management.
3. Modern Portfolio Theory underpins portfolio optimisation.
4. Client risk profiling determines the appropriate asset allocation.
5. Regulatory compliance is essential (fiduciary duty, suitability, disclosure).
6. Business models vary from pure-play robo to hybrid human-digital.

Recommendations:
  - Build a robo-advisory platform with Modern Portfolio Theory.
  - Implement client risk profiling algorithms.
  - Offer hybrid advisory (human + digital) for mass affluent and HNW clients.
  - Ensure regulatory compliance (fiduciary duty, disclosure).
  - Invest in AI for personalisation and predictive analytics.
  - Develop an ESG investment offering.
""")

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