Complete_Model_Python

"""
COMPLETE ULTIMATE TRADING SYSTEM
=================================

The definitive trading platform with ALL features integrated:

CORE FEATURES:
- Interactive user input & custom ticker selection
- Real-time trading signals (BUY/SELL/HOLD)
- 5 Trading strategies (MA, Mean Reversion, RSI, BB, Momentum)
- Regime-aware strategy allocation
- Complete backtesting framework
- Walk-forward testing & validation
- Monte Carlo simulation
- 6+ Comprehensive visualizations
- Performance comparison tables
- Portfolio mode for multi-asset analysis

ADVANCED FEATURES:
- Multi-timeframe analysis (daily/weekly/monthly alignment)
- Machine learning regime prediction
- Automatic parameter optimization
- Portfolio optimization (Markowitz, Risk Parity)
- Enhanced backtesting with realistic costs
- Real-time alert system with export
- Advanced performance metrics

This is the complete, production-ready system.
"""

import yfinance as yf
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import warnings
from datetime import datetime, timedelta
from typing import Tuple, Dict, List, Optional
import seaborn as sns
import json


from scipy.optimize import minimize
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.preprocessing import StandardScaler
from dataclasses import dataclass
from enum import Enum

warnings.filterwarnings('ignore')
plt.style.use('seaborn-v0_8-darkgrid')

# ==================================================
# CONFIGURATION
# ==================================================

class Config:
    """Centralized configuration management"""

    # Data Parameters
    START_DATE = "2010-01-01"
    DEFAULT_UNIVERSE = ["SPY", "QQQ", "IWM", "EFA", "EEM"]

    # Strategy Parameters
    LOOKBACK_MOM = 126  # ~6 months
    TOP_N = 2
    TARGET_VOL = 0.10
    REB_FREQ = "ME"  # Month End
    VOL_LOOKBACK = 20
    VOL_THRESHOLD = 0.20
    REGIME_CONFIRM_DAYS = 5

    # MA Parameters
    MA_FAST = 50
    MA_SLOW = 200

    # Z-Score Parameters
    ZSCORE_WINDOW = 20
    ZSCORE_ENTRY = -1.0
    ZSCORE_EXIT = 0.0

    # RSI Parameters
    RSI_PERIOD = 14
    RSI_OVERSOLD = 30
    RSI_OVERBOUGHT = 70

    # Bollinger Bands Parameters
    BB_PERIOD = 20
    BB_STD = 2.0

    # Performance Parameters
    ROLL_WINDOW = 252
    TRANSACTION_COST = 0.001  # 10 bps

    # Walk-Forward Parameters
    TRAIN_YEARS = 5
    TEST_YEARS = 1

    # Monte Carlo Parameters
    MC_SIMULATIONS = 1000
    MC_SAMPLE_SIZE = 252  # 1 year

    # Multi-Timeframe Parameters
    TIMEFRAMES = {
        'daily': '1d',
        'weekly': '1wk',
        'monthly': '1mo'
    }

    # Alert Parameters
    DRAWDOWN_ALERT_THRESHOLD = 0.05  # 5% drawdown triggers alert

    # ML Parameters
    ML_LOOKBACK_FEATURES = 60  # Days for feature calculation
    ML_TRAIN_SIZE = 1000  # Minimum training samples

    # Enhanced Backtesting Parameters
    SLIPPAGE = 0.0005  # 5 bps
    MARKET_IMPACT = 0.0002  # 2 bps

    # Portfolio Optimization Parameters
    RISK_FREE_RATE = 0.04  # 4% annual
    MAX_POSITION_SIZE = 0.25  # 25% max per position
    MIN_POSITION_SIZE = 0.01  # 1% min per position


# ==================================================
# ENUMS AND DATA CLASSES
# ==================================================

class Signal(Enum):
    """Trading signal enumeration"""
    STRONG_BUY = 2
    BUY = 1
    HOLD = 0
    SELL = -1
    STRONG_SELL = -2

@dataclass


class Alert:
    """Alert data structure"""
    timestamp: datetime
    ticker: str
    signal: Signal
    strategy: str
    price: float
    confidence: float
    message: str
    timeframes_aligned: bool

@dataclass


class TradeRecommendation:
    """Trade recommendation structure"""
    ticker: str
    action: str  # BUY, SELL, HOLD
    current_price: float
    target_price: float
    stop_loss: float
    position_size: float  # As percentage of portfolio
    confidence: float
    timeframe_alignment: Dict[str, str]
    strategies_agreeing: List[str]
    regime: str
    risk_reward_ratio: float

# ==================================================
# DATA MANAGEMENT
# ==================================================



# ==================================================
# DATA VALIDATION & FETCHING
# ==================================================

