import numpy as np
import pandas as pd
from scipy.optimize import minimize
from typing import Dict, List, Tuple
from dataclasses import dataclass, field
import uuid

class RoboAdvisorDataGenerator:
    """Generate synthetic market data and investor profiles."""
    
    @staticmethod
    def generate_asset_returns(n_assets=10, n_years=10):
        np.random.seed(42)
        
        asset_names = ['US_Stock', 'Intl_Stock', 'Emerging', 'US_Bond', 'Intl_Bond',
                       'REIT', 'Commodities', 'TIPS', 'Small_Cap', 'Value']
        
        mu = np.array([0.10, 0.08, 0.11, 0.04, 0.035, 0.07, 0.05, 0.03, 0.12, 0.09])
        sigma = np.array([0.18, 0.20, 0.25, 0.06, 0.08, 0.22, 0.15, 0.05, 0.22, 0.16])
        
        corr = np.eye(n_assets)
        corr[0, 1] = corr[1, 0] = 0.75
        corr[0, 4] = corr[4, 0] = 0.1
        corr[2, 5] = corr[5, 2] = 0.3
        
        cov = np.outer(sigma, sigma) * corr
        
        daily_returns = np.random.multivariate_normal(mu/252, cov/252, n_years*252)
        
        return pd.DataFrame(daily_returns, columns=asset_names)
    
    @staticmethod
    def generate_investor_profiles(n_investors=100):
        np.random.seed(42)
        
        profiles = []
        for i in range(n_investors):
            age = np.random.randint(25, 65)
            income = np.random.lognormal(10.5, 0.5)
            risk_tolerance = np.clip(0.3 + 0.01 * (65 - age) + 0.000001 * income + np.random.randn() * 0.15, 0, 1)
            
            profiles.append({
                'investor_id': f'INV_{i:04d}',
                'age': age,
                'income': income,
                'risk_tolerance': risk_tolerance,
                'investment_horizon': max(65 - age, 5),
                'initial_investment': np.random.lognormal(10, 1)
            })
        
        return profiles

class MeanVarianceOptimizer:
    """Portfolio optimization using mean-variance framework."""
    
    def __init__(self, risk_aversion: float = 3.0):
        self.risk_aversion = risk_aversion
        
    def optimize(self, expected_returns: np.ndarray, cov_matrix: np.ndarray,
                constraints: Dict = None) -> np.ndarray:
        n = len(expected_returns)
        
        if constraints is None:
            constraints = {'max_weight': 0.40, 'min_weight': 0.0}
        
        bounds = tuple(
            (constraints.get('min_weight', 0.0), constraints.get('max_weight', 0.40))
            for _ in range(n)
        )
        
        def objective(w):
            port_return = expected_returns @ w
            port_risk = w @ cov_matrix @ w
            return -(port_return - 0.5 * self.risk_aversion * port_risk)
        
        constraints_list = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1}]
        
        w0 = np.ones(n) / n
        result = minimize(objective, w0, method='SLSQP', bounds=bounds, constraints=constraints_list)
        
        return result.x

class TaxLossHarvester:
    """Tax-loss harvesting engine."""
    
    def __init__(self):
        self.wash_sale_window = 30
        
    def find_harvest_candidates(self, positions: List[dict]) -> List[dict]:
        candidates = []
        
        for pos in positions:
            if pos['current_value'] < pos['cost_basis']:
                loss = pos['cost_basis'] - pos['current_value']
                candidates.append({
                    'asset': pos['asset'],
                    'loss': loss,
                    'cost_basis': pos['cost_basis'],
                    'current_value': pos['current_value']
                })
        
        return sorted(candidates, key=lambda x: x['loss'], reverse=True)
    
    def calculate_harvest_benefit(self, loss: float, tax_rate: float = 0.30) -> float:
        immediate_benefit = loss * tax_rate
        
        carryforward_value = min(loss, 3000) * tax_rate
        
        return immediate_benefit + carryforward_value * 0.1