class DataManager:
    """Manage data fetching and validation for securities"""

    @staticmethod
    def validate_ticker(ticker: str) -> Tuple[bool, str]:
        """Validate if ticker exists and has data"""
        try:
            stock = yf.Ticker(ticker)
            info = stock.info

            # Check if ticker is valid
            if not info or 'regularMarketPrice' not in info:
                return False, f"Ticker {ticker} not found or has no data"

            return True, f"Valid ticker: {info.get('shortName', ticker)}"
        except Exception as e:
            return False, f"Error validating {ticker}: {str(e)}"

    @staticmethod
    def fetch_data(tickers: List[str], start_date: str,
                   end_date: Optional[str] = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
        """Fetch historical price data for given tickers"""
        try:
            data = yf.download(
                tickers,
                start=start_date,
                end=end_date,
                auto_adjust=True,
                progress=False
            )

            if len(tickers) == 1:
                # For single ticker, extract Close column and convert to DataFrame
                if "Close" in data.columns:
                    prices = pd.DataFrame(data["Close"])
                    prices.columns = [tickers[0]]
                else:
                    # Handle case where Close is the only column
                    prices = pd.DataFrame(data)
                    if prices.shape[1] == 1:
                        prices.columns = [tickers[0]]
            else:
                # For multiple tickers
                if isinstance(data.columns, pd.MultiIndex):
                    prices = data["Close"]
                else:
                    prices = data

            returns = prices.pct_change(fill_method=None).dropna()

            return prices, returns
        except Exception as e:
            raise ValueError(f"Error fetching data: {str(e)}")

    @staticmethod
    def get_ticker_info(ticker: str) -> Dict:
        """Get detailed information about a ticker"""
        try:
            stock = yf.Ticker(ticker)
            info = stock.info

            return {
                'name': info.get('shortName', ticker),
                'sector': info.get('sector', 'N/A'),
                'industry': info.get('industry', 'N/A'),
                'market_cap': info.get('marketCap', 'N/A'),
                'currency': info.get('currency', 'USD'),
                'exchange': info.get('exchange', 'N/A')
            }
        except:
            return {'name': ticker, 'sector': 'N/A', 'industry': 'N/A',
                   'market_cap': 'N/A', 'currency': 'USD', 'exchange': 'N/A'}

    @staticmethod
    def fetch_multi_timeframe(ticker: str, start_date: str) -> Dict[str, pd.DataFrame]:
        """Fetch data across multiple timeframes"""
        data = {}
        for name, interval in Config.TIMEFRAMES.items():
            try:
                raw_data = yf.download(
                    ticker,
                    start=start_date,
                    interval=interval,
                    auto_adjust=True,
                    progress=False
                )

                if not raw_data.empty and "Close" in raw_data.columns:
                    prices = pd.DataFrame(raw_data["Close"])
                    prices.columns = [ticker]
                    data[name] = prices
                else:
                    data[name] = None
            except Exception as e:
                print(f"Could not fetch {name} data: {str(e)}")
                data[name] = None
        return data

# ==================================================
# UTILITY FUNCTIONS
# ==================================================

def safe_divide(numerator: pd.Series, denominator: pd.Series,
                fill_value: float = 0.0) -> pd.Series:
    """Safely divide two series, handling zeros and NaNs"""
    result = numerator / denominator
    result = result.replace([np.inf, -np.inf], fill_value)
    return result.fillna(fill_value)

def compute_zscore(series: pd.Series, window: int) -> pd.Series:
    """Compute rolling z-score"""
    mean = series.rolling(window).mean()
    std = series.rolling(window).std()
    return safe_divide(series - mean, std)

def compute_returns(prices: pd.DataFrame, periods: int = 1) -> pd.DataFrame:
    """Compute returns with proper handling of missing data"""
    return prices.pct_change(periods, fill_method=None)

def compute_rsi(prices: pd.Series, period: int = 14) -> pd.Series:
    """Compute Relative Strength Index"""
    delta = prices.diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
    rs = safe_divide(gain, loss, fill_value=100)
    rsi = 100 - (100 / (1 + rs))
    return rsi

def compute_bollinger_bands(prices: pd.Series, period: int = 20,
                           num_std: float = 2.0) -> Tuple[pd.Series, pd.Series, pd.Series]:
    """Compute Bollinger Bands"""
    middle = prices.rolling(window=period).mean()
    std = prices.rolling(window=period).std()
    upper = middle + (std * num_std)
    lower = middle - (std * num_std)
    return upper, middle, lower

# ==================================================
# INSTITUTIONAL-GRADE PERFORMANCE ANALYTICS
# ==================================================

class PerformanceAnalytics:
    """
    Comprehensive institutional-grade performance metrics

    Features:
    - Return metrics (Total, CAGR, Excess)
    - Risk-adjusted ratios (Sharpe, Sortino, Calmar, Information, Omega)
    - Drawdown analysis (Max, Average, Recovery, Ulcer Index)
    - Distribution metrics (Skewness, Kurtosis, Tail risk)
    - Trading metrics (Win rate, Profit factor, Expectancy, Payoff ratio)
    - Risk metrics (VaR, CVaR, Downside deviation, Tracking error)
    - Consistency metrics (Gain/Pain ratio, Sterling ratio, Burke ratio)
    - Time-based analysis (Monthly/Yearly returns, Rolling metrics)
    """

    # Risk-free rate for Sharpe/Sortino calculations
    RISK_FREE_RATE = 0.04  # 4% annual

    @staticmethod
    def calculate_metrics(returns: pd.Series, benchmark: Optional[pd.Series] = None,
                         risk_free_rate: float = None) -> Dict[str, float]:
        """
        Calculate comprehensive performance metrics

        Args:
            returns: Series of period returns
            benchmark: Optional benchmark returns for relative metrics
            risk_free_rate: Annual risk-free rate (default 4%)

        Returns:
            Dictionary with 40+ performance metrics
        """
        if risk_free_rate is None:
            risk_free_rate = PerformanceAnalytics.RISK_FREE_RATE

        returns = returns.dropna()

        if len(returns) == 0:
            return PerformanceAnalytics._empty_metrics()

        # Basic equity curve
        equity = (1 + returns).cumprod()

        # Initialize metrics dict
        metrics = {}

        # =====================================================
        # SECTION 1: RETURN METRICS
        # =====================================================
        metrics['total_return'] = equity.iloc[-1] - 1
        metrics['num_periods'] = len(returns)
        metrics['num_years'] = len(returns) / 252

        # CAGR (Compound Annual Growth Rate)
        if len(returns) > 0:
            metrics['cagr'] = (equity.iloc[-1] ** (252 / len(returns))) - 1
        else:
            metrics['cagr'] = 0

        # Excess return over risk-free rate
        daily_rf = risk_free_rate / 252
        metrics['excess_return'] = metrics['cagr'] - risk_free_rate

        # Average returns
        metrics['avg_daily_return'] = returns.mean()
        metrics['avg_monthly_return'] = returns.mean() * 21
        metrics['avg_annual_return'] = returns.mean() * 252

        # Geometric mean return
        metrics['geometric_mean'] = ((1 + returns).prod() ** (252 / len(returns))) - 1

        # =====================================================
        # SECTION 2: VOLATILITY & RISK METRICS
        # =====================================================
        metrics['volatility'] = returns.std() * np.sqrt(252)
        metrics['downside_volatility'] = PerformanceAnalytics._downside_deviation(returns, risk_free_rate)

        # Tracking error (if benchmark provided)
        if benchmark is not None:
            aligned_bench = benchmark.reindex(returns.index).fillna(0)
            tracking_diff = returns - aligned_bench
            metrics['tracking_error'] = tracking_diff.std() * np.sqrt(252)
            metrics['information_ratio'] = PerformanceAnalytics._information_ratio(
                returns, aligned_bench
            )
        else:
            metrics['tracking_error'] = 0
            metrics['information_ratio'] = 0

        # =====================================================
        # SECTION 3: RISK-ADJUSTED RETURN RATIOS
        # =====================================================

        # Sharpe Ratio: (Return - RiskFree) / Volatility
        excess_daily = returns.mean() - daily_rf
        if returns.std() > 0:
            metrics['sharpe'] = (excess_daily / returns.std()) * np.sqrt(252)
        else:
            metrics['sharpe'] = 0

        # Sortino Ratio: (Return - RiskFree) / Downside Volatility
        if metrics['downside_volatility'] > 0:
            metrics['sortino'] = metrics['excess_return'] / metrics['downside_volatility']
        else:
            metrics['sortino'] = 0

        # Calmar Ratio: CAGR / Max Drawdown
        drawdown_series = PerformanceAnalytics.get_drawdown_series(returns)
        max_dd = abs(drawdown_series.min())
        metrics['max_drawdown'] = -max_dd

        if max_dd > 0:
            metrics['calmar'] = metrics['cagr'] / max_dd
        else:
            metrics['calmar'] = 0

        # Omega Ratio: Probability-weighted gains vs losses
        metrics['omega'] = PerformanceAnalytics._omega_ratio(returns, risk_free_rate)

        # Gain-to-Pain Ratio: Sum(gains) / Sum(|losses|)
        metrics['gain_to_pain'] = PerformanceAnalytics._gain_to_pain(returns)

        # Sterling Ratio: CAGR / Average Max Drawdown (3 years)
        metrics['sterling'] = PerformanceAnalytics._sterling_ratio(returns, drawdown_series)

        # Burke Ratio: CAGR / Square root of sum of squared drawdowns
        metrics['burke'] = PerformanceAnalytics._burke_ratio(returns, drawdown_series)

        # =====================================================
        # SECTION 4: DRAWDOWN ANALYSIS
        # =====================================================
        metrics['avg_drawdown'] = drawdown_series[drawdown_series < 0].mean()
        metrics['max_drawdown_duration'] = PerformanceAnalytics._max_drawdown_duration(drawdown_series)
        metrics['avg_drawdown_duration'] = PerformanceAnalytics._avg_drawdown_duration(drawdown_series)
        metrics['recovery_factor'] = PerformanceAnalytics._recovery_factor(
            metrics['total_return'], max_dd
        )
        metrics['ulcer_index'] = PerformanceAnalytics._ulcer_index(drawdown_series)

        # Pain Index: Average of squared drawdowns
        metrics['pain_index'] = (drawdown_series ** 2).mean() * 100

        # =====================================================
        # SECTION 5: DISTRIBUTION METRICS
        # =====================================================
        metrics['skewness'] = returns.skew()
        metrics['kurtosis'] = returns.kurtosis()
        metrics['excess_kurtosis'] = metrics['kurtosis'] - 3  # Excess over normal

        # =====================================================
        # SECTION 6: TAIL RISK METRICS
        # =====================================================
        metrics['var_95'] = returns.quantile(0.05)  # 95% VaR
        metrics['var_99'] = returns.quantile(0.01)  # 99% VaR
        metrics['cvar_95'] = returns[returns <= metrics['var_95']].mean()  # Expected Shortfall
        metrics['cvar_99'] = returns[returns <= metrics['var_99']].mean()

        # Tail Ratio: 95th percentile / 5th percentile
        metrics['tail_ratio'] = abs(returns.quantile(0.95) / returns.quantile(0.05))

        # =====================================================
        # SECTION 7: TRADING METRICS
        # =====================================================

        # Win rate and related
        winners = returns[returns > 0]
        losers = returns[returns < 0]

        metrics['win_rate'] = len(winners) / len(returns) if len(returns) > 0 else 0
        metrics['loss_rate'] = len(losers) / len(returns) if len(returns) > 0 else 0

        # Average win/loss
        metrics['avg_win'] = winners.mean() if len(winners) > 0 else 0
        metrics['avg_loss'] = losers.mean() if len(losers) > 0 else 0

        # Largest win/loss
        metrics['largest_win'] = winners.max() if len(winners) > 0 else 0
        metrics['largest_loss'] = losers.min() if len(losers) > 0 else 0

        # Payoff Ratio: Average Win / Average Loss
        if metrics['avg_loss'] != 0:
            metrics['payoff_ratio'] = abs(metrics['avg_win'] / metrics['avg_loss'])
        else:
            metrics['payoff_ratio'] = 0

        # Profit Factor: Gross Profit / Gross Loss
        gross_profit = winners.sum()
        gross_loss = abs(losers.sum())

        if gross_loss > 0:
            metrics['profit_factor'] = gross_profit / gross_loss
        else:
            metrics['profit_factor'] = 0

        # Expectancy: (Win Rate × Avg Win) - (Loss Rate × |Avg Loss|)
        metrics['expectancy'] = (
            metrics['win_rate'] * metrics['avg_win'] +
            metrics['loss_rate'] * metrics['avg_loss']
        )

        # =====================================================
        # SECTION 8: CONSISTENCY METRICS
        # =====================================================

        # Percentage of positive days/periods
        metrics['positive_periods_pct'] = metrics['win_rate']

        # Longest winning/losing streaks
        metrics['max_winning_streak'] = PerformanceAnalytics._max_streak(returns, positive=True)
        metrics['max_losing_streak'] = PerformanceAnalytics._max_streak(returns, positive=False)

        # =====================================================
        # SECTION 9: TIME-BASED METRICS
        # =====================================================

        # Best/worst day
        metrics['best_day'] = returns.max()
        metrics['worst_day'] = returns.min()

        # Best/worst month (approximate)
        if len(returns) >= 21:
            rolling_month = returns.rolling(21).sum()
            metrics['best_month'] = rolling_month.max()
            metrics['worst_month'] = rolling_month.min()
        else:
            metrics['best_month'] = 0
            metrics['worst_month'] = 0

        return metrics

    @staticmethod
    def _downside_deviation(returns: pd.Series, risk_free_rate: float) -> float:
        """Calculate downside deviation (semi-deviation below risk-free rate)"""
        daily_rf = risk_free_rate / 252
        downside_returns = returns[returns < daily_rf]

        if len(downside_returns) == 0:
            return 0

        return np.sqrt(((downside_returns - daily_rf) ** 2).mean()) * np.sqrt(252)

    @staticmethod
    def _information_ratio(returns: pd.Series, benchmark: pd.Series) -> float:
        """Calculate Information Ratio: Excess return / Tracking error"""
        excess = returns - benchmark

        if excess.std() == 0:
            return 0

        return (excess.mean() / excess.std()) * np.sqrt(252)

    @staticmethod
    def _omega_ratio(returns: pd.Series, threshold: float) -> float:
        """
        Calculate Omega Ratio

        Omega = Sum of gains above threshold / Sum of losses below threshold
        Better captures entire return distribution than Sharpe
        """
        daily_threshold = threshold / 252

        gains = returns[returns > daily_threshold] - daily_threshold
        losses = daily_threshold - returns[returns < daily_threshold]

        if losses.sum() == 0:
            return 0

        return gains.sum() / losses.sum()

    @staticmethod
    def _gain_to_pain(returns: pd.Series) -> float:
        """Calculate Gain-to-Pain Ratio: Sum(positive) / Sum(|negative|)"""
        gains = returns[returns > 0].sum()
        pains = abs(returns[returns < 0].sum())

        if pains == 0:
            return 0

        return gains / pains

    @staticmethod
    def _sterling_ratio(returns: pd.Series, drawdown_series: pd.Series) -> float:
        """
        Calculate Sterling Ratio

        Sterling = CAGR / Average of worst N drawdowns
        """
        cagr = ((1 + returns).prod() ** (252 / len(returns))) - 1

        # Get worst drawdowns per year
        years = len(returns) / 252
        n_periods = max(1, int(years))

        # Get N worst drawdowns
        dd_values = drawdown_series[drawdown_series < 0]
        if len(dd_values) == 0:
            return 0

        worst_dds = dd_values.nsmallest(min(n_periods, len(dd_values)))
        avg_worst_dd = abs(worst_dds.mean())

        if avg_worst_dd == 0:
            return 0

        return cagr / avg_worst_dd

    @staticmethod
    def _burke_ratio(returns: pd.Series, drawdown_series: pd.Series) -> float:
        """
        Calculate Burke Ratio

        Burke = CAGR / sqrt(sum of squared drawdowns)
        """
        cagr = ((1 + returns).prod() ** (252 / len(returns))) - 1

        squared_dd_sum = (drawdown_series ** 2).sum()

        if squared_dd_sum == 0:
            return 0

        return cagr / np.sqrt(squared_dd_sum)

    @staticmethod
    def _max_drawdown_duration(drawdown_series: pd.Series) -> int:
        """Calculate maximum drawdown duration in periods"""
        underwater = (drawdown_series < 0).astype(int)

        # Find continuous underwater periods
        underwater_diff = underwater.diff()
        starts = drawdown_series.index[underwater_diff == 1].tolist()
        ends = drawdown_series.index[underwater_diff == -1].tolist()

        # Handle case where still underwater at end
        if len(starts) > len(ends):
            ends.append(drawdown_series.index[-1])

        if len(starts) == 0:
            return 0

        # Calculate durations
        durations = []
        for start, end in zip(starts, ends):
            duration = (drawdown_series.index.get_loc(end) -
                       drawdown_series.index.get_loc(start))
            durations.append(duration)

        return max(durations) if durations else 0

    @staticmethod
    def _avg_drawdown_duration(drawdown_series: pd.Series) -> float:
        """Calculate average drawdown duration"""
        underwater = (drawdown_series < 0).astype(int)

        # Find continuous underwater periods
        underwater_diff = underwater.diff()
        starts = drawdown_series.index[underwater_diff == 1].tolist()
        ends = drawdown_series.index[underwater_diff == -1].tolist()

        if len(starts) > len(ends):
            ends.append(drawdown_series.index[-1])

        if len(starts) == 0:
            return 0

        # Calculate durations
        durations = []
        for start, end in zip(starts, ends):
            duration = (drawdown_series.index.get_loc(end) -
                       drawdown_series.index.get_loc(start))
            durations.append(duration)

        return np.mean(durations) if durations else 0

    @staticmethod
    def _recovery_factor(total_return: float, max_drawdown: float) -> float:
        """
        Calculate Recovery Factor

        Recovery = Net Profit / Max Drawdown
        """
        if max_drawdown == 0:
            return 0

        return total_return / max_drawdown

    @staticmethod
    def _ulcer_index(drawdown_series: pd.Series) -> float:
        """
        Calculate Ulcer Index

        Ulcer = sqrt(mean of squared drawdowns)
        Measures depth and duration of drawdowns
        """
        return np.sqrt((drawdown_series ** 2).mean()) * 100

    @staticmethod
    def _max_streak(returns: pd.Series, positive: bool = True) -> int:
        """Calculate maximum winning or losing streak"""
        if positive:
            streak_series = (returns > 0).astype(int)
        else:
            streak_series = (returns < 0).astype(int)

        # Count consecutive occurrences
        streaks = []
        current_streak = 0

        for val in streak_series:
            if val == 1:
                current_streak += 1
            else:
                if current_streak > 0:
                    streaks.append(current_streak)
                current_streak = 0

        # Don't forget last streak
        if current_streak > 0:
            streaks.append(current_streak)

        return max(streaks) if streaks else 0

    @staticmethod
    def _empty_metrics() -> Dict[str, float]:
        """Return empty metrics dictionary"""
        keys = [
            'total_return', 'num_periods', 'num_years', 'cagr', 'excess_return',
            'avg_daily_return', 'avg_monthly_return', 'avg_annual_return', 'geometric_mean',
            'volatility', 'downside_volatility', 'tracking_error', 'information_ratio',
            'sharpe', 'sortino', 'calmar', 'omega', 'gain_to_pain', 'sterling', 'burke',
            'max_drawdown', 'avg_drawdown', 'max_drawdown_duration', 'avg_drawdown_duration',
            'recovery_factor', 'ulcer_index', 'pain_index',
            'skewness', 'kurtosis', 'excess_kurtosis',
            'var_95', 'var_99', 'cvar_95', 'cvar_99', 'tail_ratio',
            'win_rate', 'loss_rate', 'avg_win', 'avg_loss', 'largest_win', 'largest_loss',
            'payoff_ratio', 'profit_factor', 'expectancy',
            'positive_periods_pct', 'max_winning_streak', 'max_losing_streak',
            'best_day', 'worst_day', 'best_month', 'worst_month'
        ]
        return {k: 0.0 for k in keys}

    @staticmethod
    def rolling_sharpe(returns: pd.Series, window: int = 252) -> pd.Series:
        """Calculate rolling Sharpe ratio"""
        daily_rf = PerformanceAnalytics.RISK_FREE_RATE / 252
        excess = returns - daily_rf

        rolling_mean = excess.rolling(window).mean()
        rolling_std = returns.rolling(window).std()

        return safe_divide(rolling_mean, rolling_std) * np.sqrt(252)

    @staticmethod
    def get_drawdown_series(returns: pd.Series) -> pd.Series:
        """Calculate drawdown series"""
        equity = (1 + returns).cumprod()
        running_max = equity.expanding().max()
        return (equity - running_max) / running_max

    @staticmethod
    def print_performance_report(metrics: Dict[str, float],
                                 title: str = "PERFORMANCE REPORT"):
        """
        Print formatted performance report

        Args:
            metrics: Dictionary from calculate_metrics()
            title: Report title
        """
        print("\n" + "="*80)
        print(title.center(80))
        print("="*80)

        # Section 1: Returns
        print("\nRETURN METRICS")
        print("-" * 80)
        print(f"Total Return:              {metrics.get('total_return', 0):>12.2%}")
        print(f"CAGR:                      {metrics.get('cagr', 0):>12.2%}")
        print(f"Excess Return (over RF):   {metrics.get('excess_return', 0):>12.2%}")
        print(f"Geometric Mean:            {metrics.get('geometric_mean', 0):>12.2%}")

        # Section 2: Risk-Adjusted Returns
        print("\nRISK-ADJUSTED RATIOS")
        print("-" * 80)
        print(f"Sharpe Ratio:              {metrics.get('sharpe', 0):>12.2f}")
        print(f"Sortino Ratio:             {metrics.get('sortino', 0):>12.2f}")
        print(f"Calmar Ratio:              {metrics.get('calmar', 0):>12.2f}")
        print(f"Omega Ratio:               {metrics.get('omega', 0):>12.2f}")
        print(f"Information Ratio:         {metrics.get('information_ratio', 0):>12.2f}")
        print(f"Gain-to-Pain Ratio:        {metrics.get('gain_to_pain', 0):>12.2f}")
        print(f"Sterling Ratio:            {metrics.get('sterling', 0):>12.2f}")

        # Section 3: Risk Metrics
        print("\nRISK METRICS")
        print("-" * 80)
        print(f"Volatility (Annual):       {metrics.get('volatility', 0):>12.2%}")
        print(f"Downside Volatility:       {metrics.get('downside_volatility', 0):>12.2%}")
        print(f"Max Drawdown:              {metrics.get('max_drawdown', 0):>12.2%}")
        print(f"Average Drawdown:          {metrics.get('avg_drawdown', 0):>12.2%}")
        print(f"Ulcer Index:               {metrics.get('ulcer_index', 0):>12.2f}")
        print(f"VaR (95%):                 {metrics.get('var_95', 0):>12.2%}")
        print(f"CVaR (95%):                {metrics.get('cvar_95', 0):>12.2%}")

        # Section 4: Trading Metrics
        print("\nTRADING METRICS")
        print("-" * 80)
        print(f"Win Rate:                  {metrics.get('win_rate', 0):>12.2%}")
        print(f"Profit Factor:             {metrics.get('profit_factor', 0):>12.2f}")
        print(f"Payoff Ratio:              {metrics.get('payoff_ratio', 0):>12.2f}")
        print(f"Expectancy:                {metrics.get('expectancy', 0):>12.4f}")
        print(f"Average Win:               {metrics.get('avg_win', 0):>12.2%}")
        print(f"Average Loss:              {metrics.get('avg_loss', 0):>12.2%}")

        # Section 5: Distribution
        print("\nDISTRIBUTION METRICS")
        print("-" * 80)
        print(f"Skewness:                  {metrics.get('skewness', 0):>12.2f}")
        print(f"Excess Kurtosis:           {metrics.get('excess_kurtosis', 0):>12.2f}")
        print(f"Tail Ratio:                {metrics.get('tail_ratio', 0):>12.2f}")

        # Section 6: Streaks
        print("\nCONSISTENCY METRICS")
        print("-" * 80)
        print(f"Max Winning Streak:        {metrics.get('max_winning_streak', 0):>12.0f} periods")
        print(f"Max Losing Streak:         {metrics.get('max_losing_streak', 0):>12.0f} periods")
        print(f"Max DD Duration:           {metrics.get('max_drawdown_duration', 0):>12.0f} periods")

        print("="*80 + "\n")

# ==================================================
# REGIME DETECTION
# ==================================================

# ==================================================
# COMPREHENSIVE MARKET REGIME DETECTOR
# ==================================================

class MarketRegimeDetector:
    """
    Advanced market regime detection system

    Detects:
    1. Volatility regimes (High/Low)
    2. Trend regimes (Trending/Mean-Reverting)
    3. Combined market states

    Uses multiple indicators for robust classification
    """

    def __init__(self, price: pd.Series, returns: pd.Series,
                 vol_lookback: int = 20,
                 trend_lookback: int = 50,
                 confirm_days: int = 3):
        """
        Args:
            price: Price series
            returns: Returns series
            vol_lookback: Period for volatility calculation
            trend_lookback: Period for trend detection
            confirm_days: Days to confirm regime change (reduces whipsaws)
        """
        self.price = price
        self.returns = returns
        self.vol_lookback = vol_lookback
        self.trend_lookback = trend_lookback
        self.confirm_days = confirm_days

        # Pre-calculate indicators
        self._calculate_indicators()

    def _calculate_indicators(self):
        """Pre-calculate all regime indicators"""
        # Volatility measures
        self.realized_vol = self.returns.rolling(self.vol_lookback).std() * np.sqrt(252)
        self.vol_percentile = self.realized_vol.rolling(252).rank(pct=True)

        # Trend measures
        self.sma_50 = self.price.rolling(50).mean()
        self.sma_200 = self.price.rolling(200).mean()
        self.price_to_ma = self.price / self.sma_50

        # ADX for trend strength
        self.adx = self._calculate_adx(self.price, period=14)

        # ATR for volatility
        self.atr = self._calculate_atr(self.price, period=14)

        # R-squared for trend quality
        self.r_squared = self._calculate_r_squared(self.price, period=self.trend_lookback)

    def _calculate_adx(self, price: pd.Series, period: int = 14) -> pd.Series:
        """Calculate Average Directional Index (ADX) - trend strength"""
        high = price.rolling(period).max()
        low = price.rolling(period).min()

        # Simplified ADX
        tr = high - low
        directional_movement = price.diff().abs()

        adx = (directional_movement.rolling(period).mean() /
               (tr.rolling(period).mean() + 1e-10) * 100)

        return adx.fillna(25)  # Neutral value

    def _calculate_atr(self, price: pd.Series, period: int = 14) -> pd.Series:
        """Calculate Average True Range (ATR)"""
        high = price.rolling(period).max()
        low = price.rolling(period).min()
        tr = high - low
        atr = tr.rolling(period).mean()
        return atr / price  # Normalized ATR

    def _calculate_r_squared(self, price: pd.Series, period: int = 50) -> pd.Series:
        """
        Calculate R-squared of linear regression
        Measures how well price follows a linear trend

        High R² = Strong trend
        Low R² = Mean-reverting/choppy
        """
        def rolling_r_squared(x):
            if len(x) < 10:
                return 0.5

            y = x.values
            n = len(y)
            x_vals = np.arange(n)

            # Linear regression
            x_mean = x_vals.mean()
            y_mean = y.mean()

            numerator = ((x_vals - x_mean) * (y - y_mean)).sum()
            denominator = np.sqrt(((x_vals - x_mean)**2).sum() * ((y - y_mean)**2).sum())

            if denominator == 0:
                return 0.5

            r = numerator / denominator
            return r ** 2

        r_squared = price.rolling(period).apply(rolling_r_squared, raw=False)
        return r_squared.fillna(0.5)

    def detect_volatility_regime(self) -> pd.Series:
        """
        Detect volatility regime: High or Low

        Uses:
        - Realized volatility percentile
        - ATR

        Returns:
            Series with 'High Vol' or 'Low Vol'
        """
        # Multiple volatility signals
        vol_high_percentile = self.vol_percentile > 0.7  # Top 30%
        vol_low_percentile = self.vol_percentile < 0.3   # Bottom 30%

        atr_high = self.atr > self.atr.rolling(100).median()

        # Classify
        regime = pd.Series('Medium Vol', index=self.price.index)
        regime[vol_high_percentile | atr_high] = 'High Vol'
        regime[vol_low_percentile & ~atr_high] = 'Low Vol'

        # Apply confirmation filter
        return self._apply_hysteresis(regime)

    def detect_trend_regime(self) -> pd.Series:
        """
        Detect trend regime: Trending or Mean-Reverting

        Uses:
        - ADX (trend strength)
        - R-squared (trend quality)
        - Moving average alignment

        Returns:
            Series with 'Trending' or 'Mean-Reverting'
        """
        # Multiple trend signals
        adx_trending = self.adx > 25  # Standard ADX threshold
        r_squared_high = self.r_squared > 0.6  # Strong linear relationship

        # MA alignment
        ma_aligned = (self.price > self.sma_50) & (self.sma_50 > self.sma_200)
        ma_diverging = ~ma_aligned & ~((self.price < self.sma_50) & (self.sma_50 < self.sma_200))

        # Price deviation from MA (mean reversion signal)
        price_deviation = abs(self.price / self.sma_50 - 1)
        extreme_deviation = price_deviation > 0.05  # 5% from MA

        # Classify
        regime = pd.Series('Choppy', index=self.price.index)

        # Trending: High ADX + High R² OR strong MA alignment
        trending = (adx_trending & r_squared_high) | (ma_aligned & (self.adx > 20))
        regime[trending] = 'Trending'

        # Mean-reverting: Low ADX + Low R² + extreme deviations
        mean_reverting = (~adx_trending & (self.r_squared < 0.4)) | extreme_deviation
        regime[mean_reverting] = 'Mean-Reverting'

        # Apply confirmation filter
        return self._apply_hysteresis(regime)

    def detect_combined_regime(self) -> pd.Series:
        """
        Detect combined market regime

        Combines volatility and trend regimes into market states:
        - Low Vol + Trending = 'Steady Trend'
        - Low Vol + Mean-Reverting = 'Quiet Range'
        - High Vol + Trending = 'Volatile Trend'
        - High Vol + Mean-Reverting = 'Choppy Market'

        Returns:
            Series with combined regime labels
        """
        vol_regime = self.detect_volatility_regime()
        trend_regime = self.detect_trend_regime()

        # Combine regimes
        combined = pd.Series('Unknown', index=self.price.index)

        for i in range(len(combined)):
            vol = vol_regime.iloc[i]
            trend = trend_regime.iloc[i]

            if vol == 'Low Vol':
                if trend == 'Trending':
                    combined.iloc[i] = 'Steady Trend'
                elif trend == 'Mean-Reverting':
                    combined.iloc[i] = 'Quiet Range'
                else:
                    combined.iloc[i] = 'Low Vol Choppy'

            elif vol == 'High Vol':
                if trend == 'Trending':
                    combined.iloc[i] = 'Volatile Trend'
                elif trend == 'Mean-Reverting':
                    combined.iloc[i] = 'Choppy Market'
                else:
                    combined.iloc[i] = 'High Vol Choppy'

            else:  # Medium Vol
                if trend == 'Trending':
                    combined.iloc[i] = 'Normal Trend'
                elif trend == 'Mean-Reverting':
                    combined.iloc[i] = 'Normal Range'
                else:
                    combined.iloc[i] = 'Neutral'

        return combined

    def _apply_hysteresis(self, raw_regime: pd.Series) -> pd.Series:
        """
        Apply hysteresis filter to reduce regime switching noise

        Requires regime to persist for confirm_days before switching
        """
        regime = raw_regime.copy()
        current = regime.iloc[0]
        count = 0

        for i in range(1, len(regime)):
            if raw_regime.iloc[i] == current:
                count = 0
            else:
                count += 1
                if count >= self.confirm_days:
                    current = raw_regime.iloc[i]
                    count = 0
            regime.iloc[i] = current

        return regime

    def get_regime_statistics(self) -> pd.DataFrame:
        """
        Get statistics about regime distribution

        Returns:
            DataFrame with regime counts, durations, and percentages
        """
        vol_regime = self.detect_volatility_regime()
        trend_regime = self.detect_trend_regime()
        combined_regime = self.detect_combined_regime()

        stats = pd.DataFrame({
            'Volatility Regime': vol_regime.value_counts(),
            'Trend Regime': trend_regime.value_counts(),
            'Combined Regime': combined_regime.value_counts()
        }).fillna(0)

        # Add percentages
        for col in stats.columns:
            stats[f'{col} %'] = stats[col] / len(vol_regime) * 100

        return stats

    def get_current_regime(self) -> Dict[str, str]:
        """Get the most recent regime classification"""
        vol_regime = self.detect_volatility_regime()
        trend_regime = self.detect_trend_regime()
        combined_regime = self.detect_combined_regime()

        return {
            'volatility': vol_regime.iloc[-1],
            'trend': trend_regime.iloc[-1],
            'combined': combined_regime.iloc[-1],
            'adx': self.adx.iloc[-1],
            'realized_vol': self.realized_vol.iloc[-1] * 100,
            'r_squared': self.r_squared.iloc[-1]
        }

    def plot_regime_analysis(self):
        """Plot comprehensive regime analysis"""
        import matplotlib.pyplot as plt

        vol_regime = self.detect_volatility_regime()
        trend_regime = self.detect_trend_regime()
        combined_regime = self.detect_combined_regime()

        fig, axes = plt.subplots(5, 1, figsize=(14, 12), sharex=True)

        # 1. Price with regimes
        axes[0].plot(self.price.index, self.price.values, linewidth=1, color='black')
        axes[0].plot(self.sma_50.index, self.sma_50.values, linewidth=1,
                    alpha=0.7, label='SMA 50', color='blue')
        axes[0].plot(self.sma_200.index, self.sma_200.values, linewidth=1,
                    alpha=0.7, label='SMA 200', color='red')
        axes[0].set_ylabel('Price')
        axes[0].set_title('Market Regime Analysis', fontweight='bold', fontsize=14)
        axes[0].legend()
        axes[0].grid(True, alpha=0.3)

        # 2. Volatility regime
        vol_colors = {'High Vol': 'red', 'Medium Vol': 'orange', 'Low Vol': 'green'}
        for regime_type in vol_colors:
            mask = vol_regime == regime_type
            if mask.any():
                axes[1].fill_between(self.price.index, 0, 1, where=mask,
                                    alpha=0.3, label=regime_type, color=vol_colors[regime_type])

        axes[1].plot(self.realized_vol.index, self.realized_vol.values * 100,
                    linewidth=1, color='black', label='Realized Vol %')
        axes[1].set_ylabel('Volatility (%)')
        axes[1].set_title('Volatility Regime', fontweight='bold')
        axes[1].legend(loc='upper left')
        axes[1].grid(True, alpha=0.3)

        # 3. Trend regime
        trend_colors = {'Trending': 'green', 'Mean-Reverting': 'red', 'Choppy': 'orange'}
        for regime_type in trend_colors:
            mask = trend_regime == regime_type
            if mask.any():
                axes[2].fill_between(self.price.index, 0, 1, where=mask,
                                    alpha=0.3, label=regime_type, color=trend_colors[regime_type])

        axes[2].plot(self.adx.index, self.adx.values, linewidth=1,
                    color='black', label='ADX')
        axes[2].axhline(y=25, color='gray', linestyle='--', alpha=0.5)
        axes[2].set_ylabel('ADX')
        axes[2].set_title('Trend Regime', fontweight='bold')
        axes[2].legend(loc='upper left')
        axes[2].grid(True, alpha=0.3)

        # 4. R-squared (trend quality)
        axes[3].plot(self.r_squared.index, self.r_squared.values,
                    linewidth=1, color='purple', label='R²')
        axes[3].axhline(y=0.6, color='green', linestyle='--', alpha=0.5, label='Strong Trend')
        axes[3].axhline(y=0.4, color='red', linestyle='--', alpha=0.5, label='Weak Trend')
        axes[3].set_ylabel('R²')
        axes[3].set_title('Trend Quality (R-squared)', fontweight='bold')
        axes[3].set_ylim([0, 1])
        axes[3].legend()
        axes[3].grid(True, alpha=0.3)

        # 5. Combined regime timeline
        # Create numeric encoding for visualization
        regime_map = {
            'Steady Trend': 5, 'Normal Trend': 4, 'Volatile Trend': 3,
            'Quiet Range': 2, 'Normal Range': 1, 'Choppy Market': 0,
            'Low Vol Choppy': 1.5, 'High Vol Choppy': 0.5, 'Neutral': 2.5
        }

        regime_numeric = combined_regime.map(regime_map)

        # Use step plot for clear regime boundaries
        axes[4].step(regime_numeric.index, regime_numeric.values,
                    where='post', linewidth=2, color='darkblue')
        axes[4].set_ylabel('Regime')
        axes[4].set_xlabel('Date')
        axes[4].set_title('Combined Market Regime', fontweight='bold')
        axes[4].set_yticks([0, 1, 2, 3, 4, 5])
        axes[4].set_yticklabels(['Choppy', 'Range', 'Quiet', 'Vol Trend', 'Normal', 'Steady'])
        axes[4].grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

# Backward compatibility - simple wrapper
class RegimeDetector:
    """Legacy simple regime detector (for backward compatibility)"""

    def __init__(self, price: pd.Series, returns: pd.Series,
                 vol_lookback: int = 20, vol_threshold: float = 0.20,
                 confirm_days: int = 5):
        self.detector = MarketRegimeDetector(price, returns, vol_lookback, 50, confirm_days)

    def detect_regime(self) -> pd.Series:
        """Simple 3-regime classification for compatibility"""
        combined = self.detector.detect_combined_regime()

        # Map to legacy regimes
        regime_map = {
            'Steady Trend': 'Trend',
            'Normal Trend': 'Trend',
            'Volatile Trend': 'Choppy',
            'Quiet Range': 'Risk-Off',
            'Normal Range': 'Risk-Off',
            'Choppy Market': 'Choppy',
            'Low Vol Choppy': 'Risk-Off',
            'High Vol Choppy': 'Choppy',
            'Neutral': 'Choppy'
        }

        return combined.map(regime_map)

# ==================================================
# STRATEGY IMPLEMENTATIONS
# ==================================================

# ==================================================
# PROPER BACKTESTING ENGINE
# ==================================================

class Position:
    """Represents a trading position with trailing stop support"""

    def __init__(self, ticker: str, quantity: float, entry_price: float,
                 entry_date: datetime, position_type: str = 'LONG'):
        self.ticker = ticker
        self.quantity = quantity
        self.entry_price = entry_price
        self.entry_date = entry_date
        self.position_type = position_type
        self.exit_price = None
        self.exit_date = None
        self.realized_pnl = 0.0

        # Trailing stop tracking
        self.highest_price = entry_price if position_type == 'LONG' else entry_price
        self.lowest_price = entry_price if position_type == 'SHORT' else entry_price
        self.trailing_stop_pct = None  # Set by risk manager if enabled

    def update_trailing_stop(self, current_price: float):
        """Update trailing stop levels"""
        if self.position_type == 'LONG':
            if current_price > self.highest_price:
                self.highest_price = current_price
        else:  # SHORT
            if current_price < self.lowest_price:
                self.lowest_price = current_price

    def check_trailing_stop(self, current_price: float) -> bool:
        """Check if trailing stop is hit"""
        if self.trailing_stop_pct is None:
            return False

        if self.position_type == 'LONG':
            # Long position: check if price dropped from highest
            drop_from_high = (self.highest_price - current_price) / self.highest_price
            return drop_from_high >= self.trailing_stop_pct
        else:  # SHORT
            # Short position: check if price rose from lowest
            rise_from_low = (current_price - self.lowest_price) / self.lowest_price
            return rise_from_low >= self.trailing_stop_pct

    def close_position(self, exit_price: float, exit_date: datetime) -> float:
        """Close the position and calculate P&L"""
        self.exit_price = exit_price
        self.exit_date = exit_date

        if self.position_type == 'LONG':
            self.realized_pnl = (exit_price - self.entry_price) * self.quantity
        else:  # SHORT
            self.realized_pnl = (self.entry_price - exit_price) * self.quantity

        return self.realized_pnl

    def unrealized_pnl(self, current_price: float) -> float:
        """Calculate unrealized P&L"""
        if self.position_type == 'LONG':
            return (current_price - self.entry_price) * self.quantity
        else:
            return (self.entry_price - current_price) * self.quantity

    def market_value(self, current_price: float) -> float:
        """Calculate current market value"""
        return current_price * abs(self.quantity)

class RiskManager:
    """Comprehensive risk management module"""

    def __init__(self, max_position_size: float = 0.25, max_portfolio_leverage: float = 1.0,
                 max_drawdown_limit: float = 0.20, stop_loss_pct: float = 0.05,
                 enable_trailing_stop: bool = True, trailing_stop_pct: float = 0.10):
        self.max_position_size = max_position_size
        self.max_portfolio_leverage = max_portfolio_leverage
        self.max_drawdown_limit = max_drawdown_limit
        self.stop_loss_pct = stop_loss_pct
        self.enable_trailing_stop = enable_trailing_stop
        self.trailing_stop_pct = trailing_stop_pct

        # Drawdown tracking
        self.drawdown_actions_taken = []

    def calculate_position_size(self, portfolio_value: float, volatility: float,
                               risk_per_trade: float = 0.02, method: str = 'volatility_target',
                               num_positions: int = 1) -> float:
        """
        Calculate position size using various methods

        Args:
            portfolio_value: Current portfolio value
            volatility: Asset volatility (annualized)
            risk_per_trade: Risk as fraction of portfolio (e.g., 0.02 = 2%)
            method: 'fixed_risk', 'volatility_target', 'kelly', 'equal_weight', or 'vol_scaled'
            num_positions: Number of positions in portfolio (for equal_weight)

        Returns:
            Position size as fraction of portfolio
        """
        if method == 'fixed_risk':
            # Risk fixed percentage of portfolio
            if volatility > 0:
                position_size = risk_per_trade / volatility
            else:
                position_size = risk_per_trade

        elif method == 'volatility_target' or method == 'vol_target':
            # Target specific volatility
            target_vol = 0.10  # 10% target
            if volatility > 0:
                position_size = target_vol / volatility
            else:
                position_size = 0.1

        elif method == 'vol_scaled' or method == 'volatility_scaled':
            # Inverse volatility weighting for multi-asset
            # Higher allocation to lower volatility assets
            if volatility > 0:
                base_allocation = 1.0 / num_positions
                vol_scalar = 0.15 / volatility  # 15% reference volatility
                position_size = base_allocation * vol_scalar
            else:
                position_size = 1.0 / num_positions

        elif method == 'kelly':
            # Simplified Kelly Criterion
            # Assumes 55% win rate and 1.5 win/loss ratio
            win_rate = 0.55
            win_loss_ratio = 1.5
            kelly = (win_rate * win_loss_ratio - (1 - win_rate)) / win_loss_ratio
            position_size = kelly * 0.5  # Use half-Kelly for safety

        elif method == 'equal_weight':
            # Equal weight across N positions
            position_size = 1.0 / max(num_positions, 1)

        else:
            position_size = 0.1  # Default 10%

        # Apply maximum position size constraint
        position_size = min(position_size, self.max_position_size)

        # Apply minimum
        return max(position_size, 0.01)  # Minimum 1%

    def check_stop_loss(self, position: Position, current_price: float) -> bool:
        """Check if position hits stop loss"""
        if position.position_type == 'LONG':
            loss_pct = (current_price - position.entry_price) / position.entry_price
            return loss_pct <= -self.stop_loss_pct
        else:  # SHORT
            loss_pct = (position.entry_price - current_price) / position.entry_price
            return loss_pct <= -self.stop_loss_pct

    def check_trailing_stop(self, position: Position, current_price: float) -> bool:
        """Check if trailing stop is hit"""
        if not self.enable_trailing_stop:
            return False

        # Update position's highest/lowest price
        position.update_trailing_stop(current_price)

        # Set trailing stop percentage if not set
        if position.trailing_stop_pct is None:
            position.trailing_stop_pct = self.trailing_stop_pct

        # Check if trailing stop triggered
        return position.check_trailing_stop(current_price)

    def check_portfolio_risk(self, portfolio_value: float, equity_peak: float) -> bool:
        """Check if portfolio exceeds maximum drawdown"""
        if equity_peak > 0:
            current_dd = (portfolio_value - equity_peak) / equity_peak
            return current_dd <= -self.max_drawdown_limit
        return False

    def get_drawdown_action(self, current_dd: float) -> str:
        """
        Determine action based on drawdown severity

        Returns:
            Action: 'NORMAL', 'REDUCE', 'HALT', or 'LIQUIDATE'
        """
        abs_dd = abs(current_dd)

        if abs_dd < 0.05:  # Less than 5%
            return 'NORMAL'
        elif abs_dd < 0.10:  # 5-10%
            return 'REDUCE'  # Reduce position sizes by 50%
        elif abs_dd < self.max_drawdown_limit:  # 10-20%
            return 'HALT'  # Stop opening new positions
        else:  # Over 20%
            return 'LIQUIDATE'  # Close all positions

    def calculate_var(self, returns: pd.Series, confidence: float = 0.95) -> float:
        """Calculate Value at Risk"""
        if len(returns) == 0:
            return 0.0
        return returns.quantile(1 - confidence)

    def calculate_cvar(self, returns: pd.Series, confidence: float = 0.95) -> float:
        """Calculate Conditional Value at Risk (Expected Shortfall)"""
        if len(returns) == 0:
            return 0.0
        var = self.calculate_var(returns, confidence)
        return returns[returns <= var].mean() if (returns <= var).any() else var

class TransactionCostModel:
    """Model transaction costs and market impact"""

    def __init__(self, commission: float = 0.001, spread_pct: float = 0.0005,
                 market_impact_coef: float = 0.1):
        self.commission = commission  # 10 bps
        self.spread_pct = spread_pct  # 5 bps
        self.market_impact_coef = market_impact_coef

    def calculate_total_cost(self, trade_value: float, volatility: float,
                            avg_volume: float = 1000000, is_buy: bool = True) -> float:
        """
        Calculate total transaction cost

        Components:
        1. Commission (fixed)
        2. Bid-ask spread
        3. Market impact (depends on trade size)
        4. Slippage (volatility-dependent)
        """
        # 1. Commission
        commission_cost = trade_value * self.commission

        # 2. Spread cost
        spread_cost = trade_value * self.spread_pct

        # 3. Market impact (square-root model)
        if avg_volume > 0:
            participation_rate = trade_value / avg_volume
            market_impact = trade_value * self.market_impact_coef * np.sqrt(participation_rate)
        else:
            market_impact = 0

        # 4. Slippage (increases with volatility)
        base_slippage = 0.0005  # 5 bps base
        vol_multiplier = 1 + (volatility / 0.20)  # Scale with volatility
        slippage_cost = trade_value * base_slippage * vol_multiplier

        total_cost = commission_cost + spread_cost + market_impact + slippage_cost

        return total_cost

    def get_execution_price(self, market_price: float, trade_value: float,
                           volatility: float, is_buy: bool = True) -> float:
        """Get realistic execution price accounting for slippage"""
        cost_pct = self.calculate_total_cost(trade_value, volatility) / trade_value

        if is_buy:
            execution_price = market_price * (1 + cost_pct)
        else:
            execution_price = market_price * (1 - cost_pct)

        return execution_price

class Portfolio:
    """Portfolio management class for backtesting"""

    def __init__(self, initial_capital: float = 100000,
                 risk_manager: Optional[RiskManager] = None,
                 cost_model: Optional[TransactionCostModel] = None):
        self.initial_capital = initial_capital
        self.cash = initial_capital
        self.positions = {}  # ticker -> Position
        self.closed_positions = []
        self.equity_curve = []
        self.equity_peak = initial_capital

        self.risk_manager = risk_manager or RiskManager()
        self.cost_model = cost_model or TransactionCostModel()

        # Performance tracking
        self.total_trades = 0
        self.winning_trades = 0
        self.losing_trades = 0
        self.total_pnl = 0.0
        self.total_costs = 0.0

    def update(self, date: datetime, prices: Dict[str, float],
               volatilities: Dict[str, float] = None):
        """Update portfolio value and check stops"""
        if volatilities is None:
            volatilities = {ticker: 0.20 for ticker in prices.keys()}

        # Check stop losses and trailing stops
        positions_to_close = []
        for ticker, position in self.positions.items():
            if ticker in prices:
                current_price = prices[ticker]

                # Check fixed stop loss
                if self.risk_manager.check_stop_loss(position, current_price):
                    positions_to_close.append((ticker, current_price, date, 'STOP_LOSS'))
                # Check trailing stop
                elif self.risk_manager.check_trailing_stop(position, current_price):
                    positions_to_close.append((ticker, current_price, date, 'TRAILING_STOP'))

        # Close positions that hit stops
        for ticker, price, close_date, reason in positions_to_close:
            self.close_position(ticker, price, close_date, reason=reason)

        # Update equity curve
        portfolio_value = self.get_portfolio_value(prices)
        self.equity_curve.append({
            'date': date,
            'value': portfolio_value,
            'cash': self.cash,
            'positions_value': portfolio_value - self.cash
        })

        # Update equity peak
        if portfolio_value > self.equity_peak:
            self.equity_peak = portfolio_value

        # Check maximum drawdown and take action
        current_dd = (portfolio_value - self.equity_peak) / self.equity_peak if self.equity_peak > 0 else 0
        action = self.risk_manager.get_drawdown_action(current_dd)

        if action == 'LIQUIDATE':
            print(f"WARNING: Maximum drawdown {current_dd:.2%} exceeded on {date}")
            print("LIQUIDATING ALL POSITIONS")
            # Close all positions
            for ticker in list(self.positions.keys()):
                if ticker in prices:
                    self.close_position(ticker, prices[ticker], date, reason='MAX_DRAWDOWN')
        elif action == 'HALT':
            print(f"WARNING: Drawdown {current_dd:.2%} - HALTING new positions on {date}")
        elif action == 'REDUCE':
            print(f"WARNING: Drawdown {current_dd:.2%} - REDUCING position sizes on {date}")

    def open_position(self, ticker: str, signal: float, price: float,
                     date: datetime, volatility: float = 0.20,
                     position_sizing_method: str = 'volatility_target'):
        """Open a new position"""
        portfolio_value = self.get_portfolio_value({ticker: price})

        # Calculate position size
        position_size_pct = self.risk_manager.calculate_position_size(
            portfolio_value, volatility, method=position_sizing_method
        )

        # Calculate dollar amount
        position_value = portfolio_value * position_size_pct

        # Don't exceed available cash
        position_value = min(position_value, self.cash * 0.95)  # Keep 5% cash buffer

        if position_value < 100:  # Minimum position size
            return

        # Calculate execution price with costs
        execution_price = self.cost_model.get_execution_price(
            price, position_value, volatility, is_buy=(signal > 0)
        )

        # Calculate transaction costs
        costs = self.cost_model.calculate_total_cost(position_value, volatility)
        self.total_costs += costs

        # Calculate quantity
        quantity = position_value / execution_price

        # Determine position type
        position_type = 'LONG' if signal > 0 else 'SHORT'

        # Create position
        position = Position(ticker, quantity, execution_price, date, position_type)

        # Update cash
        self.cash -= (position_value + costs)

        # Store position
        self.positions[ticker] = position
        self.total_trades += 1

    def close_position(self, ticker: str, price: float, date: datetime,
                      reason: str = 'SIGNAL'):
        """Close an existing position"""
        if ticker not in self.positions:
            return

        position = self.positions[ticker]

        # Calculate position value
        position_value = position.market_value(price)

        # Calculate volatility (simplified)
        volatility = 0.20

        # Get execution price
        execution_price = self.cost_model.get_execution_price(
            price, position_value, volatility, is_buy=False
        )

        # Calculate costs
        costs = self.cost_model.calculate_total_cost(position_value, volatility)
        self.total_costs += costs

        # Close position
        pnl = position.close_position(execution_price, date)

        # Update cash
        proceeds = position_value - costs
        self.cash += proceeds

        # Track performance
        self.total_pnl += pnl
        if pnl > 0:
            self.winning_trades += 1
        else:
            self.losing_trades += 1

        # Move to closed positions
        self.closed_positions.append(position)
        del self.positions[ticker]

    def get_portfolio_value(self, prices: Dict[str, float]) -> float:
        """Calculate total portfolio value"""
        positions_value = sum(
            pos.market_value(prices.get(ticker, pos.entry_price))
            for ticker, pos in self.positions.items()
        )
        return self.cash + positions_value

    def get_returns(self) -> pd.Series:
        """Get portfolio returns series"""
        if not self.equity_curve:
            return pd.Series()

        df = pd.DataFrame(self.equity_curve)
        df.set_index('date', inplace=True)
        returns = df['value'].pct_change().dropna()
        return returns

    def get_performance_summary(self) -> Dict:
        """Get comprehensive performance summary"""
        returns = self.get_returns()

        if len(returns) == 0:
            return {}

        final_value = self.equity_curve[-1]['value']
        total_return = (final_value - self.initial_capital) / self.initial_capital

        # Calculate metrics using PerformanceAnalytics
        analytics = PerformanceAnalytics()
        metrics = analytics.calculate_metrics(returns)

        # Add portfolio-specific metrics
        metrics['initial_capital'] = self.initial_capital
        metrics['final_value'] = final_value
        metrics['total_pnl'] = self.total_pnl
        metrics['total_costs'] = self.total_costs
        metrics['net_pnl'] = self.total_pnl - self.total_costs
        metrics['total_trades'] = self.total_trades
        metrics['winning_trades'] = self.winning_trades
        metrics['losing_trades'] = self.losing_trades
        metrics['win_rate'] = self.winning_trades / self.total_trades if self.total_trades > 0 else 0

        return metrics

# ==================================================
# MULTI-ASSET PORTFOLIO MANAGER
# ==================================================

class MultiAssetPortfolioManager:
    """
    Comprehensive multi-asset portfolio management

    Features:
    - Equal weight vs volatility scaling
    - Dynamic rebalancing
    - Risk parity option
    - Drawdown-based position adjustment
    - Trailing stops on all positions
    """

    def __init__(self, tickers: List[str], initial_capital: float = 100000,
                 weighting_method: str = 'vol_scaled',
                 rebalance_frequency: str = 'monthly',
                 enable_trailing_stops: bool = True,
                 max_drawdown: float = 0.20):
        """
        Initialize multi-asset portfolio manager

        Args:
            tickers: List of ticker symbols
            initial_capital: Starting capital
            weighting_method: 'equal_weight', 'vol_scaled', 'risk_parity', or 'market_cap'
            rebalance_frequency: 'daily', 'weekly', 'monthly', 'quarterly'
            enable_trailing_stops: Enable trailing stops on positions
            max_drawdown: Maximum acceptable drawdown
        """
        self.tickers = tickers
        self.initial_capital = initial_capital
        self.weighting_method = weighting_method
        self.rebalance_frequency = rebalance_frequency

        # Create risk manager with trailing stops
        self.risk_manager = RiskManager(
            max_position_size=1.0 / len(tickers) * 2,  # Max 2x equal weight
            max_drawdown_limit=max_drawdown,
            enable_trailing_stop=enable_trailing_stops,
            trailing_stop_pct=0.10  # 10% trailing stop
        )

        # Create portfolio
        self.portfolio = Portfolio(
            initial_capital=initial_capital,
            risk_manager=self.risk_manager
        )

        # Track weights and rebalance dates
        self.current_weights = {}
        self.target_weights = {}
        self.last_rebalance = None
        self.rebalance_history = []

    def calculate_target_weights(self, prices: pd.DataFrame,
                                 returns: pd.DataFrame) -> Dict[str, float]:
        """
        Calculate target weights based on selected method

        Args:
            prices: DataFrame of prices
            returns: DataFrame of returns

        Returns:
            Dictionary of {ticker: weight}
        """
        n_assets = len(self.tickers)
        weights = {}

        if self.weighting_method == 'equal_weight':
            # Equal weight: 1/N for each asset
            for ticker in self.tickers:
                weights[ticker] = 1.0 / n_assets

        elif self.weighting_method == 'vol_scaled' or self.weighting_method == 'volatility_scaled':
            # Inverse volatility weighting
            # Calculate volatilities
            vols = {}
            for ticker in self.tickers:
                if ticker in returns.columns:
                    vol = returns[ticker].std() * np.sqrt(252)
                    vols[ticker] = max(vol, 0.01)  # Minimum vol
                else:
                    vols[ticker] = 0.20  # Default

            # Inverse volatility weights
            inv_vols = {t: 1.0/v for t, v in vols.items()}
            total_inv_vol = sum(inv_vols.values())

            for ticker in self.tickers:
                weights[ticker] = inv_vols[ticker] / total_inv_vol

        elif self.weighting_method == 'risk_parity':
            # Risk parity: equal risk contribution
            # Simplified version - equal weight adjusted by inverse volatility
            vols = {}
            for ticker in self.tickers:
                if ticker in returns.columns:
                    vol = returns[ticker].std() * np.sqrt(252)
                    vols[ticker] = max(vol, 0.01)
                else:
                    vols[ticker] = 0.20

            # Risk parity weights
            inv_vols = {t: 1.0/v for t, v in vols.items()}
            total_inv_vol = sum(inv_vols.values())

            for ticker in self.tickers:
                weights[ticker] = inv_vols[ticker] / total_inv_vol

        elif self.weighting_method == 'momentum':
            # Momentum-based weighting
            # Calculate 6-month returns
            lookback = min(126, len(returns))
            mom_scores = {}

            for ticker in self.tickers:
                if ticker in returns.columns and len(returns[ticker]) >= lookback:
                    # Total return over lookback period
                    mom = (1 + returns[ticker].tail(lookback)).prod() - 1
                    mom_scores[ticker] = max(mom, 0)  # Only positive momentum
                else:
                    mom_scores[ticker] = 0

            total_mom = sum(mom_scores.values())
            if total_mom > 0:
                for ticker in self.tickers:
                    weights[ticker] = mom_scores[ticker] / total_mom
            else:
                # Fallback to equal weight
                for ticker in self.tickers:
                    weights[ticker] = 1.0 / n_assets
        else:
            # Default to equal weight
            for ticker in self.tickers:
                weights[ticker] = 1.0 / n_assets

        # Ensure weights sum to 1
        total_weight = sum(weights.values())
        if total_weight > 0:
            weights = {t: w/total_weight for t, w in weights.items()}

        return weights

    def should_rebalance(self, current_date: datetime) -> bool:
        """Check if it's time to rebalance"""
        if self.last_rebalance is None:
            return True

        days_since = (current_date - self.last_rebalance).days

        if self.rebalance_frequency == 'daily':
            return days_since >= 1
        elif self.rebalance_frequency == 'weekly':
            return days_since >= 7
        elif self.rebalance_frequency == 'monthly':
            return days_since >= 30
        elif self.rebalance_frequency == 'quarterly':
            return days_since >= 90

        return False

    def rebalance_portfolio(self, date: datetime, prices: Dict[str, float],
                           returns: pd.DataFrame):
        """
        Rebalance portfolio to target weights

        Args:
            date: Current date
            prices: Current prices dictionary
            returns: Historical returns for weight calculation
        """
        # Calculate target weights
        prices_df = pd.DataFrame({t: [prices.get(t, np.nan)] for t in self.tickers})
        self.target_weights = self.calculate_target_weights(prices_df, returns)

        # Get current portfolio value
        portfolio_value = self.portfolio.get_portfolio_value(prices)

        # Calculate target dollar amounts
        target_values = {
            ticker: portfolio_value * weight
            for ticker, weight in self.target_weights.items()
        }

        # Close positions that should be reduced or eliminated
        for ticker, position in list(self.portfolio.positions.items()):
            current_value = position.market_value(prices[ticker])
            target_value = target_values.get(ticker, 0)

            if target_value < current_value * 0.9:  # Reduce if >10% off target
                # Close position (will re-open with correct size)
                self.portfolio.close_position(ticker, prices[ticker], date, reason='REBALANCE')

        # Open/adjust positions to target weights
        for ticker, target_weight in self.target_weights.items():
            if ticker not in prices or target_weight < 0.01:  # Skip tiny weights
                continue

            target_value = portfolio_value * target_weight

            if ticker not in self.portfolio.positions:
                # Open new position
                signal = 1  # Long only for now
                vol = returns[ticker].std() * np.sqrt(252) if ticker in returns.columns else 0.20

                # Override position sizing to use exact target weight
                self.portfolio.open_position(
                    ticker, signal, prices[ticker], date, vol,
                    position_sizing_method='equal_weight'  # Will be overridden
                )

                # Adjust the position to exact target weight
                if ticker in self.portfolio.positions:
                    pos = self.portfolio.positions[ticker]
                    current_val = pos.market_value(prices[ticker])
                    if abs(current_val - target_value) / portfolio_value > 0.01:
                        # Re-size if off by >1%
                        self.portfolio.close_position(ticker, prices[ticker], date, 'REBALANCE')
                        # Re-open with correct size (simplified - actual implementation would adjust quantity)

        self.last_rebalance = date
        self.rebalance_history.append({
            'date': date,
            'weights': self.target_weights.copy(),
            'portfolio_value': portfolio_value
        })

    def run_backtest(self, start_date: str, end_date: Optional[str] = None) -> Dict:
        """
        Run multi-asset backtest with rebalancing

        Returns:
            Dictionary with performance results
        """
        print(f"\nRunning multi-asset backtest: {', '.join(self.tickers)}")
        print(f"Weighting: {self.weighting_method}")
        print(f"Rebalance: {self.rebalance_frequency}")
        print(f"Trailing stops: {'Enabled' if self.risk_manager.enable_trailing_stop else 'Disabled'}")

        # Fetch data for all tickers
        prices, returns = DataManager.fetch_data(self.tickers, start_date, end_date)

        # Run backtest day by day
        for date in prices.index:
            # Get current prices
            current_prices = {
                ticker: prices.loc[date, ticker] if ticker in prices.columns else np.nan
                for ticker in self.tickers
            }

            # Remove NaN prices
            current_prices = {t: p for t, p in current_prices.items() if not np.isnan(p)}

            if not current_prices:
                continue

            # Update portfolio (checks stops)
            self.portfolio.update(date, current_prices)

            # Check if should rebalance
            if self.should_rebalance(date):
                # Get historical returns up to this point
                hist_returns = returns.loc[:date]
                if len(hist_returns) >= 20:  # Need minimum history
                    self.rebalance_portfolio(date, current_prices, hist_returns)

        # Get performance
        performance = self.portfolio.get_performance_summary()

        # Add multi-asset specific metrics
        performance['weighting_method'] = self.weighting_method
        performance['num_rebalances'] = len(self.rebalance_history)
        performance['tickers'] = self.tickers

        return performance

    def print_performance_summary(self, performance: Dict):
        """Print formatted performance summary"""
        print("\n" + "="*80)
        print("MULTI-ASSET PORTFOLIO PERFORMANCE")
        print("="*80)
        print(f"Tickers:             {', '.join(self.tickers)}")
        print(f"Weighting Method:    {performance['weighting_method']}")
        print(f"Rebalances:          {performance['num_rebalances']}")
        print(f"\nInitial Capital:     ${performance.get('initial_capital', 0):>12,.0f}")
        print(f"Final Value:         ${performance.get('final_value', 0):>12,.0f}")
        print(f"Total Return:        {performance.get('total_return', 0):>12.2%}")
        print(f"CAGR:                {performance.get('cagr', 0):>12.2%}")
        print(f"\nSharpe Ratio:        {performance.get('sharpe', 0):>12.2f}")
        print(f"Sortino Ratio:       {performance.get('sortino', 0):>12.2f}")
        print(f"Max Drawdown:        {performance.get('max_drawdown', 0):>12.2%}")
        print(f"Calmar Ratio:        {performance.get('calmar', 0):>12.2f}")
        print(f"\nTotal Trades:        {performance.get('total_trades', 0):>12.0f}")
        print(f"Win Rate:            {performance.get('win_rate', 0):>12.2%}")
        print("="*80)

# ==================================================
# BACKTEST ENGINE
# ==================================================

class BacktestEngine:
    """Complete backtesting engine orchestrating all components"""

    def __init__(self, initial_capital: float = 100000,
                 risk_manager: Optional[RiskManager] = None,
                 cost_model: Optional[TransactionCostModel] = None):

        self.portfolio = Portfolio(initial_capital, risk_manager, cost_model)
        self.risk_manager = risk_manager or RiskManager()
        self.cost_model = cost_model or TransactionCostModel()

    def run_backtest(self, prices: pd.DataFrame, signals: pd.DataFrame,
                     volatilities: Optional[pd.DataFrame] = None) -> Portfolio:
        """
        Run complete backtest

        Args:
            prices: DataFrame of prices (index=dates, columns=tickers)
            signals: DataFrame of signals (1=long, 0=flat, -1=short)
            volatilities: Optional DataFrame of volatilities

        Returns:
            Portfolio object with complete results
        """
        if volatilities is None:
            # Calculate rolling volatility
            returns = prices.pct_change()
            volatilities = returns.rolling(20).std() * np.sqrt(252)

        # Iterate through time
        for date in prices.index:
            if date not in signals.index:
                continue

            current_prices = prices.loc[date].to_dict()
            current_signals = signals.loc[date]
            current_vols = volatilities.loc[date].to_dict() if date in volatilities.index else {}

            # Update portfolio
            self.portfolio.update(date, current_prices, current_vols)

            # Process signals for each ticker
            for ticker in signals.columns:
                signal = current_signals[ticker]
                price = current_prices.get(ticker)
                vol = current_vols.get(ticker, 0.20)

                if price is None or pd.isna(price):
                    continue

                # Check if we have a position
                has_position = ticker in self.portfolio.positions

                # Entry signal
                if signal != 0 and not has_position:
                    self.portfolio.open_position(ticker, signal, price, date, vol)

                # Exit signal
                elif signal == 0 and has_position:
                    self.portfolio.close_position(ticker, price, date, reason='SIGNAL')

                # Reverse signal (close and open opposite)
                elif has_position:
                    current_pos = self.portfolio.positions[ticker]
                    if (signal > 0 and current_pos.position_type == 'SHORT') or \
                       (signal < 0 and current_pos.position_type == 'LONG'):
                        self.portfolio.close_position(ticker, price, date, reason='REVERSE')
                        self.portfolio.open_position(ticker, signal, price, date, vol)

        # Close all remaining positions at end
        final_date = prices.index[-1]
        final_prices = prices.iloc[-1].to_dict()

        for ticker in list(self.portfolio.positions.keys()):
            if ticker in final_prices:
                self.portfolio.close_position(ticker, final_prices[ticker],
                                             final_date, reason='END')

        return self.portfolio

# ==================================================
# STRATEGY CLASSES
# ==================================================

class Strategy:
    """Base strategy class"""

    @staticmethod
    def apply_transaction_costs(returns: pd.Series, signal: pd.Series,
                                cost: float = 0.001) -> pd.Series:
        """Apply transaction costs to strategy returns"""
        trades = signal.diff().abs()
        adjusted_returns = signal.shift(1) * returns
        adjusted_returns -= trades * cost
        return adjusted_returns.dropna()

class MovingAverageTrend(Strategy):
    """Moving Average trend following strategy"""

    def __init__(self, price: pd.Series, fast: int = 50, slow: int = 200):
        self.price = price
        self.fast = fast
        self.slow = slow

    def generate_signal(self) -> pd.Series:
        """Generate MA crossover signal"""
        ma_fast = self.price.rolling(self.fast).mean()
        ma_slow = self.price.rolling(self.slow).mean()
        return (ma_fast > ma_slow).astype(int)

    def backtest(self, returns: pd.Series, cost: float = 0.001) -> pd.Series:
        """Backtest the strategy"""
        signal = self.generate_signal()
        return self.apply_transaction_costs(returns, signal, cost)

class MeanReversion(Strategy):
    """Z-score based mean reversion strategy"""

    def __init__(self, price: pd.Series, window: int = 20,
                 entry_threshold: float = -1.0, exit_threshold: float = 0.0):
        self.price = price
        self.window = window
        self.entry_threshold = entry_threshold
        self.exit_threshold = exit_threshold

    def generate_signal(self) -> pd.Series:
        """Generate mean reversion signal"""
        zscore = compute_zscore(self.price, self.window)
        signal = pd.Series(0, index=zscore.index)

        # Entry when z-score is low (oversold)
        signal[zscore < self.entry_threshold] = 1
        # Exit when z-score returns to normal
        signal[zscore > self.exit_threshold] = 0

        # Forward fill to maintain positions
        signal = signal.replace(0, np.nan).fillna(method='ffill').fillna(0)

        return signal

    def backtest(self, returns: pd.Series, cost: float = 0.001) -> pd.Series:
        """Backtest the strategy"""
        signal = self.generate_signal()
        return self.apply_transaction_costs(returns, signal, cost)

class RSIStrategy(Strategy):
    """RSI-based mean reversion strategy"""

    def __init__(self, price: pd.Series, period: int = 14,
                 oversold: float = 30, overbought: float = 70):
        self.price = price
        self.period = period
        self.oversold = oversold
        self.overbought = overbought

    def generate_signal(self) -> pd.Series:
        """Generate RSI signal"""
        rsi = compute_rsi(self.price, self.period)
        signal = pd.Series(0, index=rsi.index)

        # Entry when RSI is oversold
        signal[rsi < self.oversold] = 1
        # Exit when RSI reaches overbought
        signal[rsi > self.overbought] = 0

        # Forward fill to maintain positions
        signal = signal.replace(0, np.nan).fillna(method='ffill').fillna(0)

        return signal

    def backtest(self, returns: pd.Series, cost: float = 0.001) -> pd.Series:
        """Backtest the strategy"""
        signal = self.generate_signal()
        return self.apply_transaction_costs(returns, signal, cost)

class BollingerBandsStrategy(Strategy):
    """Bollinger Bands mean reversion strategy"""

    def __init__(self, price: pd.Series, period: int = 20, num_std: float = 2.0):
        self.price = price
        self.period = period
        self.num_std = num_std

    def generate_signal(self) -> pd.Series:
        """Generate Bollinger Bands signal"""
        upper, middle, lower = compute_bollinger_bands(self.price, self.period, self.num_std)
        signal = pd.Series(0, index=self.price.index)

        # Entry when price touches lower band
        signal[self.price < lower] = 1
        # Exit when price returns to middle band
        signal[self.price > middle] = 0

        # Forward fill to maintain positions
        signal = signal.replace(0, np.nan).fillna(method='ffill').fillna(0)

        return signal

    def backtest(self, returns: pd.Series, cost: float = 0.001) -> pd.Series:
        """Backtest the strategy"""
        signal = self.generate_signal()
        return self.apply_transaction_costs(returns, signal, cost)

class MomentumPortfolio(Strategy):
    """Cross-sectional momentum strategy"""

    def __init__(self, prices: pd.DataFrame, lookback: int = 126,
                 top_n: int = 2, rebalance_freq: str = "ME"):
        self.prices = prices
        self.lookback = lookback
        self.top_n = top_n
        self.rebalance_freq = rebalance_freq

    def rank_assets(self) -> pd.DataFrame:
        """Rank assets by past returns"""
        past_returns = self.prices.pct_change(self.lookback, fill_method=None)
        return past_returns.rank(axis=1, ascending=False)

    def generate_weights(self) -> pd.DataFrame:
        """Generate equal-weight portfolio of top N assets"""
        ranks = self.rank_assets()
        signals = (ranks <= self.top_n).astype(int)
        weights = signals.div(signals.sum(axis=1), axis=0).fillna(0)

        # Rebalance at specified frequency
        weights = (
            weights.resample(self.rebalance_freq).last()
            .reindex(weights.index, method='ffill')
        )

        return weights

    def backtest(self, returns: pd.DataFrame, target_vol: float = 0.10) -> pd.Series:
        """Backtest momentum portfolio with volatility targeting"""
        weights = self.generate_weights()
        portfolio_returns = (weights.shift(1) * returns).sum(axis=1)

        # Apply volatility targeting
        realized_vol = portfolio_returns.rolling(20).std() * np.sqrt(252)
        scaler = safe_divide(
            pd.Series(target_vol, index=realized_vol.index),
            realized_vol
        ).clip(0, 1.5)

        return portfolio_returns * scaler.shift(1)

# ==================================================
# TRADING SIGNAL GENERATOR
# ==================================================

class TradingSignalGenerator:
    """Generate current trading signals for a given security"""

    def __init__(self, ticker: str, price_data: pd.Series, returns: pd.Series):
        self.ticker = ticker
        self.price = price_data
        self.returns = returns
        self.current_price = price_data.iloc[-1]
        self.signals = {}

    def generate_all_signals(self) -> Dict[str, Dict]:
        """Generate signals from all available strategies"""

        # Moving Average Strategy
        ma_strategy = MovingAverageTrend(self.price, Config.MA_FAST, Config.MA_SLOW)
        ma_signal = ma_strategy.generate_signal()
        self.signals['MA_Crossover'] = self._format_signal(
            ma_signal,
            "Moving Average Crossover (50/200)",
            self._get_ma_details()
        )

        # Mean Reversion (Z-Score)
        mr_strategy = MeanReversion(self.price, Config.ZSCORE_WINDOW,
                                    Config.ZSCORE_ENTRY, Config.ZSCORE_EXIT)
        mr_signal = mr_strategy.generate_signal()
        self.signals['Mean_Reversion'] = self._format_signal(
            mr_signal,
            "Mean Reversion (Z-Score)",
            self._get_zscore_details()
        )

        # RSI Strategy
        rsi_strategy = RSIStrategy(self.price, Config.RSI_PERIOD,
                                   Config.RSI_OVERSOLD, Config.RSI_OVERBOUGHT)
        rsi_signal = rsi_strategy.generate_signal()
        self.signals['RSI'] = self._format_signal(
            rsi_signal,
            "RSI Mean Reversion",
            self._get_rsi_details()
        )

        # Bollinger Bands Strategy
        bb_strategy = BollingerBandsStrategy(self.price, Config.BB_PERIOD, Config.BB_STD)
        bb_signal = bb_strategy.generate_signal()
        self.signals['Bollinger_Bands'] = self._format_signal(
            bb_signal,
            "Bollinger Bands",
            self._get_bb_details()
        )

        # Regime Detection
        detector = RegimeDetector(self.price, self.returns, Config.VOL_LOOKBACK,
                                 Config.VOL_THRESHOLD, Config.REGIME_CONFIRM_DAYS)
        regime = detector.detect_regime()
        self.signals['Regime'] = self._format_regime(regime)

        return self.signals

    def _format_signal(self, signal: pd.Series, strategy_name: str,
                      details: Dict) -> Dict:
        """Format signal output"""
        current_signal = signal.iloc[-1]
        previous_signal = signal.iloc[-2] if len(signal) > 1 else 0

        position = "LONG" if current_signal == 1 else "FLAT"
        action = "HOLD"

        if current_signal == 1 and previous_signal == 0:
            action = "BUY"
        elif current_signal == 0 and previous_signal == 1:
            action = "SELL"

        return {
            'strategy': strategy_name,
            'position': position,
            'action': action,
            'signal_value': int(current_signal),
            'details': details
        }

    def _format_regime(self, regime: pd.Series) -> Dict:
        """Format regime information"""
        current_regime = regime.iloc[-1]

        recommendation = {
            'Trend': "Favorable for trend-following and momentum strategies",
            'Choppy': "Favorable for mean reversion strategies",
            'Risk-Off': "Reduce exposure or stay in cash"
        }

        return {
            'strategy': 'Market Regime',
            'current_regime': current_regime,
            'recommendation': recommendation.get(current_regime, "Unknown"),
            'details': {
                'regime_type': current_regime,
                'volatility': self.returns.rolling(Config.VOL_LOOKBACK).std().iloc[-1] * np.sqrt(252)
            }
        }

    def _get_ma_details(self) -> Dict:
        """Get moving average details"""
        ma_fast = self.price.rolling(Config.MA_FAST).mean().iloc[-1]
        ma_slow = self.price.rolling(Config.MA_SLOW).mean().iloc[-1]

        return {
            'current_price': self.current_price,
            'ma_fast': ma_fast,
            'ma_slow': ma_slow,
            'distance_from_ma_fast': (self.current_price - ma_fast) / ma_fast,
            'distance_from_ma_slow': (self.current_price - ma_slow) / ma_slow
        }

    def _get_zscore_details(self) -> Dict:
        """Get z-score details"""
        zscore = compute_zscore(self.price, Config.ZSCORE_WINDOW).iloc[-1]
        mean = self.price.rolling(Config.ZSCORE_WINDOW).mean().iloc[-1]
        std = self.price.rolling(Config.ZSCORE_WINDOW).std().iloc[-1]

        return {
            'current_price': self.current_price,
            'zscore': zscore,
            'mean': mean,
            'std_dev': std,
            'interpretation': self._interpret_zscore(zscore)
        }

    def _get_rsi_details(self) -> Dict:
        """Get RSI details"""
        rsi = compute_rsi(self.price, Config.RSI_PERIOD).iloc[-1]

        return {
            'current_price': self.current_price,
            'rsi': rsi,
            'oversold_threshold': Config.RSI_OVERSOLD,
            'overbought_threshold': Config.RSI_OVERBOUGHT,
            'interpretation': self._interpret_rsi(rsi)
        }

    def _get_bb_details(self) -> Dict:
        """Get Bollinger Bands details"""
        upper, middle, lower = compute_bollinger_bands(self.price, Config.BB_PERIOD, Config.BB_STD)

        return {
            'current_price': self.current_price,
            'upper_band': upper.iloc[-1],
            'middle_band': middle.iloc[-1],
            'lower_band': lower.iloc[-1],
            'bb_width': (upper.iloc[-1] - lower.iloc[-1]) / middle.iloc[-1],
            'position_in_bands': (self.current_price - lower.iloc[-1]) / (upper.iloc[-1] - lower.iloc[-1])
        }

    def _interpret_zscore(self, zscore: float) -> str:
        """Interpret z-score value"""
        if zscore < -2:
            return "Extremely oversold"
        elif zscore < -1:
            return "Oversold"
        elif zscore > 2:
            return "Extremely overbought"
        elif zscore > 1:
            return "Overbought"
        else:
            return "Normal range"

    def _interpret_rsi(self, rsi: float) -> str:
        """Interpret RSI value"""
        if rsi < 30:
            return "Oversold"
        elif rsi > 70:
            return "Overbought"
        else:
            return "Neutral"

    def print_signals(self):
        """Print formatted trading signals"""
        print("\n" + "="*80)
        print(f"TRADING SIGNALS FOR {self.ticker}")
        print(f"Current Price: ${self.current_price:.2f}")
        print(f"As of: {self.price.index[-1].strftime('%Y-%m-%d')}")
        print("="*80)

        for signal_name, signal_data in self.signals.items():
            if signal_name == 'Regime':
                print(f"\n{signal_data['strategy']}:")
                print(f"  Current Regime: {signal_data['current_regime']}")
                print(f"  Recommendation: {signal_data['recommendation']}")
                print(f"  Volatility: {signal_data['details']['volatility']:.2%}")
            else:
                print(f"\n{signal_data['strategy']}:")
                print(f"  Position: {signal_data['position']}")
                print(f"  Action: {signal_data['action']}")

                details = signal_data['details']
                if 'ma_fast' in details:
                    print(f"  MA Fast ({Config.MA_FAST}): ${details['ma_fast']:.2f}")
                    print(f"  MA Slow ({Config.MA_SLOW}): ${details['ma_slow']:.2f}")
                elif 'zscore' in details:
                    print(f"  Z-Score: {details['zscore']:.2f} ({details['interpretation']})")
                    print(f"  Mean: ${details['mean']:.2f}")
                elif 'rsi' in details:
                    print(f"  RSI: {details['rsi']:.2f} ({details['interpretation']})")
                elif 'upper_band' in details:
                    print(f"  Upper Band: ${details['upper_band']:.2f}")
                    print(f"  Middle Band: ${details['middle_band']:.2f}")
                    print(f"  Lower Band: ${details['lower_band']:.2f}")

        print("\n" + "="*80)

# ==================================================
# REGIME-AWARE STRATEGY ALLOCATOR
# ==================================================

class RegimeAwareAllocator:
    """Allocate between strategies based on market regime"""

    def __init__(self, strategies: Dict[str, pd.Series], regime: pd.Series,
                 target_vol: float = 0.10):
        self.strategies = strategies
        self.regime = regime
        self.target_vol = target_vol

    def allocate(self) -> pd.Series:
        """Allocate between strategies based on regime"""
        combined = pd.DataFrame(self.strategies).dropna()
        regime_aligned = self.regime.reindex(combined.index)

        final_returns = pd.Series(0.0, index=combined.index)

        # Trend regime: favor trend following strategies
        trend_mask = regime_aligned == "Trend"
        if trend_mask.any():
            # Use MA if available, otherwise use any trend-following strategy
            if 'MA' in combined.columns:
                final_returns[trend_mask] = combined.loc[trend_mask, "MA"]
            elif 'MOM' in combined.columns:
                final_returns[trend_mask] = combined.loc[trend_mask, "MOM"]
            else:
                # Average all available strategies
                final_returns[trend_mask] = combined.loc[trend_mask].mean(axis=1)

        # Choppy regime: favor mean reversion strategies
        choppy_mask = regime_aligned == "Choppy"
        if choppy_mask.any():
            # Prefer mean reversion strategies
            mean_rev_strategies = []
            if 'Z' in combined.columns:
                mean_rev_strategies.append('Z')
            if 'RSI' in combined.columns:
                mean_rev_strategies.append('RSI')
            if 'BB' in combined.columns:
                mean_rev_strategies.append('BB')

            if mean_rev_strategies:
                final_returns[choppy_mask] = combined.loc[choppy_mask, mean_rev_strategies].mean(axis=1)
            else:
                # Use all available strategies
                final_returns[choppy_mask] = combined.loc[choppy_mask].mean(axis=1)

        # Risk-off regime: reduce exposure (stay flat)
        risk_off_mask = regime_aligned == "Risk-Off"
        final_returns[risk_off_mask] = 0.0

        # Apply volatility targeting
        return self._apply_vol_targeting(final_returns)

    def _apply_vol_targeting(self, returns: pd.Series) -> pd.Series:
        """Apply volatility targeting to final returns"""
        realized_vol = returns.rolling(20).std() * np.sqrt(252)
        scaler = safe_divide(
            pd.Series(self.target_vol, index=realized_vol.index),
            realized_vol
        ).clip(0, 1.5)

        return returns * scaler.shift(1)

# ==================================================
# WALK-FORWARD ANALYSIS
# ==================================================

# ==================================================
# MULTI-FACTOR MODEL
# ==================================================

class Factor:
    """Base class for factor calculation"""

    def __init__(self, name: str):
        self.name = name

    def calculate(self, prices: pd.DataFrame, returns: pd.DataFrame,
                 fundamentals: Optional[Dict] = None) -> pd.Series:
        """Calculate factor values for each asset"""
        raise NotImplementedError

    def get_signal(self, factor_values: pd.Series,
                   method: str = 'zscore') -> pd.Series:
        """
        Convert factor values to signals

        Args:
            factor_values: Raw factor values
            method: 'zscore', 'rank', or 'quintile'

        Returns:
            Normalized signals
        """
        if method == 'zscore':
            # Z-score normalization
            mean = factor_values.mean()
            std = factor_values.std()
            if std > 0:
                return (factor_values - mean) / std
            return pd.Series(0, index=factor_values.index)

        elif method == 'rank':
            # Rank from 0 to 1
            return factor_values.rank(pct=True)

        elif method == 'quintile':
            # Quintile ranking (-2 to +2)
            quintiles = pd.qcut(factor_values, q=5, labels=False, duplicates='drop')
            return quintiles - 2

        return factor_values

class MomentumFactor(Factor):
    """
    Momentum Factor - Past returns predict future returns

    Measures: Recent price performance
    Theory: Winners continue winning, losers continue losing
    """

    def __init__(self, lookback_periods: List[int] = [21, 63, 126, 252]):
        """
        Args:
            lookback_periods: List of lookback periods in days
                             Default: 1m, 3m, 6m, 12m
        """
        super().__init__("Momentum")
        self.lookback_periods = lookback_periods

    def calculate(self, prices: pd.DataFrame, returns: pd.DataFrame,
                 fundamentals: Optional[Dict] = None) -> pd.DataFrame:
        """
        Calculate momentum for multiple lookback periods

        Returns:
            DataFrame with momentum values for each period
        """
        momentum_factors = {}

        for period in self.lookback_periods:
            period_name = f"mom_{period}d"

            # Calculate cumulative returns over period
            if len(prices) >= period:
                period_returns = prices.pct_change(period, fill_method=None)
                momentum_factors[period_name] = period_returns.iloc[-1]
            else:
                # Not enough data
                momentum_factors[period_name] = pd.Series(0, index=prices.columns)

        momentum_df = pd.DataFrame(momentum_factors)

        # Composite momentum (average across periods)
        momentum_df['composite'] = momentum_df.mean(axis=1)

        return momentum_df

    def calculate_residual_momentum(self, returns: pd.DataFrame,
                                    market_returns: pd.Series) -> pd.Series:
        """
        Calculate residual momentum (alpha momentum)

        Returns momentum after removing market beta
        """
        residual_mom = {}

        for ticker in returns.columns:
            asset_returns = returns[ticker].dropna()
            aligned_market = market_returns.reindex(asset_returns.index).dropna()

            if len(asset_returns) > 30:
                # Simple beta calculation
                covariance = asset_returns.cov(aligned_market)
                market_variance = aligned_market.var()

                if market_variance > 0:
                    beta = covariance / market_variance
                    residual = asset_returns - beta * aligned_market
                    residual_mom[ticker] = residual.mean()
                else:
                    residual_mom[ticker] = asset_returns.mean()
            else:
                residual_mom[ticker] = 0

        return pd.Series(residual_mom)

class VolatilityFactor(Factor):
    """
    Volatility Factor - Low volatility anomaly

    Measures: Price volatility
    Theory: Low volatility stocks outperform high volatility stocks
           (contradicts CAPM)
    """

    def __init__(self, lookback_periods: List[int] = [21, 63, 252]):
        """
        Args:
            lookback_periods: Volatility measurement periods
                             Default: 1m, 3m, 12m
        """
        super().__init__("Volatility")
        self.lookback_periods = lookback_periods

    def calculate(self, prices: pd.DataFrame, returns: pd.DataFrame,
                 fundamentals: Optional[Dict] = None) -> pd.DataFrame:
        """
        Calculate volatility measures

        Returns:
            DataFrame with volatility for each period (annualized)
        """
        volatility_factors = {}

        for period in self.lookback_periods:
            period_name = f"vol_{period}d"

            if len(returns) >= period:
                # Rolling volatility (annualized)
                rolling_vol = returns.rolling(period).std() * np.sqrt(252)
                volatility_factors[period_name] = rolling_vol.iloc[-1]
            else:
                volatility_factors[period_name] = pd.Series(np.nan, index=returns.columns)

        vol_df = pd.DataFrame(volatility_factors)

        # Composite volatility (average)
        vol_df['composite'] = vol_df.mean(axis=1)

        # Invert for low-vol strategy (negative sign = prefer low vol)
        vol_df['low_vol_signal'] = -vol_df['composite']

        return vol_df

    def calculate_downside_volatility(self, returns: pd.DataFrame,
                                     threshold: float = 0) -> pd.Series:
        """Calculate downside volatility (semi-deviation)"""
        downside_vol = {}

        for ticker in returns.columns:
            asset_returns = returns[ticker].dropna()
            downside_returns = asset_returns[asset_returns < threshold]

            if len(downside_returns) > 0:
                downside_vol[ticker] = downside_returns.std() * np.sqrt(252)
            else:
                downside_vol[ticker] = 0

        return pd.Series(downside_vol)

class ValueFactor(Factor):
    """
    Value Factor - Cheap stocks outperform expensive stocks

    Measures: P/E, P/B, P/S, Dividend Yield, EV/EBITDA
    Theory: Value stocks are underpriced and provide better returns

    Note: Requires fundamental data (yfinance provides some)
    """

    def __init__(self):
        super().__init__("Value")

    def calculate(self, prices: pd.DataFrame, returns: pd.DataFrame,
                 fundamentals: Optional[Dict] = None) -> pd.DataFrame:
        """
        Calculate value metrics

        Args:
            fundamentals: Dict of {ticker: {metric: value}}

        Returns:
            DataFrame with value scores
        """
        value_factors = {}

        for ticker in prices.columns:
            if fundamentals and ticker in fundamentals:
                fund = fundamentals[ticker]

                value_factors[ticker] = {
                    'pe_ratio': fund.get('trailingPE', np.nan),
                    'pb_ratio': fund.get('priceToBook', np.nan),
                    'ps_ratio': fund.get('priceToSalesTrailing12Months', np.nan),
                    'div_yield': fund.get('dividendYield', 0) * 100 if fund.get('dividendYield') else 0,
                    'ev_ebitda': fund.get('enterpriseToEbitda', np.nan)
                }
            else:
                # No fundamental data available
                value_factors[ticker] = {
                    'pe_ratio': np.nan,
                    'pb_ratio': np.nan,
                    'ps_ratio': np.nan,
                    'div_yield': np.nan,
                    'ev_ebitda': np.nan
                }

        value_df = pd.DataFrame(value_factors).T

        # Calculate composite value score
        # Lower P/E, P/B, P/S is better (inverted)
        # Higher dividend yield is better

        value_scores = pd.Series(0.0, index=value_df.index)

        if not value_df['pe_ratio'].isna().all():
            # Invert P/E (lower is better)
            pe_score = -value_df['pe_ratio'].rank(pct=True)
            value_scores += pe_score.fillna(0)

        if not value_df['pb_ratio'].isna().all():
            pb_score = -value_df['pb_ratio'].rank(pct=True)
            value_scores += pb_score.fillna(0)

        if not value_df['div_yield'].isna().all():
            # Higher dividend yield is better
            div_score = value_df['div_yield'].rank(pct=True)
            value_scores += div_score.fillna(0)

        value_df['composite'] = value_scores

        return value_df

    def fetch_fundamentals(self, tickers: List[str]) -> Dict:
        """Fetch fundamental data from yfinance"""
        fundamentals = {}

        print("Fetching fundamental data...")
        for ticker in tickers:
            try:
                stock = yf.Ticker(ticker)
                info = stock.info

                fundamentals[ticker] = {
                    'trailingPE': info.get('trailingPE'),
                    'priceToBook': info.get('priceToBook'),
                    'priceToSalesTrailing12Months': info.get('priceToSalesTrailing12Months'),
                    'dividendYield': info.get('dividendYield'),
                    'enterpriseToEbitda': info.get('enterpriseToEbitda'),
                    'marketCap': info.get('marketCap'),
                    'sector': info.get('sector')
                }
                print(f"  {ticker}: ✓")
            except:
                print(f"  {ticker}: ✗ (no data)")
                fundamentals[ticker] = {}

        return fundamentals

class MultiFactorModel:
    """
    Multi-Factor Model combining multiple factors

    Combines momentum, volatility, and value factors to generate
    portfolio weights and trading signals
    """

    def __init__(self, factors: Optional[List[Factor]] = None,
                 factor_weights: Optional[Dict[str, float]] = None):
        """
        Args:
            factors: List of Factor objects to use
            factor_weights: Dict of {factor_name: weight}
                          If None, equal weight
        """
        if factors is None:
            # Default: momentum and volatility (value needs fundamentals)
            self.factors = [
                MomentumFactor(),
                VolatilityFactor()
            ]
        else:
            self.factors = factors

        self.factor_weights = factor_weights or {}
        self.factor_scores = {}
        self.combined_scores = None
        self.decile_ranks = None  # For decile-based portfolio construction

    def calculate_factor_scores(self, prices: pd.DataFrame,
                                returns: pd.DataFrame,
                                fundamentals: Optional[Dict] = None) -> Dict[str, pd.Series]:
        """
        Calculate scores for all factors

        Returns:
            Dict of {factor_name: scores}
        """
        scores = {}

        for factor in self.factors:
            print(f"Calculating {factor.name} factor...")

            factor_values = factor.calculate(prices, returns, fundamentals)

            # Get composite score
            if 'composite' in factor_values.columns:
                composite = factor_values['composite']
            elif 'low_vol_signal' in factor_values.columns:
                composite = factor_values['low_vol_signal']
            else:
                composite = factor_values.iloc[:, 0]

            # Normalize to z-scores
            normalized = factor.get_signal(composite, method='zscore')
            scores[factor.name] = normalized

        self.factor_scores = scores
        return scores

    def combine_factors(self, factor_scores: Optional[Dict[str, pd.Series]] = None,
                       method: str = 'equal_weight') -> pd.Series:
        """
        Combine multiple factors into single score

        Args:
            factor_scores: Dict of factor scores (uses self.factor_scores if None)
            method: 'equal_weight', 'custom', or 'ic_weighted'

        Returns:
            Combined factor scores
        """
        if factor_scores is None:
            factor_scores = self.factor_scores

        if not factor_scores:
            raise ValueError("No factor scores available")

        # Convert to DataFrame
        scores_df = pd.DataFrame(factor_scores)

        if method == 'equal_weight':
            # Simple average
            combined = scores_df.mean(axis=1)

        elif method == 'custom':
            # Use provided weights
            if not self.factor_weights:
                raise ValueError("Must provide factor_weights for custom weighting")

            combined = pd.Series(0.0, index=scores_df.index)
            for factor_name, weight in self.factor_weights.items():
                if factor_name in scores_df.columns:
                    combined += scores_df[factor_name] * weight

        else:
            combined = scores_df.mean(axis=1)

        self.combined_scores = combined
        return combined

    def rank_assets_by_decile(self, combined_scores: Optional[pd.Series] = None) -> pd.Series:
        """
        Rank assets into deciles (1-10)

        Decile 1 = Bottom 10% (worst performers)
        Decile 10 = Top 10% (best performers)

        Args:
            combined_scores: Combined factor scores

        Returns:
            Series of decile rankings (1 = bottom, 10 = top)
        """
        if combined_scores is None:
            combined_scores = self.combined_scores

        if combined_scores is None:
            raise ValueError("Must calculate combined scores first")

        # Remove NaN
        scores = combined_scores.dropna()
        n_assets = len(scores)

        if n_assets < 10:
            # Not enough assets for 10 deciles, use quintiles (5 groups)
            print(f"\nNote: Only {n_assets} assets available.")
            print(f"Using {min(n_assets, 5)} groups instead of 10 deciles.")

            n_groups = min(n_assets, 5)
            try:
                ranks = pd.qcut(scores, q=n_groups, labels=False, duplicates='drop') + 1
            except ValueError:
                # Too many duplicates even for fewer groups
                ranks = scores.rank(method='first', pct=True)
                ranks = (ranks * n_groups).astype(int) + 1
                ranks = ranks.clip(1, n_groups)

        elif n_assets < 20:
            # 10-19 assets: use 5 quintiles
            print(f"\nNote: {n_assets} assets - using 5 groups (quintiles)")
            try:
                ranks = pd.qcut(scores, q=5, labels=False, duplicates='drop') + 1
            except ValueError:
                ranks = scores.rank(method='first', pct=True)
                ranks = (ranks * 5).astype(int) + 1
                ranks = ranks.clip(1, 5)

        else:
            # 20+ assets: use full 10 deciles
            try:
                ranks = pd.qcut(scores, q=10, labels=False, duplicates='drop') + 1
            except ValueError:
                # If too many duplicates, fall back to ranking
                ranks = scores.rank(method='first', pct=True)
                ranks = (ranks * 10).astype(int) + 1
                ranks = ranks.clip(1, 10)

        self.decile_ranks = ranks
        return ranks

    def get_top_decile(self, decile_ranks: Optional[pd.Series] = None) -> List[str]:
        """
        Get assets in top decile (highest scores)

        Returns:
            List of ticker symbols in top decile
        """
        if decile_ranks is None:
            decile_ranks = self.decile_ranks

        if decile_ranks is None:
            raise ValueError("Must calculate decile ranks first")

        # Top decile has highest rank number
        top_decile = decile_ranks[decile_ranks == decile_ranks.max()]
        return top_decile.index.tolist()

    def get_bottom_decile(self, decile_ranks: Optional[pd.Series] = None) -> List[str]:
        """
        Get assets in bottom decile (lowest scores)

        Returns:
            List of ticker symbols in bottom decile
        """
        if decile_ranks is None:
            decile_ranks = self.decile_ranks

        if decile_ranks is None:
            raise ValueError("Must calculate decile ranks first")

        # Bottom decile has lowest rank number
        bottom_decile = decile_ranks[decile_ranks == decile_ranks.min()]
        return bottom_decile.index.tolist()

    def generate_long_short_decile_portfolio(self,
                                            combined_scores: Optional[pd.Series] = None,
                                            long_allocation: float = 1.0,
                                            short_allocation: float = 1.0) -> pd.Series:
        """
        Generate long-short portfolio: Long top decile, Short bottom decile

        Classic factor portfolio construction:
        - Long the top 10% of assets (best factor scores)
        - Short the bottom 10% of assets (worst factor scores)
        - Equal weight within each decile

        Args:
            combined_scores: Combined factor scores
            long_allocation: Total capital for long positions (1.0 = 100%)
            short_allocation: Total capital for short positions (1.0 = 100%)

        Returns:
            Portfolio weights (positive = long, negative = short)
        """
        if combined_scores is None:
            combined_scores = self.combined_scores

        n_assets = len(combined_scores.dropna())

        # Warn if too few assets
        if n_assets < 10:
            print(f"\n⚠ WARNING: Only {n_assets} assets provided.")
            print(f"  Recommended: 20-50 assets for proper decile analysis")
            print(f"  Minimum: 10 assets")
            print(f"  Current strategy: Long top {1}/{n_assets}, Short bottom {1}/{n_assets}")

        # Rank into deciles (or fewer groups if needed)
        decile_ranks = self.rank_assets_by_decile(combined_scores)

        # Get top and bottom groups
        top_group = self.get_top_decile(decile_ranks)
        bottom_group = self.get_bottom_decile(decile_ranks)

        print(f"\nPortfolio Construction:")
        print(f"  Total Assets: {n_assets}")
        print(f"  Top Group (LONG): {len(top_group)} assets")
        print(f"  Bottom Group (SHORT): {len(bottom_group)} assets")
        print(f"  Long Allocation: {long_allocation:.0%}")
        print(f"  Short Allocation: {short_allocation:.0%}")

        # Initialize weights
        weights = pd.Series(0.0, index=combined_scores.index)

        # Long positions (equal weight within top group)
        if len(top_group) > 0:
            long_weight_per_asset = long_allocation / len(top_group)
            for ticker in top_group:
                weights[ticker] = long_weight_per_asset

        # Short positions (equal weight within bottom group)
        if len(bottom_group) > 0:
            short_weight_per_asset = -short_allocation / len(bottom_group)
            for ticker in bottom_group:
                weights[ticker] = short_weight_per_asset

        return weights

    def print_decile_analysis(self):
        """Print detailed decile distribution"""
        if self.decile_ranks is None:
            print("No decile ranks calculated. Call rank_assets_by_decile() first.")
            return

        print("\n" + "="*80)
        print("DECILE DISTRIBUTION")
        print("="*80)

        for decile in sorted(self.decile_ranks.unique()):
            assets_in_decile = self.decile_ranks[self.decile_ranks == decile]

            if len(assets_in_decile) > 0:
                print(f"\nDecile {decile}: {len(assets_in_decile)} assets")
                for ticker in assets_in_decile.index:
                    score = self.combined_scores[ticker] if self.combined_scores is not None else 0
                    print(f"  {ticker}: score {score:.3f}")

        # Highlight top and bottom
        top_decile = self.get_top_decile()
        bottom_decile = self.get_bottom_decile()

        print(f"\n" + "="*80)
        print(f"PORTFOLIO POSITIONS:")
        print(f"  LONG (Top Decile): {', '.join(top_decile)}")
        print(f"  SHORT (Bottom Decile): {', '.join(bottom_decile)}")
        print("="*80)

    def generate_portfolio_weights(self, combined_scores: Optional[pd.Series] = None,
                                  method: str = 'long_only',
                                  top_n: Optional[int] = None,
                                  long_allocation: float = 1.0,
                                  short_allocation: float = 1.0) -> pd.Series:
        """
        Generate portfolio weights from factor scores

        Args:
            combined_scores: Combined factor scores
            method: 'long_only', 'long_short', 'long_short_decile', or 'ranked'
            top_n: Number of top assets to hold (for long_only/ranked)
            long_allocation: Long capital (for long_short_decile)
            short_allocation: Short capital (for long_short_decile)

        Returns:
            Portfolio weights
        """
        if combined_scores is None:
            combined_scores = self.combined_scores

        if combined_scores is None:
            raise ValueError("Must calculate combined scores first")

        # Remove NaN
        scores = combined_scores.dropna()

        if len(scores) == 0:
            return pd.Series()

        if method == 'long_short_decile':
            # Decile-based long-short
            return self.generate_long_short_decile_portfolio(
                scores, long_allocation, short_allocation
            )

        elif method == 'long_only':
            # Only long positive scores
            positive_scores = scores[scores > 0]

            if len(positive_scores) == 0:
                return pd.Series(0, index=scores.index)

            # Select top N if specified
            if top_n and len(positive_scores) > top_n:
                positive_scores = positive_scores.nlargest(top_n)

            # Normalize to sum to 1
            weights = positive_scores / positive_scores.sum()

            # Ensure all tickers present
            return weights.reindex(scores.index, fill_value=0)

        elif method == 'long_short':
            # Long high scores, short low scores
            # Top 30% long, bottom 30% short
            n_long = max(1, int(len(scores) * 0.3))
            n_short = max(1, int(len(scores) * 0.3))

            long_assets = scores.nlargest(n_long)
            short_assets = scores.nsmallest(n_short)

            weights = pd.Series(0.0, index=scores.index)

            # Long positions (50% of capital)
            if len(long_assets) > 0:
                weights[long_assets.index] = 0.5 / len(long_assets)

            # Short positions (50% of capital)
            if len(short_assets) > 0:
                weights[short_assets.index] = -0.5 / len(short_assets)

            return weights

        elif method == 'ranked':
            # Weight proportional to rank
            ranks = scores.rank(pct=True)

            if top_n:
                top_assets = scores.nlargest(top_n)
                ranks = ranks[top_assets.index]

            weights = ranks / ranks.sum()
            return weights.reindex(scores.index, fill_value=0)

        return pd.Series()

    def backtest_factor_model(self, prices: pd.DataFrame, returns: pd.DataFrame,
                             fundamentals: Optional[Dict] = None,
                             rebalance_frequency: str = 'monthly',
                             method: str = 'long_only',
                             top_n: int = 5) -> pd.Series:
        """
        Backtest the multi-factor model

        Returns:
            Portfolio returns series
        """
        print("\n" + "="*80)
        print("MULTI-FACTOR MODEL BACKTEST")
        print("="*80)
        print(f"Factors: {[f.name for f in self.factors]}")
        print(f"Method: {method}")
        print(f"Top N: {top_n}")
        print(f"Rebalance: {rebalance_frequency}")

        # Calculate factor scores
        factor_scores = self.calculate_factor_scores(prices, returns, fundamentals)

        # Combine factors
        combined = self.combine_factors(factor_scores)

        # Generate weights
        weights = self.generate_portfolio_weights(combined, method, top_n)

        print(f"\nPortfolio Allocation:")
        for ticker, weight in weights[weights > 0].sort_values(ascending=False).items():
            print(f"  {ticker}: {weight:.2%}")

        # Calculate portfolio returns
        # Simple implementation - assumes constant weights
        portfolio_returns = (returns * weights).sum(axis=1)

        return portfolio_returns

    def print_factor_analysis(self):
        """Print detailed factor analysis"""
        if not self.factor_scores:
            print("No factor scores calculated")
            return

        print("\n" + "="*80)
        print("FACTOR ANALYSIS")
        print("="*80)

        for factor_name, scores in self.factor_scores.items():
            print(f"\n{factor_name} Factor:")
            print(f"  Mean: {scores.mean():.3f}")
            print(f"  Std: {scores.std():.3f}")
            print(f"  Min: {scores.min():.3f}")
            print(f"  Max: {scores.max():.3f}")

            # Top and bottom
            print(f"\n  Top 3 assets:")
            for ticker, score in scores.nlargest(3).items():
                print(f"    {ticker}: {score:.3f}")

            print(f"\n  Bottom 3 assets:")
            for ticker, score in scores.nsmallest(3).items():
                print(f"    {ticker}: {score:.3f}")

# ==================================================
# WALK-FORWARD ANALYSIS
# ==================================================

class WalkForwardAnalyzer:
    """
    Comprehensive walk-forward optimization and testing

    Features:
    - Parameter optimization on training window
    - Out-of-sample testing
    - Rolling window re-training
    - Performance tracking per window
    - Overfitting detection
    """

    def __init__(self, train_years: int = 8, test_years: int = 4,
                 anchor: bool = False):
        """
        Initialize walk-forward analyzer

        Args:
            train_years: Years for training window (default 8: 2010-2018)
            test_years: Years for testing window (default 4: 2019-2022)
            anchor: If True, always start from beginning (anchored)
                   If False, use rolling window
        """
        self.train_years = train_years
        self.test_years = test_years
        self.anchor = anchor
        self.windows = []
        self.results = []

    def run(self, price: pd.Series, returns: pd.Series,
            start_date: str = '2010-01-01') -> Dict:
        """
        Execute comprehensive walk-forward analysis

        Args:
            price: Price series
            returns: Returns series
            start_date: Start date for analysis

        Returns:
            Dictionary with results
        """
        print("\n" + "="*80)
        print("WALK-FORWARD ANALYSIS")
        print("="*80)
        print(f"Training Period: {self.train_years} years")
        print(f"Testing Period: {self.test_years} years")
        print(f"Method: {'Anchored' if self.anchor else 'Rolling'}")
        print("="*80)

        # Find windows
        self.windows = self._create_windows(returns.index, start_date)

        if not self.windows:
            print("Error: Insufficient data for walk-forward analysis")
            print(f"Need at least {self.train_years + self.test_years} years of data")
            return {}

        print(f"\nTotal Windows: {len(self.windows)}")

        # Process each window
        all_oos_returns = []

        for i, window in enumerate(self.windows, 1):
            print(f"\n--- Window {i}/{len(self.windows)} ---")
            print(f"Train: {window['train_start'].date()} to {window['train_end'].date()}")
            print(f"Test:  {window['test_start'].date()} to {window['test_end'].date()}")

            # Get data for this window
            train_prices = price.loc[window['train_start']:window['train_end']]
            train_returns = returns.loc[window['train_start']:window['train_end']]

            test_prices = price.loc[window['test_start']:window['test_end']]
            test_returns = returns.loc[window['test_start']:window['test_end']]

            if len(train_returns) < 100 or len(test_returns) < 20:
                print("  Skipping: insufficient data")
                continue

            # Optimize parameters on training data
            print("  Optimizing parameters on training data...")
            best_params = self._optimize_parameters(train_prices, train_returns)

            # Test on out-of-sample data
            print(f"  Testing with optimized parameters...")
            oos_returns = self._backtest_with_params(
                test_prices, test_returns, best_params
            )

            if len(oos_returns) > 0:
                all_oos_returns.append(oos_returns)

                # Calculate metrics for this window
                window_metrics = PerformanceAnalytics.calculate_metrics(oos_returns)

                # Store results
                self.results.append({
                    'window': i,
                    'train_start': window['train_start'],
                    'train_end': window['train_end'],
                    'test_start': window['test_start'],
                    'test_end': window['test_end'],
                    'params': best_params,
                    'oos_returns': oos_returns,
                    'metrics': window_metrics
                })

                print(f"  OOS Sharpe: {window_metrics['sharpe']:.2f}")
                print(f"  OOS Return: {window_metrics['total_return']:.2%}")

        # Combine all out-of-sample returns
        if all_oos_returns:
            combined_oos = pd.concat(all_oos_returns)
            combined_oos = combined_oos.sort_index()

            # Calculate overall metrics
            overall_metrics = PerformanceAnalytics.calculate_metrics(combined_oos)

            # Print summary
            self._print_summary(overall_metrics)

            return {
                'oos_returns': combined_oos,
                'overall_metrics': overall_metrics,
                'windows': self.results,
                'num_windows': len(self.results)
            }

        return {}

    def _create_windows(self, date_index: pd.DatetimeIndex,
                       start_date: str) -> List[Dict]:
        """Create train/test windows"""
        windows = []

        start = pd.to_datetime(start_date)
        end = date_index[-1]

        current_start = start

        while True:
            # Training period
            if self.anchor:
                train_start = start  # Anchored: always from beginning
            else:
                train_start = current_start  # Rolling window

            train_end = current_start + pd.DateOffset(years=self.train_years)

            # Testing period
            test_start = train_end
            test_end = test_start + pd.DateOffset(years=self.test_years)

            # Check if we have enough data
            if test_end > end:
                break

            windows.append({
                'train_start': train_start,
                'train_end': train_end,
                'test_start': test_start,
                'test_end': test_end
            })

            # Move forward by test period
            current_start = test_start

        return windows

    def _optimize_parameters(self, price: pd.Series,
                            returns: pd.Series) -> Dict:
        """
        Optimize strategy parameters on training data

        Tests multiple parameter combinations and returns best
        """
        best_sharpe = -np.inf
        best_params = {
            'ma_fast': 50,
            'ma_slow': 200,
            'use_regime': True
        }

        # Parameter ranges to test
        ma_fast_range = [30, 40, 50, 60]
        ma_slow_range = [150, 180, 200, 220]

        for fast in ma_fast_range:
            for slow in ma_slow_range:
                if fast >= slow:
                    continue

                # Backtest with these parameters
                test_returns = self._backtest_ma(price, returns, fast, slow)

                if len(test_returns) > 0 and test_returns.std() > 0:
                    sharpe = test_returns.mean() / test_returns.std() * np.sqrt(252)

                    if sharpe > best_sharpe:
                        best_sharpe = sharpe
                        best_params = {
                            'ma_fast': fast,
                            'ma_slow': slow,
                            'use_regime': True
                        }

        return best_params

    def _backtest_ma(self, price: pd.Series, returns: pd.Series,
                    fast: int, slow: int) -> pd.Series:
        """Backtest MA strategy with given parameters"""
        try:
            ma_fast = price.rolling(fast).mean()
            ma_slow = price.rolling(slow).mean()
            signal = (ma_fast > ma_slow).astype(int)

            # Apply strategy
            strategy_returns = signal.shift(1) * returns

            # Apply transaction costs
            trades = signal.diff().abs()
            strategy_returns -= trades * Config.TRANSACTION_COST

            return strategy_returns.dropna()
        except:
            return pd.Series()

    def _backtest_with_params(self, price: pd.Series, returns: pd.Series,
                             params: Dict) -> pd.Series:
        """Backtest using optimized parameters"""
        return self._backtest_ma(
            price, returns,
            params['ma_fast'],
            params['ma_slow']
        )

    def _print_summary(self, metrics: Dict):
        """Print walk-forward summary"""
        print("\n" + "="*80)
        print("WALK-FORWARD RESULTS (Out-of-Sample)")
        print("="*80)
        print(f"Total Return:        {metrics['total_return']:>10.2%}")
        print(f"CAGR:                {metrics['cagr']:>10.2%}")
        print(f"Sharpe Ratio:        {metrics['sharpe']:>10.2f}")
        print(f"Sortino Ratio:       {metrics['sortino']:>10.2f}")
        print(f"Max Drawdown:        {metrics['max_drawdown']:>10.2%}")
        print(f"Win Rate:            {metrics['win_rate']:>10.2%}")
        print("="*80)

        # Check for overfitting
        if len(self.results) > 0:
            # Compare performance across windows
            sharpes = [r['metrics']['sharpe'] for r in self.results]
            sharpe_std = np.std(sharpes)
            sharpe_mean = np.mean(sharpes)

            print(f"\nConsistency Analysis:")
            print(f"  Average Window Sharpe: {sharpe_mean:.2f}")
            print(f"  Std Dev of Sharpes:    {sharpe_std:.2f}")

            if sharpe_std / abs(sharpe_mean) > 0.5 if sharpe_mean != 0 else True:
                print("  ⚠ Warning: High variance across windows - possible overfitting")
            else:
                print("  ✓ Consistent performance across windows")

    def plot_results(self):
        """Plot walk-forward analysis results"""
        if not self.results:
            print("No results to plot")
            return

        fig, axes = plt.subplots(3, 1, figsize=(14, 10))

        # 1. Cumulative returns by window
        colors = plt.cm.viridis(np.linspace(0, 1, len(self.results)))

        for i, result in enumerate(self.results):
            oos_returns = result['oos_returns']
            equity = (1 + oos_returns).cumprod()

            axes[0].plot(equity.index, equity.values,
                        label=f"Window {result['window']}",
                        color=colors[i], alpha=0.7)

        axes[0].set_ylabel('Cumulative Return')
        axes[0].set_title('Walk-Forward: Out-of-Sample Performance by Window',
                         fontweight='bold')
        axes[0].legend(bbox_to_anchor=(1.05, 1), loc='upper left')
        axes[0].grid(True, alpha=0.3)

        # 2. Sharpe ratio by window
        window_nums = [r['window'] for r in self.results]
        sharpes = [r['metrics']['sharpe'] for r in self.results]

        axes[1].bar(window_nums, sharpes, color='steelblue', alpha=0.7)
        axes[1].axhline(y=np.mean(sharpes), color='red', linestyle='--',
                       label=f'Mean: {np.mean(sharpes):.2f}')
        axes[1].set_xlabel('Window')
        axes[1].set_ylabel('Sharpe Ratio')
        axes[1].set_title('Sharpe Ratio by Window (Consistency Check)')
        axes[1].legend()
        axes[1].grid(True, alpha=0.3)

        # 3. Optimized parameters over time
        ma_fast_params = [r['params']['ma_fast'] for r in self.results]
        ma_slow_params = [r['params']['ma_slow'] for r in self.results]

        axes[2].plot(window_nums, ma_fast_params, marker='o',
                    label='Fast MA', color='green')
        axes[2].plot(window_nums, ma_slow_params, marker='s',
                    label='Slow MA', color='red')
        axes[2].set_xlabel('Window')
        axes[2].set_ylabel('Parameter Value')
        axes[2].set_title('Optimal Parameters Over Time')
        axes[2].legend()
        axes[2].grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    def get_detailed_report(self) -> str:
        """Generate detailed text report"""
        if not self.results:
            return "No results available"

        report = "\n" + "="*80 + "\n"
        report += "DETAILED WALK-FORWARD REPORT\n"
        report += "="*80 + "\n\n"

        for result in self.results:
            report += f"Window {result['window']}:\n"
            report += f"  Training:  {result['train_start'].date()} to {result['train_end'].date()}\n"
            report += f"  Testing:   {result['test_start'].date()} to {result['test_end'].date()}\n"
            report += f"  Parameters: MA({result['params']['ma_fast']}/{result['params']['ma_slow']})\n"
            report += f"  OOS Sharpe: {result['metrics']['sharpe']:>6.2f}\n"
            report += f"  OOS Return: {result['metrics']['total_return']:>6.2%}\n"
            report += f"  Max DD:     {result['metrics']['max_drawdown']:>6.2%}\n"
            report += "\n"

        return report

# ==================================================
# MONTE CARLO SIMULATION
# ==================================================

class MonteCarloSimulator:
    """Monte Carlo simulation for strategy robustness testing"""

    def __init__(self, returns: pd.Series, n_simulations: int = 1000,
                 sample_size: int = 252):
        self.returns = returns.dropna()
        self.n_simulations = n_simulations
        self.sample_size = sample_size

    def run(self) -> pd.DataFrame:
        """Run Monte Carlo simulation using bootstrap resampling"""
        simulated_returns = []

        for _ in range(self.n_simulations):
            sample = np.random.choice(
                self.returns.values,
                size=self.sample_size,
                replace=True
            )
            simulated_returns.append(sample)

        return pd.DataFrame(simulated_returns).T

    def get_metrics(self) -> Dict[str, float]:
        """Calculate Monte Carlo statistics"""
        sims = self.run()
        equity_curves = (1 + sims).cumprod()
        final_values = equity_curves.iloc[-1]

        sharpe_ratios = []
        for col in sims.columns:
            ret = sims[col]
            if ret.std() > 0:
                sharpe_ratios.append(ret.mean() / ret.std() * np.sqrt(252))

        return {
            'mean_return': final_values.mean() - 1,
            'median_return': final_values.median() - 1,
            'std_return': final_values.std(),
            'percentile_5': final_values.quantile(0.05) - 1,
            'percentile_95': final_values.quantile(0.95) - 1,
            'mean_sharpe': np.mean(sharpe_ratios) if sharpe_ratios else 0,
            'median_sharpe': np.median(sharpe_ratios) if sharpe_ratios else 0
        }

# ==================================================
# VISUALIZATION
# ==================================================

class Visualizer:
    """Comprehensive visualization suite"""

    @staticmethod
    def plot_regime_overview(price: pd.Series, ma200: pd.Series,
                            regime: pd.Series):
        """Plot regime detection overview"""
        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 8), sharex=True)

        # Price and MA
        ax1.plot(price.index, price, label='Price', linewidth=1.5, alpha=0.8)
        ax1.plot(ma200.index, ma200, label='200 MA', linewidth=1.5,
                linestyle='--', alpha=0.8)
        ax1.set_ylabel('Price', fontsize=11)
        ax1.set_title('Market Regime Detection', fontsize=13, fontweight='bold')
        ax1.legend(loc='upper left')
        ax1.grid(True, alpha=0.3)

        # Regime coloring
        regime_colors = {'Trend': 'green', 'Choppy': 'orange', 'Risk-Off': 'red'}
        for regime_type, color in regime_colors.items():
            mask = regime == regime_type
            ax2.fill_between(regime.index, 0, 1, where=mask,
                           alpha=0.3, color=color, label=regime_type)

        ax2.set_ylabel('Regime', fontsize=11)
        ax2.set_xlabel('Date', fontsize=11)
        ax2.set_ylim([0, 1])
        ax2.legend(loc='upper left')
        ax2.grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    @staticmethod
    def plot_trading_signals(ticker: str, price: pd.Series, signals: Dict):
        """Plot current trading signals"""
        fig, axes = plt.subplots(3, 1, figsize=(14, 10), sharex=True)

        # Price chart
        axes[0].plot(price.index, price, label='Price', linewidth=1.5)

        # Add moving averages if available
        if 'MA_Crossover' in signals:
            ma_fast = price.rolling(Config.MA_FAST).mean()
            ma_slow = price.rolling(Config.MA_SLOW).mean()
            axes[0].plot(ma_fast.index, ma_fast, label=f'MA {Config.MA_FAST}',
                        linestyle='--', alpha=0.7)
            axes[0].plot(ma_slow.index, ma_slow, label=f'MA {Config.MA_SLOW}',
                        linestyle='--', alpha=0.7)

        axes[0].set_ylabel('Price', fontsize=11)
        axes[0].set_title(f'{ticker} - Technical Analysis', fontsize=13, fontweight='bold')
        axes[0].legend(loc='upper left')
        axes[0].grid(True, alpha=0.3)

        # RSI
        rsi = compute_rsi(price, Config.RSI_PERIOD)
        axes[1].plot(rsi.index, rsi, label='RSI', linewidth=1.5, color='purple')
        axes[1].axhline(y=Config.RSI_OVERSOLD, color='green', linestyle='--', alpha=0.5)
        axes[1].axhline(y=Config.RSI_OVERBOUGHT, color='red', linestyle='--', alpha=0.5)
        axes[1].fill_between(rsi.index, Config.RSI_OVERSOLD, Config.RSI_OVERBOUGHT,
                            alpha=0.1, color='gray')
        axes[1].set_ylabel('RSI', fontsize=11)
        axes[1].set_ylim([0, 100])
        axes[1].legend(loc='upper left')
        axes[1].grid(True, alpha=0.3)

        # Bollinger Bands
        upper, middle, lower = compute_bollinger_bands(price, Config.BB_PERIOD, Config.BB_STD)
        axes[2].plot(price.index, price, label='Price', linewidth=1.5)
        axes[2].plot(upper.index, upper, label='Upper BB', linestyle='--', alpha=0.7, color='red')
        axes[2].plot(middle.index, middle, label='Middle BB', linestyle='--', alpha=0.7, color='blue')
        axes[2].plot(lower.index, lower, label='Lower BB', linestyle='--', alpha=0.7, color='green')
        axes[2].fill_between(upper.index, lower, upper, alpha=0.1, color='gray')
        axes[2].set_ylabel('Price', fontsize=11)
        axes[2].set_xlabel('Date', fontsize=11)
        axes[2].legend(loc='upper left')
        axes[2].grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    @staticmethod
    def plot_equity_curves(returns_dict: Dict[str, pd.Series],
                          title: str = "Equity Curves"):
        """Plot multiple equity curves"""
        fig, ax = plt.subplots(figsize=(14, 7))

        for name, returns in returns_dict.items():
            equity = (1 + returns).cumprod()
            ax.plot(equity.index, equity, label=name, linewidth=2, alpha=0.8)

        ax.set_ylabel('Equity (Initial = 1.0)', fontsize=11)
        ax.set_xlabel('Date', fontsize=11)
        ax.set_title(title, fontsize=13, fontweight='bold')
        ax.legend(loc='upper left')
        ax.grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    @staticmethod
    def plot_drawdowns(returns_dict: Dict[str, pd.Series]):
        """Plot drawdown comparison"""
        fig, ax = plt.subplots(figsize=(14, 6))

        for name, returns in returns_dict.items():
            dd = PerformanceAnalytics.get_drawdown_series(returns)
            ax.plot(dd.index, dd * 100, label=name, linewidth=2, alpha=0.8)

        ax.set_ylabel('Drawdown (%)', fontsize=11)
        ax.set_xlabel('Date', fontsize=11)
        ax.set_title('Drawdown Comparison', fontsize=13, fontweight='bold')
        ax.legend(loc='lower left')
        ax.grid(True, alpha=0.3)
        ax.fill_between(ax.get_xlim(), -100, 0, alpha=0.1, color='red')

        plt.tight_layout()
        plt.show()

    @staticmethod
    def plot_rolling_metrics(returns_dict: Dict[str, pd.Series], window: int = 252):
        """Plot rolling Sharpe ratio"""
        fig, ax = plt.subplots(figsize=(14, 6))

        for name, returns in returns_dict.items():
            rolling_sharpe = PerformanceAnalytics.rolling_sharpe(returns, window)
            ax.plot(rolling_sharpe.index, rolling_sharpe, label=name,
                   linewidth=2, alpha=0.8)

        ax.axhline(y=0, color='black', linestyle='--', alpha=0.5)
        ax.axhline(y=1, color='green', linestyle=':', alpha=0.5)
        ax.set_ylabel('Rolling Sharpe Ratio', fontsize=11)
        ax.set_xlabel('Date', fontsize=11)
        ax.set_title(f'{window}-Day Rolling Sharpe Ratio', fontsize=13,
                    fontweight='bold')
        ax.legend(loc='upper left')
        ax.grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    @staticmethod
    def plot_monte_carlo(mc_simulator: MonteCarloSimulator):
        """Plot Monte Carlo simulation results"""
        sims = mc_simulator.run()
        equity_curves = (1 + sims).cumprod()

        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))

        # Equity curves
        for col in equity_curves.columns[:100]:  # Plot first 100
            ax1.plot(equity_curves.index, equity_curves[col],
                    color='blue', alpha=0.05, linewidth=0.5)

        median_curve = equity_curves.median(axis=1)
        ax1.plot(equity_curves.index, median_curve,
                color='red', linewidth=2, label='Median')
        ax1.set_ylabel('Equity', fontsize=11)
        ax1.set_xlabel('Days', fontsize=11)
        ax1.set_title('Monte Carlo Simulation Paths', fontsize=12, fontweight='bold')
        ax1.legend()
        ax1.grid(True, alpha=0.3)

        # Distribution of final returns
        final_returns = (equity_curves.iloc[-1] - 1) * 100
        ax2.hist(final_returns, bins=50, alpha=0.7, edgecolor='black')
        ax2.axvline(final_returns.median(), color='red', linestyle='--',
                   linewidth=2, label=f'Median: {final_returns.median():.1f}%')
        ax2.set_xlabel('Return (%)', fontsize=11)
        ax2.set_ylabel('Frequency', fontsize=11)
        ax2.set_title('Distribution of Final Returns', fontsize=12, fontweight='bold')
        ax2.legend()
        ax2.grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    @staticmethod
    def plot_strategy_allocation(regime: pd.Series):
        """Plot regime allocation over time"""
        regime_counts = regime.value_counts()

        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

        # Pie chart
        colors = {'Trend': 'green', 'Choppy': 'orange', 'Risk-Off': 'red'}
        ax1.pie(regime_counts, labels=regime_counts.index, autopct='%1.1f%%',
               colors=[colors.get(r, 'gray') for r in regime_counts.index],
               startangle=90)
        ax1.set_title('Regime Distribution', fontsize=12, fontweight='bold')

        # Time series
        regime_numeric = regime.map({'Trend': 2, 'Choppy': 1, 'Risk-Off': 0})
        ax2.plot(regime_numeric.index, regime_numeric, linewidth=0.5, alpha=0.5)
        ax2.fill_between(regime_numeric.index, 0, regime_numeric, alpha=0.3)
        ax2.set_yticks([0, 1, 2])
        ax2.set_yticklabels(['Risk-Off', 'Choppy', 'Trend'])
        ax2.set_xlabel('Date', fontsize=11)
        ax2.set_title('Regime Over Time', fontsize=12, fontweight='bold')
        ax2.grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

# ==================================================
# REPORTING
# ==================================================

class PerformanceReport:
    """Generate comprehensive performance report"""

    @staticmethod
    def print_metrics(metrics: Dict[str, float], title: str = "Performance Metrics"):
        """Print formatted metrics"""
        print(f"\n{'='*60}")
        print(f"{title:^60}")
        print(f"{'='*60}")
        print(f"Total Return:        {metrics['total_return']:>10.2%}")
        print(f"CAGR:                {metrics['cagr']:>10.2%}")
        print(f"Volatility:          {metrics['volatility']:>10.2%}")
        print(f"Sharpe Ratio:        {metrics['sharpe']:>10.2f}")
        print(f"Sortino Ratio:       {metrics['sortino']:>10.2f}")
        print(f"Calmar Ratio:        {metrics['calmar']:>10.2f}")
        print(f"Max Drawdown:        {metrics['max_drawdown']:>10.2%}")
        print(f"Win Rate:            {metrics['win_rate']:>10.2%}")
        print(f"Profit Factor:       {metrics['profit_factor']:>10.2f}")
        print(f"VaR (95%):           {metrics['var_95']:>10.2%}")
        print(f"CVaR (95%):          {metrics['cvar_95']:>10.2%}")
        print(f"{'='*60}\n")

    @staticmethod
    def comparison_table(metrics_dict: Dict[str, Dict[str, float]]):
        """Print comparison table of multiple strategies"""
        df = pd.DataFrame(metrics_dict).T

        # Format percentages
        pct_cols = ['total_return', 'cagr', 'volatility', 'max_drawdown',
                    'win_rate', 'var_95', 'cvar_95']
        for col in pct_cols:
            if col in df.columns:
                df[col] = df[col].apply(lambda x: f"{x:.2%}")

        # Format ratios
        ratio_cols = ['sharpe', 'sortino', 'calmar', 'profit_factor']
        for col in ratio_cols:
            if col in df.columns:
                df[col] = df[col].apply(lambda x: f"{x:.2f}")

        print("\n" + "="*100)
        print("STRATEGY COMPARISON")
        print("="*100)
        print(df.to_string())
        print("="*100 + "\n")