class RoboAdvisorPlatform:
    """Complete robo-advisor platform."""
    
    def __init__(self):
        self.optimizer = MeanVarianceOptimizer()
        self.harvester = TaxLossHarvester()
        self.investor_portfolios: Dict[str, dict] = {}
        self.model_portfolios = self._create_model_portfolios()
        
    def _create_model_portfolios(self) -> Dict[str, np.ndarray]:
        portfolios = {
            'conservative': np.array([0.20, 0.10, 0.05, 0.35, 0.15, 0.05, 0.05, 0.05, 0.00, 0.00]),
            'moderate': np.array([0.35, 0.15, 0.10, 0.20, 0.10, 0.05, 0.03, 0.02, 0.00, 0.00]),
            'aggressive': np.array([0.45, 0.20, 0.15, 0.05, 0.05, 0.05, 0.03, 0.02, 0.00, 0.00]),
        }
        
        for name in portfolios:
            portfolios[name] /= portfolios[name].sum()
        
        return portfolios
    
    def create_investor_profile(self, investor_id: str, risk_questionnaire: dict) -> dict:
        risk_score = (
            risk_questionnaire.get('risk_tolerance', 5) / 10 * 0.4 +
            risk_questionnaire.get('investment_horizon', 10) / 30 * 0.3 +
            (1 - risk_questionnaire.get('loss_aversion', 5) / 10) * 0.3
        )
        
        if risk_score < 0.33:
            model = 'conservative'
        elif risk_score < 0.66:
            model = 'moderate'
        else:
            model = 'aggressive'
        
        profile = {
            'investor_id': investor_id,
            'risk_score': risk_score,
            'model_portfolio': model,
            'target_allocation': self.model_portfolios[model].copy(),
            'created_at': len(self.investor_portfolios)
        }
        
        self.investor_portfolios[investor_id] = profile
        return profile
    
    def invest(self, investor_id: str, amount: float, asset_names: List[str]) -> dict:
        profile = self.investor_portfolios[investor_id]
        allocation = profile['target_allocation']
        
        investments = {}
        for i, (name, weight) in enumerate(zip(asset_names, allocation)):
            investments[name] = amount * weight
        
        return {
            'investor_id': investor_id,
            'total_invested': amount,
            'allocations': investments,
            'model': profile['model_portfolio']
        }
    
    def check_rebalance(self, investor_id: str, current_values: Dict[str, float],
                       target_allocation: Dict[str, float], threshold: float = 0.05) -> bool:
        total_value = sum(current_values.values())
        
        drift = 0
        for asset, value in current_values.items():
            current_weight = value / total_value
            target_weight = target_allocation.get(asset, 0)
            drift += abs(current_weight - target_weight)
        
        return drift > threshold
    
    def get_performance_metrics(self, returns: np.ndarray, risk_free_rate: float = 0.04) -> dict:
        total_return = np.prod(1 + returns) - 1
        n_years = len(returns) / 252
        
        annual_return = (1 + total_return) ** (1/n_years) - 1
        annual_volatility = np.std(returns) * np.sqrt(252)
        sharpe_ratio = (annual_return - risk_free_rate) / annual_volatility
        
        cumulative = np.cumprod(1 + returns)
        running_max = np.maximum.accumulate(cumulative)
        drawdown = (cumulative - running_max) / running_max
        max_drawdown = np.min(drawdown)
        
        return {
            'total_return': total_return,
            'annual_return': annual_return,
            'annual_volatility': annual_volatility,
            'sharpe_ratio': sharpe_ratio,
            'max_drawdown': max_drawdown
        }

# Example usage
if __name__ == "__main__":
    returns_df = RoboAdvisorDataGenerator.generate_asset_returns(n_assets=10, n_years=5)
    
    asset_names = returns_df.columns.tolist()
    
    expected_returns = returns_df.mean().values * 252
    cov_matrix = returns_df.cov().values * 252
    
    platform = RoboAdvisorPlatform()
    
    investor_profiles = RoboAdvisorDataGenerator.generate_investor_profiles(5)
    
    for profile in investor_profiles:
        risk_questionnaire = {
            'risk_tolerance': int(profile['risk_tolerance'] * 10),
            'investment_horizon': profile['investment_horizon'],
            'loss_aversion': 5
        }
        
        investor_profile = platform.create_investor_profile(
            profile['investor_id'], risk_questionnaire
        )
        
        investment = platform.invest(
            profile['investor_id'],
            profile['initial_investment'],
            asset_names
        )
        
        print(f"\n{profile['investor_id']}:")
        print(f"  Risk Score: {investor_profile['risk_score']:.3f}")
        print(f"  Model: {investor_profile['model_portfolio']}")
        print(f"  Invested: ${profile['initial_investment']:,.2f}")
        print(f"  Allocation:")
        for asset, amount in investment['allocations'].items():
            if amount > 0:
                print(f"    {asset}: ${amount:,.2f}")
    
    portfolio_returns = returns_df.values @ platform.model_portfolios['moderate']
    metrics = platform.get_performance_metrics(portfolio_returns)
    
    print(f"\nModerate Portfolio Performance (5 years):")
    print(f"  Annual Return: {metrics['annual_return']*100:.2f}%")
    print(f"  Annual Volatility: {metrics['annual_volatility']*100:.2f}%")
    print(f"  Sharpe Ratio: {metrics['sharpe_ratio']:.3f}")
    print(f"  Max Drawdown: {metrics['max_drawdown']*100:.2f}%")