# ==================================================
# USER INPUT INTERFACE
# ==================================================

class UserInterface:
    """Handle user input and interaction"""

    @staticmethod
    def get_ticker_input() -> str:
        """Get ticker symbol from user"""
        while True:
            ticker = input("\nEnter ticker symbol (or 'portfolio' for multi-asset analysis): ").strip().upper()

            if ticker == 'PORTFOLIO':
                return ticker

            if ticker:
                is_valid, message = DataManager.validate_ticker(ticker)
                print(message)

                if is_valid:
                    return ticker
                else:
                    retry = input("Would you like to try another ticker? (y/n): ").strip().lower()
                    if retry != 'y':
                        return None
            else:
                print("Please enter a valid ticker symbol.")

    @staticmethod
    def get_portfolio_tickers() -> List[str]:
        """Get list of tickers for portfolio analysis"""
        print("\nEnter ticker symbols for portfolio analysis (comma-separated):")
        print("Example: SPY,QQQ,IWM,EFA,EEM")

        while True:
            tickers_input = input("Tickers: ").strip().upper()
            tickers = [t.strip() for t in tickers_input.split(',') if t.strip()]

            if len(tickers) < 2:
                print("Please enter at least 2 tickers for portfolio analysis.")
                continue

            # Validate all tickers
            valid_tickers = []
            for ticker in tickers:
                is_valid, message = DataManager.validate_ticker(ticker)
                print(f"{ticker}: {message}")
                if is_valid:
                    valid_tickers.append(ticker)

            if len(valid_tickers) >= 2:
                return valid_tickers
            else:
                print("Not enough valid tickers. Please try again.")

    @staticmethod
    def get_weighting_method() -> str:
        """Get portfolio weighting method"""
        print("\nSelect portfolio weighting method:")
        print("1. Equal Weight (1/N allocation)")
        print("2. Volatility Scaled (inverse volatility)")
        print("3. Risk Parity (equal risk contribution)")
        print("4. Momentum Weighted (favor recent winners)")

        method_map = {
            '1': 'equal_weight',
            '2': 'vol_scaled',
            '3': 'risk_parity',
            '4': 'momentum'
        }

        while True:
            choice = input("Enter choice (1/2/3/4, default: 2): ").strip()
            if not choice:
                return 'vol_scaled'  # Default
            if choice in method_map:
                return method_map[choice]
            print("Invalid choice. Please enter 1, 2, 3, or 4.")

    @staticmethod
    def get_analysis_mode() -> str:
        """Get analysis mode from user"""
        print("\nSelect analysis mode:")
        print("1. Current Trading Signals Only")
        print("2. Full Backtest Analysis")
        print("3. Both Signals and Backtest")
        print("4. Enhanced Backtest (Portfolio-level with costs)")
        print("5. Walk-Forward Analysis (Train/Test with re-optimization)")
        print("6. Machine Learning (Linear/Logistic Regression)")
        print("7. Market Regime Analysis (Volatility/Trend Detection)")

        while True:
            choice = input("Enter choice (1/2/3/4/5/6/7): ").strip()
            if choice in ['1', '2', '3', '4', '5', '6', '7']:
                return choice
            if not choice:
                print("No input received. Please enter a number 1-7.")
            else:
                print(f"Invalid choice '{choice}'. Please enter 1, 2, 3, 4, 5, 6, or 7.")

    @staticmethod
    def get_date_range() -> Tuple[str, Optional[str]]:
        """Get custom date range from user"""
        use_custom = input("\nUse custom date range? (y/n, default: n): ").strip().lower()

        if use_custom == 'y':
            start_date = input(f"Start date (YYYY-MM-DD, default: {Config.START_DATE}): ").strip()
            start_date = start_date if start_date else Config.START_DATE

            end_date = input("End date (YYYY-MM-DD, default: today): ").strip()
            end_date = end_date if end_date else None

            return start_date, end_date

        return Config.START_DATE, None

# ==================================================
# MAIN EXECUTION FUNCTIONS
# ==================================================

# ==================================================
# ENHANCED BACKTESTING FUNCTIONS
# ==================================================

def run_enhanced_backtest(ticker: str, start_date: str, end_date: Optional[str] = None,
                         initial_capital: float = 100000) -> Dict:
    """
    Run backtest using the comprehensive BacktestEngine

    Returns detailed results including:
    - Portfolio performance
    - Transaction costs breakdown
    - Risk metrics
    - Trade-by-trade analysis
    """
    print("\n" + "="*80)
    print(f"ENHANCED BACKTEST - {ticker}")
    print("="*80)

    # Fetch data
    prices, returns = DataManager.fetch_data([ticker], start_date, end_date)
    price_series = prices[ticker] if isinstance(prices, pd.DataFrame) else prices
    return_series = returns[ticker] if isinstance(returns, pd.DataFrame) else returns

    # Detect regime
    detector = RegimeDetector(price_series, return_series)
    regime = detector.detect_regime()

    # Generate signals using MA strategy
    ma_strategy = MovingAverageTrend(price_series, Config.MA_FAST, Config.MA_SLOW)
    ma_signal = ma_strategy.generate_signal()

    # Convert to DataFrame format for backtester
    prices_df = pd.DataFrame({ticker: price_series})
    signals_df = pd.DataFrame({ticker: ma_signal})

    # Create risk manager with custom parameters
    risk_mgr = RiskManager(
        max_position_size=0.25,
        max_portfolio_leverage=1.0,
        max_drawdown_limit=0.20,
        stop_loss_pct=0.05
    )

    # Create cost model
    cost_model = TransactionCostModel(
        commission=0.001,  # 10 bps
        spread_pct=0.0005,  # 5 bps
        market_impact_coef=0.1
    )

    # Run backtest
    print("\nRunning enhanced backtest with:")
    print(f"  Initial Capital: ${initial_capital:,.0f}")
    print(f"  Max Position Size: {risk_mgr.max_position_size:.1%}")
    print(f"  Stop Loss: {risk_mgr.stop_loss_pct:.1%}")
    print(f"  Transaction Costs: Commission={cost_model.commission:.2%}, Spread={cost_model.spread_pct:.2%}")

    engine = BacktestEngine(initial_capital, risk_mgr, cost_model)
    portfolio = engine.run_backtest(prices_df, signals_df)

    # Get performance summary
    performance = portfolio.get_performance_summary()

    # Print results
    print("\n" + "="*80)
    print("ENHANCED BACKTEST RESULTS")
    print("="*80)
    print(f"Initial Capital:     ${performance.get('initial_capital', 0):>12,.0f}")
    print(f"Final Value:         ${performance.get('final_value', 0):>12,.0f}")
    print(f"Total Return:        {performance.get('total_return', 0):>12.2%}")
    print(f"CAGR:                {performance.get('cagr', 0):>12.2%}")
    print(f"\nTotal Trades:        {performance.get('total_trades', 0):>12.0f}")
    print(f"Winning Trades:      {performance.get('winning_trades', 0):>12.0f}")
    print(f"Losing Trades:       {performance.get('losing_trades', 0):>12.0f}")
    print(f"Win Rate:            {performance.get('win_rate', 0):>12.2%}")
    print(f"\nGross P&L:           ${performance.get('total_pnl', 0):>12,.0f}")
    print(f"Transaction Costs:   ${performance.get('total_costs', 0):>12,.0f}")
    print(f"Net P&L:             ${performance.get('net_pnl', 0):>12,.0f}")
    print(f"\nSharpe Ratio:        {performance.get('sharpe', 0):>12.2f}")
    print(f"Sortino Ratio:       {performance.get('sortino', 0):>12.2f}")
    print(f"Max Drawdown:        {performance.get('max_drawdown', 0):>12.2%}")
    print(f"Calmar Ratio:        {performance.get('calmar', 0):>12.2f}")
    print("="*80)

    # Plot equity curve
    if portfolio.equity_curve:
        equity_df = pd.DataFrame(portfolio.equity_curve)
        equity_df.set_index('date', inplace=True)

        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 8), sharex=True)

        # Equity curve
        ax1.plot(equity_df.index, equity_df['value'], label='Portfolio Value', linewidth=2)
        ax1.axhline(y=initial_capital, color='gray', linestyle='--', alpha=0.5, label='Initial Capital')
        ax1.set_ylabel('Portfolio Value ($)', fontsize=11)
        ax1.set_title(f'{ticker} - Enhanced Backtest Results', fontsize=13, fontweight='bold')
        ax1.legend(loc='upper left')
        ax1.grid(True, alpha=0.3)

        # Drawdown
        equity_peak = equity_df['value'].cummax()
        drawdown = (equity_df['value'] - equity_peak) / equity_peak
        ax2.fill_between(equity_df.index, 0, drawdown * 100, alpha=0.3, color='red')
        ax2.plot(equity_df.index, drawdown * 100, color='red', linewidth=1)
        ax2.set_ylabel('Drawdown (%)', fontsize=11)
        ax2.set_xlabel('Date', fontsize=11)
        ax2.grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    return {
        'portfolio': portfolio,
        'performance': performance,
        'engine': engine
    }

# ==================================================
# ANALYSIS FUNCTIONS
# ==================================================

# ==================================================
# MULTI-ASSET ANALYSIS FUNCTION
# ==================================================

# ==================================================
# WALK-FORWARD ANALYSIS FUNCTION
# ==================================================

# ==================================================
# FACTOR ANALYSIS FUNCTION
# ==================================================

def run_factor_analysis(tickers: List[str], start_date: str,
                       end_date: Optional[str] = None,
                       include_value: bool = True,
                       method: str = 'long_only',
                       top_n: int = 5) -> Dict:
    """
    Run multi-factor analysis and portfolio construction

    Args:
        tickers: List of tickers to analyze
        start_date: Start date
        end_date: End date (optional)
        include_value: Whether to include value factor (needs fundamentals)
        method: 'long_only', 'long_short', or 'ranked'
        top_n: Number of top assets to hold

    Returns:
        Dictionary with results
    """
    print("\n" + "="*80)
    print("MULTI-FACTOR ANALYSIS")
    print("="*80)
    print(f"Assets: {', '.join(tickers)}")
    print(f"Factors: Momentum, Volatility" + (", Value" if include_value else ""))

    # Fetch price data
    print("\nFetching price data...")
    try:
        prices, returns = DataManager.fetch_data(tickers, start_date, end_date)
        print(f"Data loaded: {len(prices)} days")
    except Exception as e:
        print(f"Error fetching data: {e}")
        return {}

    # Fetch fundamentals if including value factor
    fundamentals = None
    if include_value:
        value_factor = ValueFactor()
        fundamentals = value_factor.fetch_fundamentals(tickers)

    # Create factor model
    factors = [
        MomentumFactor(lookback_periods=[21, 63, 126, 252]),
        VolatilityFactor(lookback_periods=[21, 63, 252])
    ]

    if include_value and fundamentals:
        factors.append(ValueFactor())

    model = MultiFactorModel(factors=factors)

    # Calculate factor scores
    factor_scores = model.calculate_factor_scores(prices, returns, fundamentals)

    # Print factor analysis
    model.print_factor_analysis()

    # Combine factors
    print("\nCombining factors...")
    combined_scores = model.combine_factors(method='equal_weight')

    # Generate portfolio
    print("\nGenerating portfolio...")
    if method == 'long_short_decile':
        weights = model.generate_portfolio_weights(
            combined_scores, method,
            long_allocation=1.0, short_allocation=1.0
        )
        # Print decile analysis
        model.print_decile_analysis()
    else:
        weights = model.generate_portfolio_weights(combined_scores, method, top_n)

    print(f"\n{'='*80}")
    print(f"FACTOR-BASED PORTFOLIO ({method.upper()})")
    print(f"{'='*80}")

    # Show long positions
    long_positions = weights[weights > 0].sort_values(ascending=False)
    if len(long_positions) > 0:
        print(f"\nLONG Positions ({len(long_positions)}):")

        for ticker, weight in long_positions.head(top_n if method != 'long_short_decile' else len(long_positions)).items():
            # Get factor scores for this ticker
            momentum = factor_scores.get('Momentum', pd.Series()).get(ticker, 0)
            volatility = factor_scores.get('Volatility', pd.Series()).get(ticker, 0)
            value = factor_scores.get('Value', pd.Series()).get(ticker, 0) if 'Value' in factor_scores else 0

            print(f"\n  {ticker}: {weight:.2%}")
            print(f"    Momentum: {momentum:>6.2f}")
            print(f"    Volatility: {volatility:>6.2f}")
            if include_value:
                print(f"    Value: {value:>6.2f}")
            print(f"    Combined: {combined_scores[ticker]:>6.2f}")

    # Show short positions if any
    short_positions = weights[weights < 0].sort_values()
    if len(short_positions) > 0:
        print(f"\nSHORT Positions ({len(short_positions)}):")

        for ticker, weight in short_positions.items():
            momentum = factor_scores.get('Momentum', pd.Series()).get(ticker, 0)
            volatility = factor_scores.get('Volatility', pd.Series()).get(ticker, 0)
            value = factor_scores.get('Value', pd.Series()).get(ticker, 0) if 'Value' in factor_scores else 0

            print(f"\n  {ticker}: {weight:.2%}")
            print(f"    Momentum: {momentum:>6.2f}")
            print(f"    Volatility: {volatility:>6.2f}")
            if include_value:
                print(f"    Value: {value:>6.2f}")
            print(f"    Combined: {combined_scores[ticker]:>6.2f}")

    # Backtest the portfolio
    print("\n" + "="*80)
    print("BACKTESTING FACTOR PORTFOLIO")
    print("="*80)

    portfolio_returns = (returns * weights).sum(axis=1)

    # Calculate performance
    metrics = PerformanceAnalytics.calculate_metrics(portfolio_returns)

    print(f"\nFactor Portfolio Performance:")
    print(f"  Total Return:    {metrics['total_return']:>10.2%}")
    print(f"  CAGR:            {metrics['cagr']:>10.2%}")
    print(f"  Sharpe Ratio:    {metrics['sharpe']:>10.2f}")
    print(f"  Max Drawdown:    {metrics['max_drawdown']:>10.2%}")
    print(f"  Win Rate:        {metrics['win_rate']:>10.2%}")

    # Compare to equal-weight
    equal_weight = pd.Series(1.0/len(tickers), index=returns.columns)
    equal_returns = (returns * equal_weight).sum(axis=1)
    equal_metrics = PerformanceAnalytics.calculate_metrics(equal_returns)

    print(f"\nEqual-Weight Benchmark:")
    print(f"  Total Return:    {equal_metrics['total_return']:>10.2%}")
    print(f"  CAGR:            {equal_metrics['cagr']:>10.2%}")
    print(f"  Sharpe Ratio:    {equal_metrics['sharpe']:>10.2f}")

    print(f"\nFactor Advantage:")
    print(f"  Sharpe Improvement: {metrics['sharpe'] - equal_metrics['sharpe']:+.2f}")
    print(f"  CAGR Improvement:   {(metrics['cagr'] - equal_metrics['cagr']):+.2%}")

    # Visualize
    import matplotlib.pyplot as plt
    import seaborn as sns

    fig, axes = plt.subplots(3, 1, figsize=(14, 10))

    # 1. Factor scores heatmap
    scores_df = pd.DataFrame(factor_scores)
    scores_df_sorted = scores_df.sort_values('Momentum', ascending=False)

    sns.heatmap(scores_df_sorted.T, annot=True, fmt='.2f', cmap='RdYlGn',
                center=0, ax=axes[0], cbar_kws={'label': 'Z-Score'})
    axes[0].set_title('Factor Scores by Asset', fontweight='bold')
    axes[0].set_xlabel('Asset')
    axes[0].set_ylabel('Factor')

    # 2. Cumulative returns comparison
    factor_equity = (1 + portfolio_returns).cumprod()
    equal_equity = (1 + equal_returns).cumprod()

    axes[1].plot(factor_equity.index, factor_equity.values,
                label='Factor Portfolio', linewidth=2)
    axes[1].plot(equal_equity.index, equal_equity.values,
                label='Equal Weight', linewidth=2, alpha=0.7)
    axes[1].set_ylabel('Cumulative Return')
    axes[1].set_title('Factor Portfolio vs Equal Weight', fontweight='bold')
    axes[1].legend()
    axes[1].grid(True, alpha=0.3)

    # 3. Portfolio weights
    weights_plot = weights[weights > 0].sort_values(ascending=True)
    weights_plot.plot(kind='barh', ax=axes[2], color='steelblue')
    axes[2].set_xlabel('Weight')
    axes[2].set_title(f'Factor Portfolio Allocation (Top {top_n})', fontweight='bold')
    axes[2].grid(True, alpha=0.3, axis='x')

    plt.tight_layout()
    plt.show()

    return {
        'model': model,
        'factor_scores': factor_scores,
        'combined_scores': combined_scores,
        'weights': weights,
        'portfolio_returns': portfolio_returns,
        'metrics': metrics
    }

# ==================================================
# WALK-FORWARD ANALYSIS FUNCTION
# ==================================================

# ==================================================
# MACHINE LEARNING ANALYSIS FUNCTION
# ==================================================

# ==================================================
# REGIME ANALYSIS FUNCTION
# ==================================================

def run_regime_analysis(ticker: str, start_date: str, end_date: Optional[str] = None) -> Dict:
    """
    Run comprehensive market regime analysis

    Args:
        ticker: Ticker symbol
        start_date: Start date
        end_date: End date (optional)

    Returns:
        Dictionary with regime analysis results
    """
    print("\n" + "="*80)
    print(f"MARKET REGIME ANALYSIS - {ticker}")
    print("="*80)

    # Fetch data
    print(f"\nFetching data...")
    try:
        prices, returns = DataManager.fetch_data([ticker], start_date, end_date)
        price_series = prices[ticker] if isinstance(prices, pd.DataFrame) else prices
        return_series = returns[ticker] if isinstance(returns, pd.DataFrame) else returns

        print(f"Data loaded: {len(price_series)} days")
    except Exception as e:
        print(f"Error fetching data: {e}")
        return {}

    # Create regime detector
    detector = MarketRegimeDetector(
        price=price_series,
        returns=return_series,
        vol_lookback=20,
        trend_lookback=50,
        confirm_days=3
    )

    # Get regimes
    vol_regime = detector.detect_volatility_regime()
    trend_regime = detector.detect_trend_regime()
    combined_regime = detector.detect_combined_regime()

    # Current regime
    current = detector.get_current_regime()

    print("\n" + "="*80)
    print("CURRENT MARKET REGIME")
    print("="*80)
    print(f"Volatility Regime:  {current['volatility']}")
    print(f"Trend Regime:       {current['trend']}")
    print(f"Combined State:     {current['combined']}")
    print(f"\nKey Indicators:")
    print(f"  ADX (Trend Strength):    {current['adx']:.1f}")
    print(f"  Realized Volatility:     {current['realized_vol']:.1f}%")
    print(f"  R² (Trend Quality):      {current['r_squared']:.3f}")

    # Regime statistics
    stats = detector.get_regime_statistics()

    print("\n" + "="*80)
    print("REGIME DISTRIBUTION (Historical)")
    print("="*80)

    print("\nVolatility Regimes:")
    vol_stats = stats[['Volatility Regime', 'Volatility Regime %']].dropna()
    for idx, row in vol_stats.iterrows():
        print(f"  {idx:15s}: {row['Volatility Regime']:>4.0f} days ({row['Volatility Regime %']:>5.1f}%)")

    print("\nTrend Regimes:")
    trend_stats = stats[['Trend Regime', 'Trend Regime %']].dropna()
    for idx, row in trend_stats.iterrows():
        print(f"  {idx:15s}: {row['Trend Regime']:>4.0f} days ({row['Trend Regime %']:>5.1f}%)")

    print("\nCombined Market States:")
    combined_stats = stats[['Combined Regime', 'Combined Regime %']].dropna()
    for idx, row in combined_stats.iterrows():
        print(f"  {idx:20s}: {row['Combined Regime']:>4.0f} days ({row['Combined Regime %']:>5.1f}%)")

    # Trading recommendations by regime
    print("\n" + "="*80)
    print("TRADING RECOMMENDATIONS BY REGIME")
    print("="*80)

    regime_strategies = {
        'High Vol': {
            'description': 'High volatility period',
            'strategies': ['Reduce position sizes', 'Use wider stops', 'Consider options strategies'],
            'avoid': ['Tight stops', 'Leverage', 'Buy-and-hold without stops']
        },
        'Low Vol': {
            'description': 'Low volatility period',
            'strategies': ['Normal position sizes', 'Trend-following works well', 'Lower risk'],
            'avoid': ['Expecting big moves', 'Selling volatility naked']
        },
        'Trending': {
            'description': 'Strong directional movement',
            'strategies': ['Momentum strategies', 'Trend-following', 'Moving average crossovers'],
            'avoid': ['Mean-reversion', 'Range trading', 'Fading moves']
        },
        'Mean-Reverting': {
            'description': 'Oscillating around mean',
            'strategies': ['Mean-reversion strategies', 'RSI/Bollinger', 'Range trading'],
            'avoid': ['Momentum strategies', 'Breakout trading', 'Trend-following']
        }
    }

    current_vol = current['volatility']
    current_trend = current['trend']

    if current_vol in regime_strategies:
        strat = regime_strategies[current_vol]
        print(f"\nFor {current_vol}:")
        print(f"  {strat['description']}")
        print(f"  Best strategies:")
        for s in strat['strategies']:
            print(f"    ✓ {s}")
        print(f"  Avoid:")
        for a in strat['avoid']:
            print(f"    ✗ {a}")

    if current_trend in regime_strategies:
        strat = regime_strategies[current_trend]
        print(f"\nFor {current_trend}:")
        print(f"  {strat['description']}")
        print(f"  Best strategies:")
        for s in strat['strategies']:
            print(f"    ✓ {s}")
        print(f"  Avoid:")
        for a in strat['avoid']:
            print(f"    ✗ {a}")

    # Regime persistence analysis
    print("\n" + "="*80)
    print("REGIME PERSISTENCE ANALYSIS")
    print("="*80)

    # Calculate average regime duration
    def calculate_regime_durations(regime_series):
        durations = []
        current_regime = regime_series.iloc[0]
        duration = 1

        for i in range(1, len(regime_series)):
            if regime_series.iloc[i] == current_regime:
                duration += 1
            else:
                durations.append((current_regime, duration))
                current_regime = regime_series.iloc[i]
                duration = 1

        durations.append((current_regime, duration))

        # Group by regime type
        regime_durations = {}
        for regime, dur in durations:
            if regime not in regime_durations:
                regime_durations[regime] = []
            regime_durations[regime].append(dur)

        return {k: {'avg': np.mean(v), 'median': np.median(v), 'max': max(v)}
                for k, v in regime_durations.items()}

    vol_durations = calculate_regime_durations(vol_regime)
    trend_durations = calculate_regime_durations(trend_regime)

    print("\nAverage Regime Durations:")
    print("\nVolatility:")
    for regime, stats in vol_durations.items():
        print(f"  {regime:15s}: Avg {stats['avg']:>5.1f} days, Median {stats['median']:>5.1f}, Max {stats['max']:>5.0f}")

    print("\nTrend:")
    for regime, stats in trend_durations.items():
        print(f"  {regime:15s}: Avg {stats['avg']:>5.1f} days, Median {stats['median']:>5.1f}, Max {stats['max']:>5.0f}")

    # Plot comprehensive analysis
    print("\nGenerating regime analysis charts...")
    detector.plot_regime_analysis()

    return {
        'detector': detector,
        'volatility_regime': vol_regime,
        'trend_regime': trend_regime,
        'combined_regime': combined_regime,
        'current_regime': current,
        'statistics': stats,
        'durations': {
            'volatility': vol_durations,
            'trend': trend_durations
        }
    }

# ==================================================
# MACHINE LEARNING ANALYSIS FUNCTION
# ==================================================

def run_ml_analysis(ticker: str, start_date: str, end_date: Optional[str] = None,
                   target_horizon: int = 5, model_type: str = 'both') -> Dict:
    """
    Run machine learning analysis

    Args:
        ticker: Ticker symbol
        start_date: Start date
        end_date: End date (optional)
        target_horizon: Days ahead to predict
        model_type: 'linear', 'logistic', or 'both'

    Returns:
        Dictionary with model results
    """
    print("\n" + "="*80)
    print(f"MACHINE LEARNING ANALYSIS - {ticker}")
    print("="*80)
    print(f"Target Horizon: {target_horizon} days")
    print(f"Model Type: {model_type}")

    # Fetch data
    print(f"\nFetching data...")
    try:
        prices, returns = DataManager.fetch_data([ticker], start_date, end_date)
        price_series = prices[ticker] if isinstance(prices, pd.DataFrame) else prices
        return_series = returns[ticker] if isinstance(returns, pd.DataFrame) else returns

        print(f"Data loaded: {len(price_series)} days")
    except Exception as e:
        print(f"Error fetching data: {e}")
        return {}

    results = {}

    # Linear Regression
    if model_type in ['linear', 'both']:
        print("\n" + "="*80)
        print("LINEAR REGRESSION - Predicting Return Magnitude")
        print("="*80)

        lr_model = LinearRegressionPredictor(target_horizon=target_horizon)
        lr_metrics = lr_model.train(price_series, return_series)

        if lr_metrics['test_r2'] > 0:
            # Get predictions
            predictions = lr_model.predict(price_series, return_series)

            # Generate signals from predictions
            signals = pd.Series(0, index=predictions.index)
            signals[predictions > 0.01] = 1  # Buy if predicted return > 1%
            signals[predictions < -0.01] = -1  # Sell if predicted return < -1%

            # Backtest
            strategy_returns = signals.shift(1) * return_series
            strategy_returns = strategy_returns.dropna()

            if len(strategy_returns) > 0:
                strategy_metrics = PerformanceAnalytics.calculate_metrics(strategy_returns)

                print(f"\nLinear Regression Strategy Performance:")
                print(f"  Sharpe Ratio: {strategy_metrics['sharpe']:.2f}")
                print(f"  Total Return: {strategy_metrics['total_return']:.2%}")
                print(f"  Win Rate: {strategy_metrics['win_rate']:.2%}")

                results['linear'] = {
                    'model': lr_model,
                    'metrics': lr_metrics,
                    'predictions': predictions,
                    'signals': signals,
                    'strategy_returns': strategy_returns,
                    'strategy_metrics': strategy_metrics
                }

    # Logistic Regression
    if model_type in ['logistic', 'both']:
        print("\n" + "="*80)
        print("LOGISTIC REGRESSION - Predicting Direction")
        print("="*80)

        log_model = LogisticRegressionPredictor(target_horizon=target_horizon, threshold=0.0)
        log_metrics = log_model.train(price_series, return_series)

        if log_metrics['accuracy'] > 0:
            # Generate signals with confidence threshold
            signals = log_model.generate_signals(
                price_series, return_series,
                confidence_threshold=0.6
            )

            # Backtest
            strategy_returns = signals.shift(1) * return_series
            strategy_returns = strategy_returns.dropna()

            if len(strategy_returns) > 0:
                strategy_metrics = PerformanceAnalytics.calculate_metrics(strategy_returns)

                print(f"\nLogistic Regression Strategy Performance:")
                print(f"  Sharpe Ratio: {strategy_metrics['sharpe']:.2f}")
                print(f"  Total Return: {strategy_metrics['total_return']:.2%}")
                print(f"  Win Rate: {strategy_metrics['win_rate']:.2%}")

                results['logistic'] = {
                    'model': log_model,
                    'metrics': log_metrics,
                    'signals': signals,
                    'strategy_returns': strategy_returns,
                    'strategy_metrics': strategy_metrics
                }

    # Comparison
    if len(results) == 2:
        print("\n" + "="*80)
        print("MODEL COMPARISON")
        print("="*80)

        comparison = pd.DataFrame({
            'Linear Reg': results['linear']['strategy_metrics'],
            'Logistic Reg': results['logistic']['strategy_metrics']
        }).T

        print("\nKey Metrics:")
        print(comparison[['total_return', 'sharpe', 'max_drawdown', 'win_rate']])

    # Visualization
    if results:
        import matplotlib.pyplot as plt

        n_plots = len(results)
        fig, axes = plt.subplots(n_plots, 1, figsize=(14, 5*n_plots))

        if n_plots == 1:
            axes = [axes]

        plot_idx = 0

        if 'linear' in results:
            lr_data = results['linear']
            equity = (1 + lr_data['strategy_returns']).cumprod()
            bh_equity = (1 + return_series.loc[equity.index]).cumprod()

            axes[plot_idx].plot(equity.index, equity.values,
                               label='Linear Regression Strategy', linewidth=2)
            axes[plot_idx].plot(bh_equity.index, bh_equity.values,
                               label='Buy & Hold', linewidth=2, alpha=0.7)
            axes[plot_idx].set_title('Linear Regression - Return Prediction', fontweight='bold')
            axes[plot_idx].set_ylabel('Cumulative Return')
            axes[plot_idx].legend()
            axes[plot_idx].grid(True, alpha=0.3)
            plot_idx += 1

        if 'logistic' in results:
            log_data = results['logistic']
            equity = (1 + log_data['strategy_returns']).cumprod()
            bh_equity = (1 + return_series.loc[equity.index]).cumprod()

            axes[plot_idx].plot(equity.index, equity.values,
                               label='Logistic Regression Strategy', linewidth=2)
            axes[plot_idx].plot(bh_equity.index, bh_equity.values,
                               label='Buy & Hold', linewidth=2, alpha=0.7)
            axes[plot_idx].set_title('Logistic Regression - Direction Prediction', fontweight='bold')
            axes[plot_idx].set_ylabel('Cumulative Return')
            axes[plot_idx].set_xlabel('Date')
            axes[plot_idx].legend()
            axes[plot_idx].grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    return results

# ==================================================
# WALK-FORWARD ANALYSIS FUNCTION
# ==================================================

def run_walk_forward_analysis(ticker: str, start_date: str = '2010-01-01',
                              end_date: Optional[str] = None,
                              train_years: int = 8, test_years: int = 4,
                              use_rolling: bool = True) -> Dict:
    """
    Run comprehensive walk-forward analysis

    Default: Train 2010-2018 (8 years), Test 2019-2022 (4 years)

    Args:
        ticker: Ticker symbol
        start_date: Start date for entire analysis
        end_date: End date (optional)
        train_years: Years for training (default 8)
        test_years: Years for testing (default 4)
        use_rolling: True for rolling window, False for anchored

    Returns:
        Dictionary with comprehensive results
    """
    print("\n" + "="*80)
    print(f"WALK-FORWARD ANALYSIS - {ticker}")
    print("="*80)
    print(f"Configuration:")
    print(f"  Training Period: {train_years} years")
    print(f"  Testing Period: {test_years} years")
    print(f"  Window Type: {'Rolling' if use_rolling else 'Anchored'}")
    print(f"  Start Date: {start_date}")

    # Fetch data
    print(f"\nFetching data for {ticker}...")
    try:
        prices, returns = DataManager.fetch_data([ticker], start_date, end_date)
        price_series = prices[ticker] if isinstance(prices, pd.DataFrame) else prices
        return_series = returns[ticker] if isinstance(returns, pd.DataFrame) else returns

        print(f"Data loaded: {len(price_series)} days")

        # Check if we have enough data
        total_years_needed = train_years + test_years
        years_available = (price_series.index[-1] - price_series.index[0]).days / 365.25

        if years_available < total_years_needed:
            print(f"\nWarning: Only {years_available:.1f} years of data available")
            print(f"Need at least {total_years_needed} years for walk-forward analysis")
            print("Adjusting parameters...")

            # Adjust parameters
            if years_available >= 10:
                train_years = 6
                test_years = 2
            elif years_available >= 6:
                train_years = 4
                test_years = 1
            else:
                print("Insufficient data for meaningful walk-forward analysis")
                return {}

            print(f"Adjusted: Train {train_years} years, Test {test_years} years")

    except Exception as e:
        print(f"Error fetching data: {e}")
        return {}

    # Create analyzer
    analyzer = WalkForwardAnalyzer(
        train_years=train_years,
        test_years=test_years,
        anchor=not use_rolling
    )

    # Run analysis
    results = analyzer.run(price_series, return_series, start_date)

    if not results:
        print("\nWalk-forward analysis could not be completed")
        return {}

    # Generate detailed report
    print("\n" + analyzer.get_detailed_report())

    # Plot results
    print("\nGenerating visualizations...")
    analyzer.plot_results()

    # Compare to buy-and-hold
    print("\n" + "="*80)
    print("COMPARISON: Walk-Forward vs Buy & Hold")
    print("="*80)

    if 'oos_returns' in results:
        oos_returns = results['oos_returns']

        # Get buy-and-hold for same period
        bh_returns = return_series.loc[oos_returns.index[0]:oos_returns.index[-1]]
        bh_metrics = PerformanceAnalytics.calculate_metrics(bh_returns)

        wf_metrics = results['overall_metrics']

        comparison = pd.DataFrame({
            'Walk-Forward': wf_metrics,
            'Buy & Hold': bh_metrics
        }).T

        print("\nKey Metrics:")
        print(comparison[['total_return', 'cagr', 'sharpe', 'max_drawdown', 'win_rate']])

        # Highlight improvements
        print(f"\nImprovement:")
        print(f"  Sharpe Ratio: {wf_metrics['sharpe'] - bh_metrics['sharpe']:+.2f}")
        print(f"  Max Drawdown: {wf_metrics['max_drawdown'] - bh_metrics['max_drawdown']:+.2%}")

    return results

# ==================================================
# MULTI-ASSET ANALYSIS FUNCTION
# ==================================================

def run_multi_asset_backtest(tickers: List[str], start_date: str,
                             end_date: Optional[str] = None,
                             weighting_method: str = 'vol_scaled',
                             initial_capital: float = 100000) -> Dict:
    """
    Run comprehensive multi-asset portfolio backtest

    Args:
        tickers: List of ticker symbols
        start_date: Start date
        end_date: End date (optional)
        weighting_method: 'equal_weight', 'vol_scaled', 'risk_parity', or 'momentum'
        initial_capital: Starting capital

    Returns:
        Performance dictionary
    """
    print("\n" + "="*80)
    print("MULTI-ASSET PORTFOLIO BACKTEST")
    print("="*80)

    # Display weighting method info
    method_descriptions = {
        'equal_weight': 'Equal Weight (1/N allocation)',
        'vol_scaled': 'Volatility Scaled (inverse volatility weighting)',
        'risk_parity': 'Risk Parity (equal risk contribution)',
        'momentum': 'Momentum Weighted (favors recent winners)'
    }

    print(f"\nStrategy: {method_descriptions.get(weighting_method, weighting_method)}")
    print(f"Assets: {', '.join(tickers)}")
    print(f"Initial Capital: ${initial_capital:,.0f}")

    # Create manager
    manager = MultiAssetPortfolioManager(
        tickers=tickers,
        initial_capital=initial_capital,
        weighting_method=weighting_method,
        rebalance_frequency='monthly',
        enable_trailing_stops=True,
        max_drawdown=0.20
    )

    # Run backtest
    performance = manager.run_backtest(start_date, end_date)

    # Print results
    manager.print_performance_summary(performance)

    # Visualize
    if manager.portfolio.equity_curve:
        equity_df = pd.DataFrame(manager.portfolio.equity_curve)
        equity_df.set_index('date', inplace=True)

        fig, axes = plt.subplots(3, 1, figsize=(14, 10), sharex=True)

        # Equity curve
        axes[0].plot(equity_df.index, equity_df['value'], linewidth=2, label='Portfolio Value')
        axes[0].axhline(y=initial_capital, color='gray', linestyle='--', alpha=0.5, label='Initial')
        axes[0].set_ylabel('Portfolio Value ($)')
        axes[0].set_title(f'Multi-Asset Portfolio ({weighting_method})', fontweight='bold')
        axes[0].legend()
        axes[0].grid(True, alpha=0.3)

        # Drawdown
        peak = equity_df['value'].cummax()
        drawdown = (equity_df['value'] - peak) / peak * 100
        axes[1].fill_between(equity_df.index, 0, drawdown, alpha=0.3, color='red')
        axes[1].plot(equity_df.index, drawdown, color='red', linewidth=1)
        axes[1].set_ylabel('Drawdown (%)')
        axes[1].grid(True, alpha=0.3)

        # Asset allocation over time (from rebalance history)
        if manager.rebalance_history:
            rebal_df = pd.DataFrame(manager.rebalance_history)
            rebal_df.set_index('date', inplace=True)

            # Extract weights into separate columns
            weight_data = {}
            for ticker in tickers:
                weight_data[ticker] = [r.get(ticker, 0) * 100 for r in rebal_df['weights']]

            weight_df = pd.DataFrame(weight_data, index=rebal_df.index)
            weight_df.plot(kind='area', stacked=True, ax=axes[2], alpha=0.7)
            axes[2].set_ylabel('Allocation (%)')
            axes[2].set_xlabel('Date')
            axes[2].legend(loc='upper left', bbox_to_anchor=(1, 1))
            axes[2].grid(True, alpha=0.3)

        plt.tight_layout()
        plt.show()

    return {
        'manager': manager,
        'performance': performance
    }

# ==================================================
# ANALYSIS FUNCTIONS
# ==================================================

def analyze_single_ticker(ticker: str, start_date: str, end_date: Optional[str] = None,
                         mode: str = '3'):
    """Analyze a single ticker"""

    print("\n" + "="*80)
    print(f"ANALYZING {ticker}")
    print("="*80)

    # Get ticker info
    info = DataManager.get_ticker_info(ticker)
    print(f"\nSecurity Information:")
    print(f"  Name: {info['name']}")
    print(f"  Sector: {info['sector']}")
    print(f"  Industry: {info['industry']}")
    print(f"  Exchange: {info['exchange']}")

    # Fetch data
    print(f"\nDownloading market data from {start_date}...")
    prices, returns = DataManager.fetch_data([ticker], start_date, end_date)

    price_series = prices[ticker] if isinstance(prices, pd.DataFrame) else prices
    return_series = returns[ticker] if isinstance(returns, pd.DataFrame) else returns

    print(f"Data downloaded: {len(prices)} days from {prices.index[0].date()} to {prices.index[-1].date()}")

    # Detect regime early (needed for both modes)
    print("\nDetecting market regimes...")
    detector = RegimeDetector(price_series, return_series, Config.VOL_LOOKBACK,
                             Config.VOL_THRESHOLD, Config.REGIME_CONFIRM_DAYS)
    regime = detector.detect_regime()
    print("Regime detection complete")

    # Generate trading signals if requested
    if mode in ['1', '3']:
        print("\n" + "="*80)
        print("GENERATING TRADING SIGNALS")
        print("="*80)

        signal_gen = TradingSignalGenerator(ticker, price_series, return_series)
        signals = signal_gen.generate_all_signals()
        signal_gen.print_signals()

        # Visualize signals
        viz = Visualizer()
        viz.plot_trading_signals(ticker, price_series, signals)

    # Run backtest if requested
    if mode in ['2', '3']:
        print("\n" + "="*80)
        print("RUNNING BACKTEST ANALYSIS")
        print("="*80)

        # ADVANCED FEATURES INTEGRATION

        # Multi-timeframe analysis
        print("\nPerforming multi-timeframe analysis...")
        try:
            mtf_data = DataManager.fetch_multi_timeframe(ticker, start_date)
            mtf_analyzer = MultiTimeframeAnalyzer(ticker, mtf_data)
            alignment_score, alignment_details = mtf_analyzer.get_alignment_score()
            consensus = mtf_analyzer.get_consensus_signal()

            print(f"Timeframe Alignment Score: {alignment_score:.2%}")
            print(f"Consensus Signal: {consensus}")

            print("\nTimeframe Details:")
            for tf, details in alignment_details.items():
                print(f"  {tf.upper()}: {details['signal']} ({details['trend']})")
        except Exception as e:
            print(f"Multi-timeframe analysis unavailable: {str(e)}")
            alignment_score = 0.5
            consensus = "UNKNOWN"

        # ML regime prediction
        print("\nTraining ML regime predictor...")
        try:
            ml_predictor = MLRegimePredictor()
            ml_accuracy = ml_predictor.train(price_series, return_series, regime)

            if ml_accuracy > 0:
                print(f"ML Model Accuracy: {ml_accuracy:.2%}")
                next_regime, confidence = ml_predictor.predict_next_regime(price_series, return_series)
                print(f"\nPredicted Next Regime: {next_regime} (Confidence: {confidence:.2%})")
            else:
                print("ML training skipped - insufficient data (need 1000+ samples)")

        except Exception as e:
            print(f"ML prediction unavailable: {str(e)}")
            print("Continuing without ML predictions...")

        # Parameter optimization
        optimize = input("\nOptimize strategy parameters? (y/n, default: n): ").strip().lower()
        if optimize == 'y':
            print("\nOptimizing parameters (this may take a moment)...")
            try:
                optimizer = ParameterOptimizer(price_series, return_series)
                optimized_params = optimizer.optimize_all_strategies()

                print("\nOptimal Parameters Found:")
                for strategy, params in optimized_params.items():
                    print(f"  {strategy.upper()}: {params}")
            except Exception as e:
                print(f"Parameter optimization unavailable: {str(e)}")

        # Run individual strategies
        print("\nRunning individual strategies...")

        ma_strategy = MovingAverageTrend(price_series, Config.MA_FAST, Config.MA_SLOW)
        ma_returns = ma_strategy.backtest(return_series, Config.TRANSACTION_COST)

        mr_strategy = MeanReversion(price_series, Config.ZSCORE_WINDOW,
                                    Config.ZSCORE_ENTRY, Config.ZSCORE_EXIT)
        z_returns = mr_strategy.backtest(return_series, Config.TRANSACTION_COST)

        rsi_strategy = RSIStrategy(price_series, Config.RSI_PERIOD,
                                   Config.RSI_OVERSOLD, Config.RSI_OVERBOUGHT)
        rsi_returns = rsi_strategy.backtest(return_series, Config.TRANSACTION_COST)

        bb_strategy = BollingerBandsStrategy(price_series, Config.BB_PERIOD, Config.BB_STD)
        bb_returns = bb_strategy.backtest(return_series, Config.TRANSACTION_COST)

        print("Individual strategies complete")

        # Combine strategies with regime awareness
        print("\nCombining strategies with regime awareness...")
        allocator = RegimeAwareAllocator(
            {
                "MA": ma_returns,
                "Z": z_returns,
                "RSI": rsi_returns,
                "BB": bb_returns
            },
            regime,
            Config.TARGET_VOL
        )
        combined_returns = allocator.allocate()
        print("Strategy combination complete")

        # Walk-Forward Analysis
        print("\nRunning walk-forward analysis...")
        wf_analyzer = WalkForwardAnalyzer(Config.TRAIN_YEARS, Config.TEST_YEARS)
        wf_returns = wf_analyzer.run(combined_returns, combined_returns.index[0])
        print(f"Walk-forward analysis complete ({len(wf_returns)} test days)")

        # Monte Carlo
        print("\nRunning Monte Carlo simulation...")
        mc_simulator = MonteCarloSimulator(combined_returns, Config.MC_SIMULATIONS, Config.MC_SAMPLE_SIZE)
        mc_metrics = mc_simulator.get_metrics()
        print("Monte Carlo simulation complete")

        # Calculate metrics
        print("\nCalculating performance metrics...")
        analytics = PerformanceAnalytics()

        combined_metrics = analytics.calculate_metrics(combined_returns)
        wf_metrics = analytics.calculate_metrics(wf_returns)
        buy_hold_metrics = analytics.calculate_metrics(return_series)
        ma_metrics = analytics.calculate_metrics(ma_returns)
        z_metrics = analytics.calculate_metrics(z_returns)
        rsi_metrics = analytics.calculate_metrics(rsi_returns)
        bb_metrics = analytics.calculate_metrics(bb_returns)

        # Print results
        reporter = PerformanceReport()
        reporter.print_metrics(combined_metrics, f"REGIME-AWARE STRATEGY - {ticker}")
        reporter.print_metrics(buy_hold_metrics, f"BUY & HOLD - {ticker}")

        reporter.comparison_table({
            'Regime-Aware': combined_metrics,
            'Walk-Forward': wf_metrics,
            f'{ticker} B&H': buy_hold_metrics,
            'MA Trend': ma_metrics,
            'Mean Rev': z_metrics,
            'RSI': rsi_metrics,
            'Bollinger': bb_metrics
        })

        # Monte Carlo Results
        print("\n" + "="*60)
        print("MONTE CARLO SIMULATION RESULTS")
        print("="*60)
        print(f"Mean Return:         {mc_metrics['mean_return']:>10.2%}")
        print(f"Median Return:       {mc_metrics['median_return']:>10.2%}")
        print(f"Std Dev:             {mc_metrics['std_return']:>10.2%}")
        print(f"5th Percentile:      {mc_metrics['percentile_5']:>10.2%}")
        print(f"95th Percentile:     {mc_metrics['percentile_95']:>10.2%}")
        print(f"Mean Sharpe:         {mc_metrics['mean_sharpe']:>10.2f}")
        print(f"Median Sharpe:       {mc_metrics['median_sharpe']:>10.2f}")
        print("="*60 + "\n")

        # Visualizations
        print("Generating visualizations...")

        viz = Visualizer()

        ma200 = price_series.rolling(200).mean()
        viz.plot_regime_overview(price_series, ma200, regime)

        viz.plot_equity_curves({
            'Regime-Aware Strategy': combined_returns,
            'Walk-Forward OOS': wf_returns,
            f'{ticker} Buy & Hold': return_series
        }, f"{ticker} - Strategy Performance Comparison")

        viz.plot_drawdowns({
            'Regime-Aware': combined_returns,
            'Walk-Forward': wf_returns,
            f'{ticker}': return_series
        })

        viz.plot_rolling_metrics({
            'Regime-Aware': combined_returns,
            'Walk-Forward': wf_returns,
            f'{ticker}': return_series
        }, Config.ROLL_WINDOW)

        viz.plot_strategy_allocation(regime)
        viz.plot_monte_carlo(mc_simulator)

    # Alert system
    if mode in ['1', '3']:
        print("\nChecking for alerts...")
        try:
            alert_system = AlertSystem()

            # Check drawdown
            equity = (1 + return_series).cumprod()
            drawdown = ((equity - equity.cummax()) / equity.cummax()).iloc[-1]
            alert = alert_system.check_drawdown_alert(drawdown, ticker)
            if alert:
                alert_system.print_alert(alert)

            # Export alerts
            if alert_system.alert_history:
                alert_system.export_alert_history(f'{ticker}_alerts.json')
                print(f"Alerts exported to {ticker}_alerts.json")
        except Exception as e:
            print(f"Alert system unavailable: {str(e)}")


def analyze_portfolio(tickers: List[str], start_date: str, end_date: Optional[str] = None):
    """Analyze a portfolio of tickers"""

    print("\n" + "="*80)
    print(f"ANALYZING PORTFOLIO: {', '.join(tickers)}")
    print("="*80)

    # Fetch data
    print(f"\nDownloading market data from {start_date}...")
    prices, returns = DataManager.fetch_data(tickers, start_date, end_date)
    print(f"Data downloaded: {len(prices)} days from {prices.index[0].date()} to {prices.index[-1].date()}")

    # Use first ticker for regime detection
    reference_ticker = tickers[0]
    ref_price = prices[reference_ticker]
    ref_returns = returns[reference_ticker]

    # Regime Detection
    print("\nDetecting market regimes...")
    detector = RegimeDetector(ref_price, ref_returns, Config.VOL_LOOKBACK,
                             Config.VOL_THRESHOLD, Config.REGIME_CONFIRM_DAYS)
    regime = detector.detect_regime()
    print("Regime detection complete")

    # Run strategies
    print("\nRunning portfolio strategies...")

    # Individual ticker strategies on reference
    ma_strategy = MovingAverageTrend(ref_price, Config.MA_FAST, Config.MA_SLOW)
    ma_returns = ma_strategy.backtest(ref_returns, Config.TRANSACTION_COST)

    mr_strategy = MeanReversion(ref_price, Config.ZSCORE_WINDOW,
                                Config.ZSCORE_ENTRY, Config.ZSCORE_EXIT)
    z_returns = mr_strategy.backtest(ref_returns, Config.TRANSACTION_COST)

    # Momentum portfolio across all tickers
    mom_strategy = MomentumPortfolio(prices, Config.LOOKBACK_MOM, Config.TOP_N, Config.REB_FREQ)
    mom_returns = mom_strategy.backtest(returns, Config.TARGET_VOL)

    print("Portfolio strategies complete")


    # PORTFOLIO OPTIMIZATION
    print("\nOptimizing portfolio allocation...")
    try:
        portfolio_opt = PortfolioOptimizer(returns, Config.RISK_FREE_RATE)

        # Mean-Variance Optimization
        mv_result = portfolio_opt.mean_variance_optimization()
        print("\nMean-Variance Optimal Portfolio:")
        for ticker, weight in mv_result['weights'].items():
            print(f"  {ticker}: {weight:.2%}")
        print(f"Expected Return: {mv_result['expected_return']:.2%}")
        print(f"Volatility: {mv_result['volatility']:.2%}")
        print(f"Sharpe Ratio: {mv_result['sharpe']:.2f}")

        # Risk Parity
        rp_result = portfolio_opt.risk_parity()
        print("\nRisk Parity Portfolio:")
        for ticker, weight in rp_result['weights'].items():
            print(f"  {ticker}: {weight:.2%}")
        print(f"Expected Return: {rp_result['expected_return']:.2%}")
        print(f"Volatility: {rp_result['volatility']:.2%}")
        print(f"Sharpe Ratio: {rp_result['sharpe']:.2f}")
    except Exception as e:
        print(f"Portfolio optimization unavailable: {str(e)}")

    # Combine with regime awareness
    print("\nCombining strategies with regime awareness...")
    allocator = RegimeAwareAllocator(
        {
            "MA": ma_returns,
            "Z": z_returns,
            "MOM": mom_returns
        },
        regime,
        Config.TARGET_VOL
    )
    combined_returns = allocator.allocate()
    print("Strategy combination complete")

    # Walk-Forward Analysis
    print("\nRunning walk-forward analysis...")
    wf_analyzer = WalkForwardAnalyzer(Config.TRAIN_YEARS, Config.TEST_YEARS)
    wf_returns = wf_analyzer.run(combined_returns, combined_returns.index[0])
    print(f"Walk-forward analysis complete ({len(wf_returns)} test days)")

    # Monte Carlo
    print("\nRunning Monte Carlo simulation...")
    mc_simulator = MonteCarloSimulator(combined_returns, Config.MC_SIMULATIONS, Config.MC_SAMPLE_SIZE)
    mc_metrics = mc_simulator.get_metrics()
    print("Monte Carlo simulation complete")

    # Calculate metrics
    print("\nCalculating performance metrics...")
    analytics = PerformanceAnalytics()

    full_metrics = analytics.calculate_metrics(combined_returns)
    wf_metrics = analytics.calculate_metrics(wf_returns)
    ref_metrics = analytics.calculate_metrics(ref_returns)
    ma_metrics = analytics.calculate_metrics(ma_returns)
    z_metrics = analytics.calculate_metrics(z_returns)
    mom_metrics = analytics.calculate_metrics(mom_returns)

    # Print results
    reporter = PerformanceReport()

    reporter.print_metrics(full_metrics, "FULL SAMPLE - REGIME-AWARE STRATEGY")
    reporter.print_metrics(wf_metrics, "WALK-FORWARD OUT-OF-SAMPLE")
    reporter.print_metrics(ref_metrics, f"BUY & HOLD {reference_ticker} (BENCHMARK)")

    reporter.comparison_table({
        'Regime-Aware': full_metrics,
        'Walk-Forward': wf_metrics,
        f'{reference_ticker} B&H': ref_metrics,
        'MA Trend': ma_metrics,
        'Mean Rev': z_metrics,
        'Momentum': mom_metrics
    })

    # Monte Carlo Results
    print("\n" + "="*60)
    print("MONTE CARLO SIMULATION RESULTS")
    print("="*60)
    print(f"Mean Return:         {mc_metrics['mean_return']:>10.2%}")
    print(f"Median Return:       {mc_metrics['median_return']:>10.2%}")
    print(f"Std Dev:             {mc_metrics['std_return']:>10.2%}")
    print(f"5th Percentile:      {mc_metrics['percentile_5']:>10.2%}")
    print(f"95th Percentile:     {mc_metrics['percentile_95']:>10.2%}")
    print(f"Mean Sharpe:         {mc_metrics['mean_sharpe']:>10.2f}")
    print(f"Median Sharpe:       {mc_metrics['median_sharpe']:>10.2f}")
    print("="*60 + "\n")

    # Visualizations
    print("Generating visualizations...")

    viz = Visualizer()

    ma200 = ref_price.rolling(200).mean()
    viz.plot_regime_overview(ref_price, ma200, regime)

    viz.plot_equity_curves({
        'Regime-Aware Strategy': combined_returns,
        'Walk-Forward OOS': wf_returns,
        f'{reference_ticker} Buy & Hold': ref_returns
    }, "Portfolio Performance Comparison")

    viz.plot_drawdowns({
        'Regime-Aware': combined_returns,
        'Walk-Forward': wf_returns,
        f'{reference_ticker}': ref_returns
    })

    viz.plot_rolling_metrics({
        'Regime-Aware': combined_returns,
        'Walk-Forward': wf_returns,
        f'{reference_ticker}': ref_returns
    }, Config.ROLL_WINDOW)

    viz.plot_strategy_allocation(regime)
    viz.plot_monte_carlo(mc_simulator)

    print("\nAnalysis complete.")

# ==================================================
# ADVANCED FEATURES (from Ultimate System)
# ==================================================

class MultiTimeframeAnalyzer:
    """Analyze signals across multiple timeframes"""

    def __init__(self, ticker: str, multi_tf_data: Dict[str, pd.DataFrame]):
        self.ticker = ticker
        self.data = multi_tf_data
        self.signals = {}

    def analyze_all_timeframes(self) -> Dict[str, Dict]:
        """Analyze across all available timeframes"""
        results = {}

        for tf_name, prices in self.data.items():
            if prices is None or len(prices) < 200:
                continue

            price_series = prices[self.ticker] if isinstance(prices, pd.DataFrame) else prices
            returns = price_series.pct_change().dropna()

            # Generate signals for this timeframe
            tf_signals = self._analyze_timeframe(price_series, returns, tf_name)
            results[tf_name] = tf_signals

        return results

    def _analyze_timeframe(self, price: pd.Series, returns: pd.Series,
                          tf_name: str) -> Dict:
        """Analyze a single timeframe"""
        from copy import deepcopy

        # Moving Average
        ma_fast = price.rolling(min(50, len(price)//4)).mean()
        ma_slow = price.rolling(min(200, len(price)//2)).mean()
        ma_signal = "BUY" if ma_fast.iloc[-1] > ma_slow.iloc[-1] else "SELL"

        # RSI
        rsi = compute_rsi(price, min(14, len(price)//10))
        rsi_value = rsi.iloc[-1]
        if rsi_value < 30:
            rsi_signal = "BUY"
        elif rsi_value > 70:
            rsi_signal = "SELL"
        else:
            rsi_signal = "HOLD"

        # Trend
        sma_200 = price.rolling(min(200, len(price)//2)).mean()
        trend = "BULLISH" if price.iloc[-1] > sma_200.iloc[-1] else "BEARISH"

        return {
            'ma_signal': ma_signal,
            'rsi_signal': rsi_signal,
            'trend': trend,
            'rsi_value': rsi_value,
            'price': price.iloc[-1]
        }

    def get_alignment_score(self) -> Tuple[float, Dict]:
        """Calculate alignment score across timeframes"""
        signals = self.analyze_all_timeframes()

        if not signals:
            return 0.0, {}

        # Count bullish signals
        bullish_count = 0
        total_count = 0

        alignment_details = {}

        for tf_name, tf_signals in signals.items():
            if tf_signals['ma_signal'] == 'BUY':
                bullish_count += 1
            total_count += 1

            if tf_signals['rsi_signal'] == 'BUY':
                bullish_count += 0.5
            total_count += 0.5

            if tf_signals['trend'] == 'BULLISH':
                bullish_count += 1
            total_count += 1

            alignment_details[tf_name] = {
                'signal': tf_signals['ma_signal'],
                'trend': tf_signals['trend']
            }

        score = bullish_count / total_count if total_count > 0 else 0.5

        return score, alignment_details

    def get_consensus_signal(self) -> str:
        """Get consensus signal across timeframes"""
        score, _ = self.get_alignment_score()

        if score >= 0.75:
            return "STRONG_BUY"
        elif score >= 0.6:
            return "BUY"
        elif score >= 0.4:
            return "HOLD"
        elif score >= 0.25:
            return "SELL"
        else:
            return "STRONG_SELL"

# ==================================================
# MACHINE LEARNING REGIME PREDICTOR
# ==================================================



# ==================================================
# MACHINE LEARNING MODULE
# ==================================================

class FeatureEngineer:
    """
    Advanced feature engineering for ML models

    Creates technical, fundamental, and derived features
    for predicting returns and trading signals
    """

    def __init__(self):
        self.feature_names = []

    def create_technical_features(self, price: pd.Series, returns: pd.Series,
                                  volume: Optional[pd.Series] = None) -> pd.DataFrame:
        """
        Create technical analysis features

        Returns:
            DataFrame with technical features
        """
        features = pd.DataFrame(index=price.index)

        # === PRICE FEATURES ===
        # Moving averages (multiple timeframes)
        for period in [5, 10, 20, 50, 100, 200]:
            features[f'ma_{period}'] = price.rolling(period).mean() / price - 1
            features[f'ma_{period}_slope'] = features[f'ma_{period}'].diff(5)

        # Price position in range
        for period in [5, 10, 20, 50]:
            high = price.rolling(period).max()
            low = price.rolling(period).min()
            features[f'price_position_{period}'] = (price - low) / (high - low + 1e-10)

        # === RETURN FEATURES ===
        # Returns at different horizons
        for period in [1, 2, 3, 5, 10, 20, 40, 60]:
            features[f'return_{period}d'] = returns.rolling(period).sum()

        # Return acceleration
        features['return_acceleration'] = returns.diff()

        # === VOLATILITY FEATURES ===
        # Historical volatility
        for period in [5, 10, 20, 40, 60]:
            features[f'volatility_{period}d'] = returns.rolling(period).std() * np.sqrt(252)

        # Volatility ratios (regime changes)
        features['vol_ratio_5_20'] = features['volatility_5d'] / (features['volatility_20d'] + 1e-10)
        features['vol_ratio_20_60'] = features['volatility_20d'] / (features['volatility_60d'] + 1e-10)

        # === MOMENTUM FEATURES ===
        # RSI
        features['rsi_14'] = self._compute_rsi(price, 14)
        features['rsi_28'] = self._compute_rsi(price, 28)

        # MACD
        ema_12 = price.ewm(span=12, adjust=False).mean()
        ema_26 = price.ewm(span=26, adjust=False).mean()
        features['macd'] = (ema_12 - ema_26) / price
        features['macd_signal'] = features['macd'].ewm(span=9, adjust=False).mean()
        features['macd_histogram'] = features['macd'] - features['macd_signal']

        # Momentum oscillators
        for period in [10, 20, 50]:
            features[f'momentum_{period}'] = price.pct_change(period)
            features[f'roc_{period}'] = (price - price.shift(period)) / price.shift(period)

        # === TREND FEATURES ===
        # ADX (Average Directional Index approximation)
        for period in [14, 28]:
            features[f'adx_{period}'] = self._compute_adx(price, period)

        # Trend strength
        features['trend_strength_20'] = abs(price.rolling(20).mean() - price) / price

        # === VOLATILITY INDICATORS ===
        # Bollinger Bands
        for period in [20, 50]:
            ma = price.rolling(period).mean()
            std = price.rolling(period).std()
            features[f'bb_upper_{period}'] = (ma + 2*std - price) / price
            features[f'bb_lower_{period}'] = (price - (ma - 2*std)) / price
            features[f'bb_width_{period}'] = (4 * std) / ma

        # ATR (Average True Range)
        features['atr_14'] = self._compute_atr(price, 14)

        # === VOLUME FEATURES (if available) ===
        if volume is not None:
            for period in [5, 10, 20]:
                features[f'volume_ma_{period}'] = volume.rolling(period).mean()
                features[f'volume_ratio_{period}'] = volume / features[f'volume_ma_{period}']

            # On-Balance Volume
            features['obv'] = self._compute_obv(price, volume)

        # === PATTERN FEATURES ===
        # Higher highs / lower lows
        features['higher_high_5'] = (price > price.rolling(5).max().shift(1)).astype(int)
        features['lower_low_5'] = (price < price.rolling(5).min().shift(1)).astype(int)

        # Gap detection
        features['gap_up'] = (price > price.shift(1) * 1.02).astype(int)
        features['gap_down'] = (price < price.shift(1) * 0.98).astype(int)

        self.feature_names = list(features.columns)
        return features

    def create_lagged_features(self, features: pd.DataFrame, lags: List[int] = [1, 2, 3, 5]) -> pd.DataFrame:
        """
        Create lagged versions of features

        Args:
            features: Base features
            lags: List of lag periods

        Returns:
            DataFrame with original + lagged features
        """
        lagged_features = features.copy()

        for lag in lags:
            for col in features.columns:
                lagged_features[f'{col}_lag{lag}'] = features[col].shift(lag)

        return lagged_features

    def create_interaction_features(self, features: pd.DataFrame,
                                    interactions: List[Tuple[str, str]] = None) -> pd.DataFrame:
        """
        Create interaction features (products of pairs)

        Args:
            features: Base features
            interactions: List of (feature1, feature2) tuples
                         If None, creates for important pairs

        Returns:
            DataFrame with interaction features added
        """
        result = features.copy()

        if interactions is None:
            # Default important interactions
            interactions = [
                ('return_5d', 'volatility_5d'),
                ('ma_20', 'rsi_14'),
                ('momentum_20', 'volatility_20d'),
                ('macd', 'rsi_14'),
            ]

        for feat1, feat2 in interactions:
            if feat1 in result.columns and feat2 in result.columns:
                result[f'{feat1}_x_{feat2}'] = result[feat1] * result[feat2]

        return result

    # Helper methods
    def _compute_rsi(self, price: pd.Series, period: int = 14) -> pd.Series:
        """Compute RSI indicator"""
        delta = price.diff()
        gain = (delta.where(delta > 0, 0)).rolling(period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(period).mean()
        rs = gain / (loss + 1e-10)
        return 100 - (100 / (1 + rs))

    def _compute_adx(self, price: pd.Series, period: int = 14) -> pd.Series:
        """Approximate ADX (simplified)"""
        high_low = price.rolling(period).max() - price.rolling(period).min()
        direction = price.diff().abs().rolling(period).mean()
        return (direction / (high_low + 1e-10) * 100).fillna(50)

    def _compute_atr(self, price: pd.Series, period: int = 14) -> pd.Series:
        """Approximate ATR"""
        high_low = price.rolling(period).max() - price.rolling(period).min()
        return (high_low / price).rolling(period).mean()

    def _compute_obv(self, price: pd.Series, volume: pd.Series) -> pd.Series:
        """Compute On-Balance Volume"""
        obv = (np.sign(price.diff()) * volume).fillna(0).cumsum()
        return obv

class LinearRegressionPredictor:
    """
    Linear Regression for return prediction

    Predicts future returns based on features
    Use for: Continuous return forecasting
    """

    def __init__(self, target_horizon: int = 5):
        """
        Args:
            target_horizon: Days ahead to predict (e.g., 5 = predict 5-day return)
        """
        from sklearn.linear_model import LinearRegression, Ridge

        self.model = Ridge(alpha=1.0)  # Ridge for regularization
        self.target_horizon = target_horizon
        self.scaler = StandardScaler()
        self.feature_engineer = FeatureEngineer()
        self.is_trained = False

    def prepare_features(self, price: pd.Series, returns: pd.Series,
                        volume: Optional[pd.Series] = None) -> pd.DataFrame:
        """Create and prepare features"""
        # Technical features
        features = self.feature_engineer.create_technical_features(price, returns, volume)

        # Lagged features
        features = self.feature_engineer.create_lagged_features(features, lags=[1, 2, 5])

        # Interaction features
        features = self.feature_engineer.create_interaction_features(features)

        return features.replace([np.inf, -np.inf], np.nan).fillna(0)

    def prepare_target(self, returns: pd.Series) -> pd.Series:
        """Prepare target variable (future returns)"""
        # Predict returns N days ahead
        target = returns.rolling(self.target_horizon).sum().shift(-self.target_horizon)
        return target

    def train(self, price: pd.Series, returns: pd.Series,
             volume: Optional[pd.Series] = None,
             test_size: float = 0.2) -> Dict[str, float]:
        """
        Train linear regression model

        Returns:
            Dictionary with training metrics
        """
        print(f"\nTraining Linear Regression (predicting {self.target_horizon}-day returns)...")

        # Prepare features and target
        X = self.prepare_features(price, returns, volume)
        y = self.prepare_target(returns)

        # Align and drop NaN
        data = pd.concat([X, y], axis=1).dropna()

        if len(data) < 100:
            print(f"  Insufficient data: {len(data)} samples (need 100+)")
            return {'r2': 0, 'mse': 0}

        X = data.iloc[:, :-1]
        y = data.iloc[:, -1]

        # Train/test split (time series, so use early data for train)
        split_idx = int(len(X) * (1 - test_size))
        X_train, X_test = X[:split_idx], X[split_idx:]
        y_train, y_test = y[:split_idx], y[split_idx:]

        # Scale features
        X_train_scaled = self.scaler.fit_transform(X_train)
        X_test_scaled = self.scaler.transform(X_test)

        # Train model
        self.model.fit(X_train_scaled, y_train)
        self.is_trained = True

        # Evaluate
        train_score = self.model.score(X_train_scaled, y_train)
        test_score = self.model.score(X_test_scaled, y_test)

        # Predictions
        y_pred = self.model.predict(X_test_scaled)
        mse = np.mean((y_test - y_pred) ** 2)

        print(f"  Training R²: {train_score:.4f}")
        print(f"  Test R²: {test_score:.4f}")
        print(f"  Test MSE: {mse:.6f}")

        # Feature importance
        feature_importance = pd.Series(
            np.abs(self.model.coef_),
            index=X.columns
        ).sort_values(ascending=False)

        print(f"\n  Top 5 Features:")
        for feat, importance in feature_importance.head(5).items():
            print(f"    {feat}: {importance:.4f}")

        return {
            'train_r2': train_score,
            'test_r2': test_score,
            'mse': mse,
            'feature_importance': feature_importance
        }

    def predict(self, price: pd.Series, returns: pd.Series,
               volume: Optional[pd.Series] = None) -> pd.Series:
        """
        Predict future returns

        Returns:
            Series of predicted returns
        """
        if not self.is_trained:
            raise ValueError("Model not trained. Call train() first.")

        # Prepare features
        X = self.prepare_features(price, returns, volume)
        X = X.replace([np.inf, -np.inf], np.nan).fillna(0)

        # Scale
        X_scaled = self.scaler.transform(X)

        # Predict
        predictions = self.model.predict(X_scaled)

        return pd.Series(predictions, index=X.index)

class LogisticRegressionPredictor:
    """
    Logistic Regression for directional prediction

    Predicts direction (up/down) instead of magnitude
    Use for: Binary classification trading signals
    """

    def __init__(self, target_horizon: int = 5, threshold: float = 0.0):
        """
        Args:
            target_horizon: Days ahead to predict
            threshold: Return threshold for positive class (e.g., 0.02 = 2%)
        """
        from sklearn.linear_model import LogisticRegression

        self.model = LogisticRegression(
            penalty='l2',
            C=1.0,
            max_iter=1000,
            class_weight='balanced'  # Handle imbalanced classes
        )
        self.target_horizon = target_horizon
        self.threshold = threshold
        self.scaler = StandardScaler()
        self.feature_engineer = FeatureEngineer()
        self.is_trained = False

    def prepare_features(self, price: pd.Series, returns: pd.Series,
                        volume: Optional[pd.Series] = None) -> pd.DataFrame:
        """Create and prepare features"""
        # Technical features
        features = self.feature_engineer.create_technical_features(price, returns, volume)

        # Lagged features
        features = self.feature_engineer.create_lagged_features(features, lags=[1, 2, 5])

        # Interaction features
        features = self.feature_engineer.create_interaction_features(features)

        return features.replace([np.inf, -np.inf], np.nan).fillna(0)

    def prepare_target(self, returns: pd.Series) -> pd.Series:
        """
        Prepare binary target (up=1, down=0)

        Returns:
            Series of 1s and 0s
        """
        # Future returns
        future_return = returns.rolling(self.target_horizon).sum().shift(-self.target_horizon)

        # Binary: 1 if return > threshold, 0 otherwise
        target = (future_return > self.threshold).astype(int)

        return target

    def train(self, price: pd.Series, returns: pd.Series,
             volume: Optional[pd.Series] = None,
             test_size: float = 0.2) -> Dict[str, float]:
        """
        Train logistic regression model

        Returns:
            Dictionary with training metrics
        """
        print(f"\nTraining Logistic Regression (predicting {self.target_horizon}-day direction)...")

        # Prepare features and target
        X = self.prepare_features(price, returns, volume)
        y = self.prepare_target(returns)

        # Align and drop NaN
        data = pd.concat([X, y], axis=1).dropna()

        if len(data) < 100:
            print(f"  Insufficient data: {len(data)} samples (need 100+)")
            return {'accuracy': 0, 'precision': 0, 'recall': 0}

        X = data.iloc[:, :-1]
        y = data.iloc[:, -1]

        # Train/test split
        split_idx = int(len(X) * (1 - test_size))
        X_train, X_test = X[:split_idx], X[split_idx:]
        y_train, y_test = y[:split_idx], y[split_idx:]

        print(f"  Training samples: {len(X_train)}")
        print(f"  Test samples: {len(X_test)}")
        print(f"  Positive class: {y_train.sum() / len(y_train):.2%}")

        # Scale features
        X_train_scaled = self.scaler.fit_transform(X_train)
        X_test_scaled = self.scaler.transform(X_test)

        # Train model
        self.model.fit(X_train_scaled, y_train)
        self.is_trained = True

        # Evaluate
        from sklearn.metrics import accuracy_score, precision_score, recall_score, roc_auc_score

        y_pred = self.model.predict(X_test_scaled)
        y_prob = self.model.predict_proba(X_test_scaled)[:, 1]

        accuracy = accuracy_score(y_test, y_pred)
        precision = precision_score(y_test, y_pred, zero_division=0)
        recall = recall_score(y_test, y_pred, zero_division=0)

        try:
            auc = roc_auc_score(y_test, y_prob)
        except:
            auc = 0.5

        print(f"  Test Accuracy: {accuracy:.4f}")
        print(f"  Test Precision: {precision:.4f}")
        print(f"  Test Recall: {recall:.4f}")
        print(f"  Test AUC-ROC: {auc:.4f}")

        # Feature importance
        feature_importance = pd.Series(
            np.abs(self.model.coef_[0]),
            index=X.columns
        ).sort_values(ascending=False)

        print(f"\n  Top 5 Features:")
        for feat, importance in feature_importance.head(5).items():
            print(f"    {feat}: {importance:.4f}")

        return {
            'accuracy': accuracy,
            'precision': precision,
            'recall': recall,
            'auc': auc,
            'feature_importance': feature_importance
        }

    def predict(self, price: pd.Series, returns: pd.Series,
               volume: Optional[pd.Series] = None,
               return_proba: bool = False) -> pd.Series:
        """
        Predict direction (up/down)

        Args:
            return_proba: If True, return probabilities instead of binary predictions

        Returns:
            Series of predictions (0/1) or probabilities
        """
        if not self.is_trained:
            raise ValueError("Model not trained. Call train() first.")

        # Prepare features
        X = self.prepare_features(price, returns, volume)
        X = X.replace([np.inf, -np.inf], np.nan).fillna(0)

        # Scale
        X_scaled = self.scaler.transform(X)

        # Predict
        if return_proba:
            predictions = self.model.predict_proba(X_scaled)[:, 1]
        else:
            predictions = self.model.predict(X_scaled)

        return pd.Series(predictions, index=X.index)

    def generate_signals(self, price: pd.Series, returns: pd.Series,
                        volume: Optional[pd.Series] = None,
                        confidence_threshold: float = 0.6) -> pd.Series:
        """
        Generate trading signals based on predictions

        Args:
            confidence_threshold: Minimum probability for signal (0.5-1.0)

        Returns:
            Series with signals: 1 (buy), 0 (hold), -1 (sell)
        """
        # Get probabilities
        probabilities = self.predict(price, returns, volume, return_proba=True)

        # Generate signals
        signals = pd.Series(0, index=probabilities.index)
        signals[probabilities >= confidence_threshold] = 1  # Buy
        signals[probabilities <= (1 - confidence_threshold)] = -1  # Sell

        return signals

# ==================================================
# REGIME PREDICTION (EXISTING)
# ==================================================

class MLRegimePredictor:
    """Predict market regimes using machine learning"""

    def __init__(self):
        self.model = GradientBoostingClassifier(
            n_estimators=100,
            max_depth=5,
            random_state=42
        )
        self.scaler = StandardScaler()
        self.is_trained = False

    def create_features(self, price: pd.Series, returns: pd.Series) -> pd.DataFrame:
        """Create features for ML model"""
        features = pd.DataFrame(index=price.index)

        # Price-based features
        features['returns_5d'] = returns.rolling(5).mean()
        features['returns_20d'] = returns.rolling(20).mean()
        features['returns_60d'] = returns.rolling(60).mean()

        # Volatility features
        features['vol_5d'] = returns.rolling(5).std()
        features['vol_20d'] = returns.rolling(20).std()
        features['vol_60d'] = returns.rolling(60).std()
        features['vol_ratio'] = features['vol_5d'] / features['vol_20d']

        # Trend features
        features['ma_20'] = price.rolling(20).mean() / price
        features['ma_50'] = price.rolling(50).mean() / price
        features['ma_200'] = price.rolling(200).mean() / price

        # Momentum features
        features['rsi'] = compute_rsi(price, 14)
        features['mom_20'] = price.pct_change(20)
        features['mom_60'] = price.pct_change(60)

        # Range features
        features['range_20'] = (price.rolling(20).max() - price.rolling(20).min()) / price

        return features.fillna(method='ffill').fillna(0)

    def train(self, price: pd.Series, returns: pd.Series,
             regime: pd.Series) -> float:
        """Train the ML model"""
        try:
            features = self.create_features(price, returns)

            # Align data
            aligned_data = pd.concat([features, regime], axis=1, join='inner')
            aligned_data = aligned_data.dropna()

            if len(aligned_data) < Config.ML_TRAIN_SIZE:
                print(f"  Insufficient data for ML training: {len(aligned_data)} samples (need {Config.ML_TRAIN_SIZE})")
                return 0.0

            X = aligned_data.iloc[:, :-1]
            y = aligned_data.iloc[:, -1]

            # Encode regime labels
            regime_map = {'Risk-Off': 0, 'Choppy': 1, 'Trend': 2}
            y_encoded = y.map(regime_map)

            # Check if we have any NaN after encoding
            if y_encoded.isna().any():
                print(f"  Warning: Unknown regime labels found")
                return 0.0

            # Train/test split (time series)
            split_idx = int(len(X) * 0.8)
            if split_idx < 100:  # Need minimum train size
                print(f"  Insufficient data for train/test split")
                return 0.0

            X_train, X_test = X[:split_idx], X[split_idx:]
            y_train, y_test = y_encoded[:split_idx], y_encoded[split_idx:]

            # Scale features
            X_train_scaled = self.scaler.fit_transform(X_train)
            X_test_scaled = self.scaler.transform(X_test)

            # Train model
            self.model.fit(X_train_scaled, y_train)
            self.is_trained = True

            # Calculate accuracy
            accuracy = self.model.score(X_test_scaled, y_test)

            return accuracy
        except Exception as e:
            print(f"  ML training error: {str(e)}")
            return 0.0

    def predict_next_regime(self, price: pd.Series, returns: pd.Series) -> Tuple[str, float]:
        """Predict next regime with confidence"""
        if not self.is_trained:
            return "Unknown", 0.0

        features = self.create_features(price, returns)
        latest_features = features.iloc[-1:].values

        # Scale
        latest_scaled = self.scaler.transform(latest_features)

        # Predict
        prediction = self.model.predict(latest_scaled)[0]
        probabilities = self.model.predict_proba(latest_scaled)[0]

        regime_map_inv = {0: 'Risk-Off', 1: 'Choppy', 2: 'Trend'}
        predicted_regime = regime_map_inv[prediction]
        confidence = probabilities[prediction]

        return predicted_regime, confidence

    def predict_regime_transition(self, price: pd.Series, returns: pd.Series,
                                  current_regime: str, days_ahead: int = 5) -> Dict:
        """Predict regime transition probability"""
        if not self.is_trained:
            return {}

        features = self.create_features(price, returns)
        latest_features = features.iloc[-1:].values
        latest_scaled = self.scaler.transform(latest_features)

        probabilities = self.model.predict_proba(latest_scaled)[0]

        regime_map_inv = {0: 'Risk-Off', 1: 'Choppy', 2: 'Trend'}

        transition_prob = {
            regime_map_inv[i]: prob
            for i, prob in enumerate(probabilities)
        }

        return transition_prob

# ==================================================
# PARAMETER OPTIMIZER
# ==================================================



class ParameterOptimizer:
    """Optimize strategy parameters systematically"""

    def __init__(self, price: pd.Series, returns: pd.Series):
        self.price = price
        self.returns = returns
        self.best_params = {}

    def optimize_ma_parameters(self, method: str = 'grid') -> Dict:
        """Optimize moving average parameters"""

        if method == 'grid':
            return self._grid_search_ma()
        else:
            return self._genetic_algorithm_ma()

    def _grid_search_ma(self) -> Dict:
        """Grid search for MA parameters"""
        fast_range = range(20, 101, 10)
        slow_range = range(100, 301, 20)

        best_sharpe = -np.inf
        best_params = {'fast': 50, 'slow': 200}

        for fast in fast_range:
            for slow in slow_range:
                if fast >= slow:
                    continue

                # Backtest with these parameters
                sharpe = self._backtest_ma(fast, slow)

                if sharpe > best_sharpe:
                    best_sharpe = sharpe
                    best_params = {'fast': fast, 'slow': slow}

        self.best_params['ma'] = best_params
        return best_params

    def _backtest_ma(self, fast: int, slow: int) -> float:
        """Backtest MA strategy and return Sharpe"""
        ma_fast = self.price.rolling(fast).mean()
        ma_slow = self.price.rolling(slow).mean()
        signal = (ma_fast > ma_slow).astype(int)

        trades = signal.diff().abs()
        strategy_returns = signal.shift(1) * self.returns
        strategy_returns -= trades * Config.TRANSACTION_COST

        strategy_returns = strategy_returns.dropna()

        if len(strategy_returns) == 0 or strategy_returns.std() == 0:
            return -np.inf

        sharpe = strategy_returns.mean() / strategy_returns.std() * np.sqrt(252)
        return sharpe

    def optimize_rsi_parameters(self) -> Dict:
        """Optimize RSI parameters"""
        period_range = range(10, 31, 2)
        oversold_range = range(20, 41, 5)
        overbought_range = range(60, 81, 5)

        best_sharpe = -np.inf
        best_params = {'period': 14, 'oversold': 30, 'overbought': 70}

        for period in period_range:
            for oversold in oversold_range:
                for overbought in overbought_range:
                    if oversold >= overbought:
                        continue

                    sharpe = self._backtest_rsi(period, oversold, overbought)

                    if sharpe > best_sharpe:
                        best_sharpe = sharpe
                        best_params = {
                            'period': period,
                            'oversold': oversold,
                            'overbought': overbought
                        }

        self.best_params['rsi'] = best_params
        return best_params

    def _backtest_rsi(self, period: int, oversold: float, overbought: float) -> float:
        """Backtest RSI strategy"""
        rsi = compute_rsi(self.price, period)

        signal = pd.Series(0, index=rsi.index)
        signal[rsi < oversold] = 1
        signal[rsi > overbought] = 0
        signal = signal.replace(0, np.nan).fillna(method='ffill').fillna(0)

        trades = signal.diff().abs()
        strategy_returns = signal.shift(1) * self.returns
        strategy_returns -= trades * Config.TRANSACTION_COST

        strategy_returns = strategy_returns.dropna()

        if len(strategy_returns) == 0 or strategy_returns.std() == 0:
            return -np.inf

        sharpe = strategy_returns.mean() / strategy_returns.std() * np.sqrt(252)
        return sharpe

    def optimize_all_strategies(self) -> Dict:
        """Optimize all strategy parameters"""
        print("Optimizing Moving Average parameters...")
        ma_params = self.optimize_ma_parameters()

        print("Optimizing RSI parameters...")
        rsi_params = self.optimize_rsi_parameters()

        return {
            'ma': ma_params,
            'rsi': rsi_params
        }

# ==================================================
# PORTFOLIO OPTIMIZER
# ==================================================



class PortfolioOptimizer:
    """Build optimal portfolios"""

    def __init__(self, returns: pd.DataFrame, risk_free_rate: float = 0.04):
        self.returns = returns
        self.rf = risk_free_rate / 252  # Daily risk-free rate
        self.mean_returns = returns.mean()
        self.cov_matrix = returns.cov()

    def mean_variance_optimization(self, target_return: Optional[float] = None) -> Dict:
        """Mean-variance optimization (Markowitz)"""
        n_assets = len(self.mean_returns)

        def portfolio_stats(weights):
            port_return = np.sum(self.mean_returns * weights) * 252
            port_vol = np.sqrt(np.dot(weights.T, np.dot(self.cov_matrix * 252, weights)))
            sharpe = (port_return - Config.RISK_FREE_RATE) / port_vol
            return port_return, port_vol, sharpe

        def neg_sharpe(weights):
            return -portfolio_stats(weights)[2]

        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
        bounds = tuple((Config.MIN_POSITION_SIZE, Config.MAX_POSITION_SIZE) for _ in range(n_assets))
        initial_guess = np.array([1/n_assets] * n_assets)

        result = minimize(
            neg_sharpe,
            initial_guess,
            method='SLSQP',
            bounds=bounds,
            constraints=constraints
        )

        optimal_weights = result.x
        port_return, port_vol, sharpe = portfolio_stats(optimal_weights)

        return {
            'weights': dict(zip(self.returns.columns, optimal_weights)),
            'expected_return': port_return,
            'volatility': port_vol,
            'sharpe': sharpe
        }

    def risk_parity(self) -> Dict:
        """Risk parity allocation"""
        n_assets = len(self.mean_returns)

        def risk_contribution(weights):
            port_vol = np.sqrt(np.dot(weights.T, np.dot(self.cov_matrix * 252, weights)))
            marginal_contrib = np.dot(self.cov_matrix * 252, weights)
            risk_contrib = weights * marginal_contrib / port_vol
            return risk_contrib

        def risk_parity_objective(weights):
            risk_contrib = risk_contribution(weights)
            target = np.ones(n_assets) / n_assets
            return np.sum((risk_contrib - target) ** 2)

        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
        bounds = tuple((Config.MIN_POSITION_SIZE, Config.MAX_POSITION_SIZE) for _ in range(n_assets))
        initial_guess = np.array([1/n_assets] * n_assets)

        result = minimize(
            risk_parity_objective,
            initial_guess,
            method='SLSQP',
            bounds=bounds,
            constraints=constraints
        )

        optimal_weights = result.x

        port_return = np.sum(self.mean_returns * optimal_weights) * 252
        port_vol = np.sqrt(np.dot(optimal_weights.T, np.dot(self.cov_matrix * 252, optimal_weights)))
        sharpe = (port_return - Config.RISK_FREE_RATE) / port_vol

        return {
            'weights': dict(zip(self.returns.columns, optimal_weights)),
            'expected_return': port_return,
            'volatility': port_vol,
            'sharpe': sharpe
        }

    def kelly_criterion_sizing(self, win_rate: float, avg_win: float,
                               avg_loss: float) -> float:
        """Calculate position size using Kelly Criterion"""
        if avg_loss == 0:
            return 0.0

        win_loss_ratio = abs(avg_win / avg_loss)
        kelly = (win_rate * win_loss_ratio - (1 - win_rate)) / win_loss_ratio

        # Use fractional Kelly (half-Kelly for safety)
        fractional_kelly = kelly * 0.5

        # Cap at maximum position size
        return min(max(fractional_kelly, 0), Config.MAX_POSITION_SIZE)

# ==================================================
# ENHANCED BACKTESTING
# ==================================================



class AlertSystem:
    """Real-time alert system for trading signals"""

    def __init__(self):
        self.alerts = []
        self.alert_history = []

    def create_alert(self, ticker: str, signal: Signal, strategy: str,
                    price: float, confidence: float, timeframes_aligned: bool,
                    additional_info: Dict = None) -> Alert:
        """Create a new alert"""
        message = self._generate_alert_message(
            ticker, signal, strategy, price, confidence,
            timeframes_aligned, additional_info
        )

        alert = Alert(
            timestamp=datetime.now(),
            ticker=ticker,
            signal=signal,
            strategy=strategy,
            price=price,
            confidence=confidence,
            message=message,
            timeframes_aligned=timeframes_aligned
        )

        self.alerts.append(alert)
        self.alert_history.append(alert)

        return alert

    def _generate_alert_message(self, ticker: str, signal: Signal,
                                strategy: str, price: float, confidence: float,
                                timeframes_aligned: bool,
                                additional_info: Dict = None) -> str:
        """Generate alert message"""
        alignment = "ALL TIMEFRAMES ALIGNED" if timeframes_aligned else "Single timeframe"

        message = f"""
TRADING ALERT - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

{ticker} - {signal.name.replace('_', ' ')}
Strategy: {strategy}
Current Price: ${price:.2f}
Confidence: {confidence:.1%}
Timeframe Alignment: {alignment}
"""

        if additional_info:
            message += "\nAdditional Information:\n"
            for key, value in additional_info.items():
                message += f"  {key}: {value}\n"

        return message

    def check_drawdown_alert(self, current_dd: float, ticker: str) -> Optional[Alert]:
        """Check if drawdown alert should be triggered"""
        if abs(current_dd) >= Config.DRAWDOWN_ALERT_THRESHOLD:
            return self.create_alert(
                ticker=ticker,
                signal=Signal.SELL,
                strategy="Risk Management",
                price=0.0,
                confidence=1.0,
                timeframes_aligned=False,
                additional_info={
                    'drawdown': f"{current_dd:.2%}",
                    'action': 'Consider reducing position size'
                }
            )
        return None

    def check_regime_change_alert(self, old_regime: str, new_regime: str,
                                  ticker: str) -> Optional[Alert]:
        """Alert on regime change"""
        if old_regime != new_regime:
            return self.create_alert(
                ticker=ticker,
                signal=Signal.HOLD,
                strategy="Regime Detection",
                price=0.0,
                confidence=1.0,
                timeframes_aligned=False,
                additional_info={
                    'old_regime': old_regime,
                    'new_regime': new_regime,
                    'recommendation': self._get_regime_recommendation(new_regime)
                }
            )
        return None

    def _get_regime_recommendation(self, regime: str) -> str:
        """Get recommendation based on regime"""
        recommendations = {
            'Trend': 'Favor momentum and trend-following strategies',
            'Choppy': 'Favor mean reversion strategies',
            'Risk-Off': 'Reduce exposure, consider defensive positions'
        }
        return recommendations.get(regime, 'Monitor closely')

    def get_active_alerts(self, min_confidence: float = 0.6) -> List[Alert]:
        """Get active high-confidence alerts"""
        return [a for a in self.alerts if a.confidence >= min_confidence]

    def print_alert(self, alert: Alert):
        """Print formatted alert"""
        print("\n" + "="*80)
        print(alert.message)
        print("="*80 + "\n")

    def clear_alerts(self):
        """Clear current alerts (keep history)"""
        self.alerts = []

    def export_alert_history(self, filename: str = 'alert_history.json'):
        """Export alert history to file"""
        export_data = [
            {
                'timestamp': a.timestamp.isoformat(),
                'ticker': a.ticker,
                'signal': a.signal.name,
                'strategy': a.strategy,
                'price': a.price,
                'confidence': a.confidence,
                'message': a.message
            }
            for a in self.alert_history
        ]

        with open(filename, 'w') as f:
            json.dump(export_data, f, indent=2)

# ==================================================
# TRADING ASSISTANT (Main Orchestrator)
# ==================================================




def main():
    """Main execution function with user interface"""

    print("\n" + "="*80)
    print("Enhanced Multi-Strategy Trading System".center(80))
    print("Professional Trading Analysis Platform".center(80))
    print("="*80)

    ui = UserInterface()

    # Get ticker input
    ticker_input = ui.get_ticker_input()

    if ticker_input is None:
        print("\nExiting...")
        return

    # Get date range
    start_date, end_date = ui.get_date_range()

    if ticker_input == 'PORTFOLIO':
        # Multi-asset portfolio analysis
        tickers = ui.get_portfolio_tickers()
        if not tickers:
            print("\nNo valid tickers provided. Exiting...")
            return

        # Choose between multi-asset backtest or factor analysis
        print("\nPortfolio Analysis Type:")
        print("1. Multi-Asset Backtest (rebalancing, trailing stops)")
        print("2. Factor Analysis (momentum, volatility, value)")

        analysis_type = input("Enter choice (1/2, default: 1): ").strip()

        if analysis_type == '2':
            # Factor analysis
            include_value = input("\nInclude Value factor? (y/n, default: y): ").strip().lower()
            include_value = include_value != 'n'

            method_choice = input("\nPortfolio method:\n1. Long Only\n2. Long-Short (30/30)\n3. Ranked\n4. Long-Short Decile (Top 10% / Bottom 10%)\nChoice (default: 1): ").strip()
            method_map = {'1': 'long_only', '2': 'long_short', '3': 'ranked', '4': 'long_short_decile'}
            method = method_map.get(method_choice, 'long_only')

            top_n_input = input(f"\nNumber of top holdings (default: {min(5, len(tickers))}): ").strip()
            top_n = int(top_n_input) if top_n_input else min(5, len(tickers))

            run_factor_analysis(
                tickers=tickers,
                start_date=start_date,
                end_date=end_date,
                include_value=include_value,
                method=method,
                top_n=top_n
            )
        else:
            # Multi-asset backtest
            weighting_method = ui.get_weighting_method()

            capital_input = input("\nInitial capital (default: $100,000): ").strip()
            initial_capital = float(capital_input) if capital_input else 100000

            run_multi_asset_backtest(
                tickers=tickers,
                start_date=start_date,
                end_date=end_date,
                weighting_method=weighting_method,
                initial_capital=initial_capital
            )
    else:
        # Single ticker analysis
        mode = ui.get_analysis_mode()

        if mode == '4':
            # Enhanced backtest mode
            capital = input("\nInitial capital (default: $100,000): ").strip()
            initial_capital = float(capital) if capital else 100000
            run_enhanced_backtest(ticker_input, start_date, end_date, initial_capital)

        elif mode == '5':
            # Walk-forward analysis mode
            print("\n--- Walk-Forward Configuration ---")

            # Get parameters
            train_years_input = input("Training years (default: 8 for 2010-2018): ").strip()
            train_years = int(train_years_input) if train_years_input else 8

            test_years_input = input("Testing years (default: 4 for 2019-2022): ").strip()
            test_years = int(test_years_input) if test_years_input else 4

            window_type = input("Window type - (r)olling or (a)nchored (default: rolling): ").strip().lower()
            use_rolling = window_type != 'a'

            run_walk_forward_analysis(
                ticker=ticker_input,
                start_date=start_date,
                end_date=end_date,
                train_years=train_years,
                test_years=test_years,
                use_rolling=use_rolling
            )

        elif mode == '6':
            # Machine Learning mode
            print("\n--- Machine Learning Configuration ---")

            # Get parameters
            horizon_input = input("Prediction horizon in days (default: 5): ").strip()
            target_horizon = int(horizon_input) if horizon_input else 5

            print("\nModel type:")
            print("1. Linear Regression (predict return magnitude)")
            print("2. Logistic Regression (predict direction)")
            print("3. Both")

            model_choice = input("Choice (default: 3): ").strip()
            model_map = {'1': 'linear', '2': 'logistic', '3': 'both'}
            model_type = model_map.get(model_choice, 'both')

            run_ml_analysis(
                ticker=ticker_input,
                start_date=start_date,
                end_date=end_date,
                target_horizon=target_horizon,
                model_type=model_type
            )

        elif mode == '7':
            # Market regime analysis mode
            print("\n--- Market Regime Analysis ---")

            run_regime_analysis(
                ticker=ticker_input,
                start_date=start_date,
                end_date=end_date
            )

        else:
            # Standard analysis modes (1, 2, 3)
            analyze_single_ticker(ticker_input, start_date, end_date, mode)

    print("\n" + "="*80)
    print("Analysis Complete".center(80))
    print("="*80 + "\n")

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n\nExiting...\n")
    except Exception as e:
        print(f"\n\nError: {type(e).__name__}: {str(e)}\n")
        print("Please check your inputs and try again.\n")