lean_backtest_cli.py

"""
Lean Backtest CLI - Comprehensive Backtest Manager
===================================================
Features:
- Full statistics parsing (like QuantConnect web)
- Configurable via YAML (no hardcode)
- Audit trail & validation
- Report generation
- Compare backtests
"""

import json
import os
import sys
import subprocess
import shutil
from pathlib import Path
from datetime import datetime
from typing import Dict, Any, List, Optional, Tuple
from dataclasses import dataclass, field
import csv

# Optional imports
try:
    import yaml
    HAS_YAML = True
except ImportError:
    HAS_YAML = False

try:
    from rich.console import Console
    from rich.table import Table
    from rich.panel import Panel
    from rich.progress import Progress, SpinnerColumn, TextColumn
    from rich import box
    HAS_RICH = True
except ImportError:
    HAS_RICH = False

# Paths
LEAN_DIR = Path(__file__).parent
CONFIG_DIR = LEAN_DIR / "config"
DEFAULT_CONFIG = CONFIG_DIR / "backtest_config.yaml"

console = Console() if HAS_RICH else None


# ============================================================
# Configuration Manager
# ============================================================

@dataclass
class BacktestConfig:
    """Backtest configuration - loaded from YAML"""
    project_name: str = ""
    language: str = "python"
    start_date: str = "2020-01-01"
    end_date: str = "2023-12-31"
    starting_capital: float = 100000
    currency: str = "USD"
    account_type: str = "margin"
    leverage: float = 1.0
    resolution: str = "minute"
    benchmark: str = "SPY"
    save_trades: bool = True
    save_orders: bool = True
    generate_report: bool = True
    export_csv: bool = True
    
    # Validation thresholds
    min_sharpe: float = 0.5
    max_drawdown: float = 0.30
    min_trades: int = 10
    min_win_rate: float = 0.40
    min_psr: float = 0.50
    
    @classmethod
    def from_yaml(cls, path: Path) -> "BacktestConfig":
        """Load config from YAML file"""
        if not HAS_YAML:
            return cls()
        if not path.exists():
            return cls()
        
        with open(path, encoding="utf-8") as f:
            data = yaml.safe_load(f)
        
        config = cls()
        if data:
            # Project
            if "project" in data:
                config.project_name = data["project"].get("name", "")
                config.language = data["project"].get("language", "python")
            # Period
            if "period" in data:
                config.start_date = data["period"].get("start_date", "2020-01-01")
                config.end_date = data["period"].get("end_date", "2023-12-31")
            # Account
            if "account" in data:
                config.starting_capital = data["account"].get("starting_capital", 100000)
                config.currency = data["account"].get("currency", "USD")
                config.account_type = data["account"].get("account_type", "margin")
                config.leverage = data["account"].get("leverage", 1.0)
            # Data
            if "data" in data:
                config.resolution = data["data"].get("resolution", "minute")
            # Benchmark
            if "benchmark" in data:
                config.benchmark = data["benchmark"].get("symbol", "SPY")
            # Output
            if "output" in data:
                config.save_trades = data["output"].get("save_trades", True)
                config.save_orders = data["output"].get("save_orders", True)
                config.generate_report = data["output"].get("generate_report", True)
                config.export_csv = data["output"].get("export_csv", True)
            # Validation
            if "validation" in data:
                config.min_sharpe = data["validation"].get("min_sharpe", 0.5)
                config.max_drawdown = data["validation"].get("max_drawdown", 0.30)
                config.min_trades = data["validation"].get("min_trades", 10)
                config.min_win_rate = data["validation"].get("min_win_rate", 0.40)
                config.min_psr = data["validation"].get("min_psr", 0.50)
        
        return config


# ============================================================
# Backtest Result Parser
# ============================================================

@dataclass
class TradeStatistics:
    """Trade-level statistics"""
    total_trades: int = 0
    winning_trades: int = 0
    losing_trades: int = 0
    win_rate: float = 0.0
    loss_rate: float = 0.0
    avg_win: float = 0.0
    avg_loss: float = 0.0
    largest_win: float = 0.0
    largest_loss: float = 0.0
    profit_factor: float = 0.0
    profit_loss_ratio: float = 0.0
    avg_trade_duration: str = "00:00:00"
    max_consecutive_wins: int = 0
    max_consecutive_losses: int = 0
    max_drawdown: float = 0.0
    total_fees: float = 0.0


@dataclass
class PortfolioStatistics:
    """Portfolio-level statistics"""
    start_equity: float = 0.0
    end_equity: float = 0.0
    net_profit: float = 0.0
    net_profit_pct: float = 0.0
    cagr: float = 0.0
    sharpe_ratio: float = 0.0
    sortino_ratio: float = 0.0
    psr: float = 0.0  # Probabilistic Sharpe Ratio
    treynor_ratio: float = 0.0
    information_ratio: float = 0.0
    alpha: float = 0.0
    beta: float = 0.0
    drawdown: float = 0.0
    annual_std: float = 0.0
    annual_var: float = 0.0
    var_95: float = 0.0
    var_99: float = 0.0
    tracking_error: float = 0.0
    portfolio_turnover: float = 0.0
    expectancy: float = 0.0


@dataclass
class RuntimeStatistics:
    """Runtime statistics (banner stats)"""
    equity: str = "$0"
    fees: str = "$0"
    holdings: str = "$0"
    net_profit: str = "$0"
    psr: str = "0%"
    returns: str = "0%"
    unrealized: str = "$0"
    volume: str = "$0"


@dataclass
class BacktestState:
    """Backtest execution state"""
    start_time: str = ""
    end_time: str = ""
    status: str = ""
    runtime_error: str = ""
    log_count: int = 0
    order_count: int = 0
    insight_count: int = 0
    hostname: str = ""


@dataclass 
class AlgorithmConfig:
    """Algorithm configuration"""
    name: str = ""
    account_currency: str = "USD"
    start_date: str = ""
    end_date: str = ""
    trading_days_per_year: int = 252
    parameters: Dict[str, Any] = field(default_factory=dict)


@dataclass
class BacktestResult:
    """Complete backtest result"""
    backtest_id: str = ""
    project_name: str = ""
    backtest_dir: Path = None
    
    # Statistics
    statistics: Dict[str, str] = field(default_factory=dict)
    trade_stats: TradeStatistics = field(default_factory=TradeStatistics)
    portfolio_stats: PortfolioStatistics = field(default_factory=PortfolioStatistics)
    runtime_stats: RuntimeStatistics = field(default_factory=RuntimeStatistics)
    
    # State & Config
    state: BacktestState = field(default_factory=BacktestState)
    algo_config: AlgorithmConfig = field(default_factory=AlgorithmConfig)
    
    # Orders
    orders: List[Dict] = field(default_factory=list)
    
    # Rolling window
    rolling_window: Dict[str, Any] = field(default_factory=dict)
    
    # Validation
    validation_passed: bool = False
    validation_issues: List[str] = field(default_factory=list)


class BacktestResultParser:
    """Parse Lean backtest result files"""
    
    def __init__(self, backtest_dir: Path):
        self.backtest_dir = backtest_dir
        self.result = BacktestResult(backtest_dir=backtest_dir)
        
    def parse(self) -> BacktestResult:
        """Parse all result files"""
        # Find main result JSON
        json_files = list(self.backtest_dir.glob("*.json"))
        main_json = None
        summary_json = None
        order_events_json = None
        
        for f in json_files:
            name = f.name
            if "-summary.json" in name:
                summary_json = f
            elif "-order-events.json" in name:
                order_events_json = f
            elif "-alpha-results.json" not in name and "data-monitor" not in name:
                if not name.startswith("data-"):
                    main_json = f
        
        # Parse summary (preferred) or main JSON
        if summary_json and summary_json.exists():
            self._parse_summary(summary_json)
        elif main_json and main_json.exists():
            self._parse_main(main_json)
        
        # Parse order events
        if order_events_json and order_events_json.exists():
            self._parse_orders(order_events_json)
        
        # Extract backtest ID from filename
        if main_json:
            self.result.backtest_id = main_json.stem.split("-")[0]
        
        return self.result
    
    def _parse_summary(self, path: Path):
        """Parse summary JSON file"""
        with open(path, encoding="utf-8") as f:
            data = json.load(f)
        
        # Statistics (display format)
        if "statistics" in data:
            self.result.statistics = data["statistics"]
            self._extract_portfolio_stats_from_display(data["statistics"])
        
        # Runtime statistics
        if "runtimeStatistics" in data:
            rs = data["runtimeStatistics"]
            self.result.runtime_stats = RuntimeStatistics(
                equity=rs.get("Equity", "$0"),
                fees=rs.get("Fees", "$0"),
                holdings=rs.get("Holdings", "$0"),
                net_profit=rs.get("Net Profit", "$0"),
                psr=rs.get("Probabilistic Sharpe Ratio", "0%"),
                returns=rs.get("Return", "0%"),
                unrealized=rs.get("Unrealized", "$0"),
                volume=rs.get("Volume", "$0")
            )
        
        # State
        if "state" in data:
            s = data["state"]
            self.result.state = BacktestState(
                start_time=s.get("StartTime", ""),
                end_time=s.get("EndTime", ""),
                status=s.get("Status", ""),
                runtime_error=s.get("RuntimeError", ""),
                log_count=int(s.get("LogCount", 0)),
                order_count=int(s.get("OrderCount", 0)),
                insight_count=int(s.get("InsightCount", 0)),
                hostname=s.get("Hostname", "")
            )
        
        # Algorithm config
        if "algorithmConfiguration" in data:
            ac = data["algorithmConfiguration"]
            self.result.algo_config = AlgorithmConfig(
                name=ac.get("name", ""),
                account_currency=ac.get("accountCurrency", "USD"),
                start_date=ac.get("startDate", ""),
                end_date=ac.get("endDate", ""),
                trading_days_per_year=ac.get("tradingDaysPerYear", 252),
                parameters=ac.get("parameters", {})
            )
        
        # Total performance
        if "totalPerformance" in data:
            tp = data["totalPerformance"]
            if "tradeStatistics" in tp:
                self._parse_trade_stats(tp["tradeStatistics"])
            if "portfolioStatistics" in tp:
                self._parse_portfolio_stats(tp["portfolioStatistics"])
        
        # Rolling window
        if "rollingWindow" in data:
            self.result.rolling_window = data["rollingWindow"]
    
    def _parse_main(self, path: Path):
        """Parse main result JSON (fallback)"""
        with open(path, encoding="utf-8") as f:
            data = json.load(f)
        
        if "rollingWindow" in data:
            self.result.rolling_window = data["rollingWindow"]
            # Extract latest period stats
            for period, stats in data["rollingWindow"].items():
                if "portfolioStatistics" in stats:
                    self._parse_portfolio_stats(stats["portfolioStatistics"])
                    break
    
    def _parse_orders(self, path: Path):
        """Parse order events JSON"""
        with open(path, encoding="utf-8") as f:
            self.result.orders = json.load(f)
    
    def _parse_trade_stats(self, data: Dict):
        """Parse trade statistics"""
        self.result.trade_stats = TradeStatistics(
            total_trades=int(data.get("totalNumberOfTrades", 0)),
            winning_trades=int(data.get("numberOfWinningTrades", 0)),
            losing_trades=int(data.get("numberOfLosingTrades", 0)),
            win_rate=float(data.get("winRate", 0)),
            loss_rate=float(data.get("lossRate", 0)),
            avg_win=float(data.get("averageProfit", 0)),
            avg_loss=float(data.get("averageLoss", 0)),
            largest_win=float(data.get("largestProfit", 0)),
            largest_loss=float(data.get("largestLoss", 0)),
            profit_factor=float(data.get("profitFactor", 0)),
            profit_loss_ratio=float(data.get("profitLossRatio", 0)),
            avg_trade_duration=data.get("averageTradeDuration", "00:00:00"),
            max_consecutive_wins=int(data.get("maxConsecutiveWinningTrades", 0)),
            max_consecutive_losses=int(data.get("maxConsecutiveLosingTrades", 0)),
            max_drawdown=float(data.get("maximumClosedTradeDrawdown", 0)),
            total_fees=float(data.get("totalFees", 0))
        )
    
    def _parse_portfolio_stats(self, data: Dict):
        """Parse portfolio statistics"""
        self.result.portfolio_stats = PortfolioStatistics(
            start_equity=float(data.get("startEquity", 0)),
            end_equity=float(data.get("endEquity", 0)),
            net_profit_pct=float(data.get("totalNetProfit", 0)),
            cagr=float(data.get("compoundingAnnualReturn", 0)),
            sharpe_ratio=float(data.get("sharpeRatio", 0)),
            sortino_ratio=float(data.get("sortinoRatio", 0)),
            psr=float(data.get("probabilisticSharpeRatio", 0)),
            treynor_ratio=float(data.get("treynorRatio", 0)),
            information_ratio=float(data.get("informationRatio", 0)),
            alpha=float(data.get("alpha", 0)),
            beta=float(data.get("beta", 0)),
            drawdown=float(data.get("drawdown", 0)),
            annual_std=float(data.get("annualStandardDeviation", 0)),
            annual_var=float(data.get("annualVariance", 0)),
            var_95=float(data.get("valueAtRisk95", 0)),
            var_99=float(data.get("valueAtRisk99", 0)),
            tracking_error=float(data.get("trackingError", 0)),
            portfolio_turnover=float(data.get("portfolioTurnover", 0)),
            expectancy=float(data.get("expectancy", 0))
        )
        # Calculate net profit
        self.result.portfolio_stats.net_profit = (
            self.result.portfolio_stats.end_equity - 
            self.result.portfolio_stats.start_equity
        )
    
    def _extract_portfolio_stats_from_display(self, stats: Dict[str, str]):
        """Extract numeric values from display statistics"""
        def parse_pct(s: str) -> float:
            return float(s.replace("%", "").replace(",", "")) / 100 if s else 0
        
        def parse_num(s: str) -> float:
            return float(s.replace("$", "").replace(",", "").replace("%", "")) if s else 0
        
        ps = self.result.portfolio_stats
        ps.start_equity = parse_num(stats.get("Start Equity", "0"))
        ps.end_equity = parse_num(stats.get("End Equity", "0"))
        ps.net_profit = ps.end_equity - ps.start_equity
        ps.net_profit_pct = parse_pct(stats.get("Net Profit", "0%"))
        ps.cagr = parse_pct(stats.get("Compounding Annual Return", "0%"))
        ps.sharpe_ratio = parse_num(stats.get("Sharpe Ratio", "0"))
        ps.sortino_ratio = parse_num(stats.get("Sortino Ratio", "0"))
        ps.psr = parse_pct(stats.get("Probabilistic Sharpe Ratio", "0%"))
        ps.drawdown = parse_pct(stats.get("Drawdown", "0%"))
        ps.alpha = parse_num(stats.get("Alpha", "0"))
        ps.beta = parse_num(stats.get("Beta", "0"))
        ps.annual_std = parse_num(stats.get("Annual Standard Deviation", "0"))
        ps.portfolio_turnover = parse_pct(stats.get("Portfolio Turnover", "0%"))


# ============================================================
# Validation & Audit
# ============================================================

class BacktestValidator:
    """Validate backtest results against thresholds"""
    
    def __init__(self, config: BacktestConfig):
        self.config = config
        
    def validate(self, result: BacktestResult) -> Tuple[bool, List[str]]:
        """Validate backtest result, return (passed, issues)"""
        issues = []
        ps = result.portfolio_stats
        ts = result.trade_stats
        
        # Sharpe Ratio check
        if ps.sharpe_ratio < self.config.min_sharpe:
            issues.append(
                f"Sharpe Ratio ({ps.sharpe_ratio:.2f}) < minimum ({self.config.min_sharpe})"
            )
        
        # Drawdown check
        if ps.drawdown > self.config.max_drawdown:
            issues.append(
                f"Drawdown ({ps.drawdown:.1%}) > maximum ({self.config.max_drawdown:.1%})"
            )
        
        # Trade count check
        if ts.total_trades < self.config.min_trades:
            issues.append(
                f"Total trades ({ts.total_trades}) < minimum ({self.config.min_trades})"
            )
        
        # Win rate check (only if trades exist)
        if ts.total_trades > 0 and ts.win_rate < self.config.min_win_rate:
            issues.append(
                f"Win rate ({ts.win_rate:.1%}) < minimum ({self.config.min_win_rate:.1%})"
            )
        
        # PSR check
        if ps.psr < self.config.min_psr:
            issues.append(
                f"PSR ({ps.psr:.1%}) < minimum ({self.config.min_psr:.1%})"
            )
        
        # Check for runtime errors
        if result.state.runtime_error:
            issues.append(f"Runtime error: {result.state.runtime_error}")
        
        passed = len(issues) == 0
        result.validation_passed = passed
        result.validation_issues = issues
        
        return passed, issues


# ============================================================
# Report Generator
# ============================================================

class ReportGenerator:
    """Generate backtest reports"""
    
    def __init__(self, result: BacktestResult, config: BacktestConfig):
        self.result = result
        self.config = config
    
    def generate_text_report(self) -> str:
        """Generate text report"""
        lines = []
        r = self.result
        ps = r.portfolio_stats
        ts = r.trade_stats
        
        lines.append("=" * 60)
        lines.append("LEAN BACKTEST REPORT")
        lines.append("=" * 60)
        lines.append(f"Project: {r.project_name}")
        lines.append(f"Backtest ID: {r.backtest_id}")
        lines.append(f"Status: {r.state.status}")
        lines.append(f"Period: {r.algo_config.start_date} to {r.algo_config.end_date}")
        lines.append("")
        
        # Runtime Statistics (Banner)
        lines.append("-" * 60)
        lines.append("RUNTIME STATISTICS")
        lines.append("-" * 60)
        rs = r.runtime_stats
        lines.append(f"  Equity:     {rs.equity}")
        lines.append(f"  Return:     {rs.returns}")
        lines.append(f"  Net Profit: {rs.net_profit}")
        lines.append(f"  Fees:       {rs.fees}")
        lines.append(f"  Holdings:   {rs.holdings}")
        lines.append(f"  Unrealized: {rs.unrealized}")
        lines.append(f"  Volume:     {rs.volume}")
        lines.append(f"  PSR:        {rs.psr}")
        lines.append("")
        
        # Performance Metrics
        lines.append("-" * 60)
        lines.append("PERFORMANCE METRICS")
        lines.append("-" * 60)
        lines.append(f"  Start Equity:              ${ps.start_equity:,.2f}")
        lines.append(f"  End Equity:                ${ps.end_equity:,.2f}")
        lines.append(f"  Net Profit:                ${ps.net_profit:,.2f} ({ps.net_profit_pct:.2%})")
        lines.append(f"  CAGR:                      {ps.cagr:.2%}")
        lines.append(f"  Sharpe Ratio:              {ps.sharpe_ratio:.3f}")
        lines.append(f"  Sortino Ratio:             {ps.sortino_ratio:.3f}")
        lines.append(f"  Probabilistic Sharpe:      {ps.psr:.2%}")
        lines.append(f"  Treynor Ratio:             {ps.treynor_ratio:.3f}")
        lines.append(f"  Information Ratio:         {ps.information_ratio:.3f}")
        lines.append("")
        
        # Risk Metrics
        lines.append("-" * 60)
        lines.append("RISK METRICS")
        lines.append("-" * 60)
        lines.append(f"  Max Drawdown:              {ps.drawdown:.2%}")
        lines.append(f"  Annual Std Dev:            {ps.annual_std:.2%}")
        lines.append(f"  Annual Variance:           {ps.annual_var:.4f}")
        lines.append(f"  VaR 95%:                   {ps.var_95:.2%}")
        lines.append(f"  VaR 99%:                   {ps.var_99:.2%}")
        lines.append(f"  Alpha:                     {ps.alpha:.4f}")
        lines.append(f"  Beta:                      {ps.beta:.4f}")
        lines.append(f"  Tracking Error:            {ps.tracking_error:.4f}")
        lines.append(f"  Portfolio Turnover:        {ps.portfolio_turnover:.2%}")
        lines.append("")
        
        # Trade Statistics
        lines.append("-" * 60)
        lines.append("TRADE STATISTICS")
        lines.append("-" * 60)
        lines.append(f"  Total Trades:              {ts.total_trades}")
        lines.append(f"  Winning Trades:            {ts.winning_trades}")
        lines.append(f"  Losing Trades:             {ts.losing_trades}")
        lines.append(f"  Win Rate:                  {ts.win_rate:.2%}")
        lines.append(f"  Loss Rate:                 {ts.loss_rate:.2%}")
        lines.append(f"  Avg Win:                   ${ts.avg_win:,.2f}")
        lines.append(f"  Avg Loss:                  ${ts.avg_loss:,.2f}")
        lines.append(f"  Largest Win:               ${ts.largest_win:,.2f}")
        lines.append(f"  Largest Loss:              ${ts.largest_loss:,.2f}")
        lines.append(f"  Profit Factor:             {ts.profit_factor:.2f}")
        lines.append(f"  P/L Ratio:                 {ts.profit_loss_ratio:.2f}")
        lines.append(f"  Max Consecutive Wins:      {ts.max_consecutive_wins}")
        lines.append(f"  Max Consecutive Losses:    {ts.max_consecutive_losses}")
        lines.append(f"  Avg Trade Duration:        {ts.avg_trade_duration}")
        lines.append(f"  Total Fees:                ${ts.total_fees:,.2f}")
        lines.append("")
        
        # Validation
        lines.append("-" * 60)
        lines.append("VALIDATION")
        lines.append("-" * 60)
        if r.validation_passed:
            lines.append("  [PASS] All validation checks PASSED")
        else:
            lines.append("  [FAIL] Validation FAILED:")
            for issue in r.validation_issues:
                lines.append(f"    - {issue}")
        lines.append("")
        
        # Orders Summary
        if r.orders:
            lines.append("-" * 60)
            lines.append("ORDERS SUMMARY")
            lines.append("-" * 60)
            lines.append(f"  Total Order Events: {len(r.orders)}")
            filled = [o for o in r.orders if o.get("status") == "filled"]
            lines.append(f"  Filled Orders: {len(filled)}")
            if filled:
                total_volume = sum(
                    abs(o.get("fillQuantity", 0) * o.get("fillPrice", 0)) 
                    for o in filled
                )
                total_fees = sum(o.get("orderFeeAmount", 0) for o in filled)
                lines.append(f"  Total Volume: ${total_volume:,.2f}")
                lines.append(f"  Total Fees: ${total_fees:,.2f}")
        lines.append("")
        
        lines.append("=" * 60)
        lines.append(f"Generated: {datetime.now().isoformat()}")
        lines.append("=" * 60)
        
        return "\n".join(lines)
    
    def export_csv(self, output_path: Path):
        """Export statistics to CSV"""
        ps = self.result.portfolio_stats
        ts = self.result.trade_stats
        
        rows = [
            ["Metric", "Value"],
            ["Project", self.result.project_name],
            ["Backtest ID", self.result.backtest_id],
            ["Status", self.result.state.status],
            ["Start Date", self.result.algo_config.start_date],
            ["End Date", self.result.algo_config.end_date],
            ["", ""],
            ["PERFORMANCE", ""],
            ["Start Equity", ps.start_equity],
            ["End Equity", ps.end_equity],
            ["Net Profit", ps.net_profit],
            ["Net Profit %", ps.net_profit_pct],
            ["CAGR", ps.cagr],
            ["Sharpe Ratio", ps.sharpe_ratio],
            ["Sortino Ratio", ps.sortino_ratio],
            ["PSR", ps.psr],
            ["Treynor Ratio", ps.treynor_ratio],
            ["Information Ratio", ps.information_ratio],
            ["", ""],
            ["RISK", ""],
            ["Max Drawdown", ps.drawdown],
            ["Annual Std Dev", ps.annual_std],
            ["VaR 95%", ps.var_95],
            ["VaR 99%", ps.var_99],
            ["Alpha", ps.alpha],
            ["Beta", ps.beta],
            ["", ""],
            ["TRADES", ""],
            ["Total Trades", ts.total_trades],
            ["Win Rate", ts.win_rate],
            ["Loss Rate", ts.loss_rate],
            ["Profit Factor", ts.profit_factor],
            ["Total Fees", ts.total_fees],
            ["", ""],
            ["VALIDATION", ""],
            ["Passed", self.result.validation_passed],
        ]
        
        with open(output_path, "w", newline="", encoding="utf-8") as f:
            writer = csv.writer(f)
            writer.writerows(rows)


# ============================================================
# CLI Display Functions
# ============================================================

def print_banner():
    """Print CLI banner"""
    if HAS_RICH:
        console.print(Panel.fit(
            "[bold cyan]Lean Backtest CLI[/bold cyan]\n"
            "[dim]Comprehensive Backtest Analysis & Audit[/dim]",
            border_style="cyan"
        ))
    else:
        print("=" * 50)
        print("  LEAN BACKTEST CLI")
        print("  Comprehensive Backtest Analysis & Audit")
        print("=" * 50)


def print_result_summary(result: BacktestResult):
    """Print backtest result summary"""
    if HAS_RICH:
        _print_result_rich(result)
    else:
        _print_result_plain(result)


def _print_result_rich(result: BacktestResult):
    """Print result using Rich library"""
    ps = result.portfolio_stats
    ts = result.trade_stats
    rs = result.runtime_stats
    
    # Runtime Statistics Table (Banner)
    runtime_table = Table(title="Runtime Statistics", box=box.ROUNDED)
    runtime_table.add_column("Metric", style="cyan")
    runtime_table.add_column("Value", style="green")
    runtime_table.add_row("Equity", rs.equity)
    runtime_table.add_row("Return", rs.returns)
    runtime_table.add_row("Net Profit", rs.net_profit)
    runtime_table.add_row("Fees", rs.fees)
    runtime_table.add_row("Holdings", rs.holdings)
    runtime_table.add_row("Unrealized", rs.unrealized)
    runtime_table.add_row("Volume", rs.volume)
    runtime_table.add_row("PSR", rs.psr)
    console.print(runtime_table)
    console.print()
    
    # Performance Table
    perf_table = Table(title="Performance Metrics", box=box.ROUNDED)
    perf_table.add_column("Metric", style="cyan")
    perf_table.add_column("Value", style="green")
    perf_table.add_row("Start Equity", f"${ps.start_equity:,.2f}")
    perf_table.add_row("End Equity", f"${ps.end_equity:,.2f}")
    perf_table.add_row("Net Profit", f"${ps.net_profit:,.2f} ({ps.net_profit_pct:.2%})")
    perf_table.add_row("CAGR", f"{ps.cagr:.2%}")
    perf_table.add_row("Sharpe Ratio", f"{ps.sharpe_ratio:.3f}")
    perf_table.add_row("Sortino Ratio", f"{ps.sortino_ratio:.3f}")
    perf_table.add_row("PSR", f"{ps.psr:.2%}")
    perf_table.add_row("Treynor Ratio", f"{ps.treynor_ratio:.3f}")
    perf_table.add_row("Information Ratio", f"{ps.information_ratio:.3f}")
    console.print(perf_table)
    console.print()

    # Risk Table
    risk_table = Table(title="Risk Metrics", box=box.ROUNDED)
    risk_table.add_column("Metric", style="cyan")
    risk_table.add_column("Value", style="yellow")
    risk_table.add_row("Max Drawdown", f"{ps.drawdown:.2%}")
    risk_table.add_row("Annual Std Dev", f"{ps.annual_std:.2%}")
    risk_table.add_row("VaR 95%", f"{ps.var_95:.2%}")
    risk_table.add_row("VaR 99%", f"{ps.var_99:.2%}")
    risk_table.add_row("Alpha", f"{ps.alpha:.4f}")
    risk_table.add_row("Beta", f"{ps.beta:.4f}")
    risk_table.add_row("Tracking Error", f"{ps.tracking_error:.4f}")
    risk_table.add_row("Portfolio Turnover", f"{ps.portfolio_turnover:.2%}")
    console.print(risk_table)
    console.print()
    
    # Trade Statistics Table
    trade_table = Table(title="Trade Statistics", box=box.ROUNDED)
    trade_table.add_column("Metric", style="cyan")
    trade_table.add_column("Value", style="magenta")
    trade_table.add_row("Total Trades", str(ts.total_trades))
    trade_table.add_row("Winning Trades", str(ts.winning_trades))
    trade_table.add_row("Losing Trades", str(ts.losing_trades))
    trade_table.add_row("Win Rate", f"{ts.win_rate:.2%}")
    trade_table.add_row("Loss Rate", f"{ts.loss_rate:.2%}")
    trade_table.add_row("Avg Win", f"${ts.avg_win:,.2f}")
    trade_table.add_row("Avg Loss", f"${ts.avg_loss:,.2f}")
    trade_table.add_row("Profit Factor", f"{ts.profit_factor:.2f}")
    trade_table.add_row("Max Consecutive Wins", str(ts.max_consecutive_wins))
    trade_table.add_row("Max Consecutive Losses", str(ts.max_consecutive_losses))
    trade_table.add_row("Total Fees", f"${ts.total_fees:,.2f}")
    console.print(trade_table)
    console.print()
    
    # Validation Status
    if result.validation_passed:
        console.print(Panel("[bold green]✓ VALIDATION PASSED[/bold green]", border_style="green"))
    else:
        issues_text = "\n".join([f"• {i}" for i in result.validation_issues])
        console.print(Panel(
            f"[bold red]✗ VALIDATION FAILED[/bold red]\n\n{issues_text}",
            border_style="red"
        ))


def _print_result_plain(result: BacktestResult):
    """Print result without Rich"""
    ps = result.portfolio_stats
    ts = result.trade_stats
    rs = result.runtime_stats
    
    print("\n" + "=" * 50)
    print("RUNTIME STATISTICS")
    print("=" * 50)
    print(f"  Equity:     {rs.equity}")
    print(f"  Return:     {rs.returns}")
    print(f"  Net Profit: {rs.net_profit}")
    print(f"  Fees:       {rs.fees}")
    print(f"  PSR:        {rs.psr}")
    
    print("\n" + "-" * 50)
    print("PERFORMANCE METRICS")
    print("-" * 50)
    print(f"  Start Equity:    ${ps.start_equity:,.2f}")
    print(f"  End Equity:      ${ps.end_equity:,.2f}")
    print(f"  Net Profit:      ${ps.net_profit:,.2f} ({ps.net_profit_pct:.2%})")
    print(f"  CAGR:            {ps.cagr:.2%}")
    print(f"  Sharpe Ratio:    {ps.sharpe_ratio:.3f}")
    print(f"  Sortino Ratio:   {ps.sortino_ratio:.3f}")
    print(f"  PSR:             {ps.psr:.2%}")
    
    print("\n" + "-" * 50)
    print("RISK METRICS")
    print("-" * 50)
    print(f"  Max Drawdown:    {ps.drawdown:.2%}")
    print(f"  Annual Std Dev:  {ps.annual_std:.2%}")
    print(f"  VaR 95%:         {ps.var_95:.2%}")
    print(f"  VaR 99%:         {ps.var_99:.2%}")
    print(f"  Alpha:           {ps.alpha:.4f}")
    print(f"  Beta:            {ps.beta:.4f}")
    
    print("\n" + "-" * 50)
    print("TRADE STATISTICS")
    print("-" * 50)
    print(f"  Total Trades:    {ts.total_trades}")
    print(f"  Win Rate:        {ts.win_rate:.2%}")
    print(f"  Profit Factor:   {ts.profit_factor:.2f}")
    print(f"  Total Fees:      ${ts.total_fees:,.2f}")
    
    print("\n" + "-" * 50)
    print("VALIDATION")
    print("-" * 50)
    if result.validation_passed:
        print("  ✓ All checks PASSED")
    else:
        print("  ✗ FAILED:")
        for issue in result.validation_issues:
            print(f"    - {issue}")


# ============================================================
# Backtest Runner
# ============================================================

class LeanBacktestRunner:
    """Run and manage Lean backtests"""
    
    def __init__(self, config: BacktestConfig):
        self.config = config
        self.lean_dir = LEAN_DIR
        
    def check_prerequisites(self) -> Tuple[bool, List[str]]:
        """Check if all prerequisites are met"""
        issues = []
        
        # Check lean CLI
        if not shutil.which("lean"):
            issues.append("Lean CLI not installed (pip install lean)")
        
        # Check Docker
        try:
            result = subprocess.run(
                "docker info", shell=True, capture_output=True, timeout=5
            )
            if result.returncode != 0:
                issues.append("Docker not running")
        except:
            issues.append("Docker check failed")
        
        # Check Docker image
        try:
            result = subprocess.run(
                'docker images quantconnect/lean --format "{{.Repository}}"',
                shell=True, capture_output=True, text=True, timeout=5
            )
            if "quantconnect/lean" not in result.stdout:
                issues.append("Docker image not found (docker pull quantconnect/lean:latest)")
        except:
            pass
        
        return len(issues) == 0, issues
    
    def list_projects(self) -> List[Dict[str, Any]]:
        """List all Lean projects"""
        projects = []
        for item in self.lean_dir.iterdir():
            if item.is_dir() and (item / "main.py").exists():
                # Get latest backtest
                backtests_dir = item / "backtests"
                latest_backtest = None
                if backtests_dir.exists():
                    backtest_dirs = sorted(backtests_dir.iterdir(), reverse=True)
                    if backtest_dirs:
                        latest_backtest = backtest_dirs[0].name
                
                projects.append({
                    "name": item.name,
                    "path": str(item),
                    "latest_backtest": latest_backtest
                })
        return projects
    
    def list_backtests(self, project_name: str) -> List[Dict[str, Any]]:
        """List all backtests for a project"""
        backtests = []
        project_dir = self.lean_dir / project_name
        backtests_dir = project_dir / "backtests"
        
        if not backtests_dir.exists():
            return backtests
        
        for bt_dir in sorted(backtests_dir.iterdir(), reverse=True):
            if bt_dir.is_dir():
                # Find summary JSON
                summary_files = list(bt_dir.glob("*-summary.json"))
                status = "unknown"
                if summary_files:
                    try:
                        with open(summary_files[0], encoding="utf-8") as f:
                            data = json.load(f)
                            status = data.get("state", {}).get("Status", "unknown")
                    except:
                        pass
                
                backtests.append({
                    "name": bt_dir.name,
                    "path": str(bt_dir),
                    "status": status
                })
        
        return backtests

    
    def run_backtest(self, project_name: str, timeout: int = 600) -> Tuple[bool, str, Optional[Path]]:
        """Run backtest for a project"""
        project_dir = self.lean_dir / project_name
        if not project_dir.exists():
            return False, f"Project '{project_name}' not found", None
        
        print(f"\nRunning backtest for {project_name}...")
        print("(This may take several minutes...)\n")
        
        try:
            result = subprocess.run(
                f'lean backtest "{project_name}"',
                shell=True,
                capture_output=True,
                text=True,
                timeout=timeout,
                cwd=str(self.lean_dir)
            )
            
            # Find latest backtest directory
            backtests_dir = project_dir / "backtests"
            if backtests_dir.exists():
                backtest_dirs = sorted(backtests_dir.iterdir(), reverse=True)
                if backtest_dirs:
                    return result.returncode == 0, result.stdout + result.stderr, backtest_dirs[0]
            
            return result.returncode == 0, result.stdout + result.stderr, None
            
        except subprocess.TimeoutExpired:
            return False, f"Backtest timeout ({timeout}s)", None
        except Exception as e:
            return False, str(e), None
    
    def parse_backtest(self, backtest_dir: Path) -> BacktestResult:
        """Parse backtest results"""
        parser = BacktestResultParser(backtest_dir)
        result = parser.parse()
        
        # Run validation
        validator = BacktestValidator(self.config)
        validator.validate(result)
        
        return result
    
    def generate_report(self, result: BacktestResult, output_dir: Optional[Path] = None) -> Path:
        """Generate backtest report"""
        if output_dir is None:
            output_dir = result.backtest_dir
        
        generator = ReportGenerator(result, self.config)
        
        # Text report
        report_text = generator.generate_text_report()
        report_path = output_dir / "audit_report.txt"
        report_path.write_text(report_text, encoding="utf-8")
        
        # CSV export
        if self.config.export_csv:
            csv_path = output_dir / "statistics.csv"
            generator.export_csv(csv_path)
        
        return report_path


# ============================================================
# Compare Backtests
# ============================================================

def compare_backtests(results: List[BacktestResult]) -> None:
    """Compare multiple backtest results"""
    if len(results) < 2:
        print("Need at least 2 backtests to compare")
        return
    
    if HAS_RICH:
        table = Table(title="Backtest Comparison", box=box.ROUNDED)
        table.add_column("Metric", style="cyan")
        for r in results:
            table.add_column(r.backtest_id[:10], style="green")
        
        # Performance metrics
        table.add_row("Net Profit %", *[f"{r.portfolio_stats.net_profit_pct:.2%}" for r in results])
        table.add_row("CAGR", *[f"{r.portfolio_stats.cagr:.2%}" for r in results])
        table.add_row("Sharpe", *[f"{r.portfolio_stats.sharpe_ratio:.3f}" for r in results])
        table.add_row("Sortino", *[f"{r.portfolio_stats.sortino_ratio:.3f}" for r in results])
        table.add_row("PSR", *[f"{r.portfolio_stats.psr:.2%}" for r in results])
        table.add_row("Max DD", *[f"{r.portfolio_stats.drawdown:.2%}" for r in results])
        table.add_row("Win Rate", *[f"{r.trade_stats.win_rate:.2%}" for r in results])
        table.add_row("Trades", *[str(r.trade_stats.total_trades) for r in results])
        table.add_row("Validation", *["PASS" if r.validation_passed else "FAIL" for r in results])
        
        console.print(table)
    else:
        print("\nBacktest Comparison")
        print("-" * 60)
        headers = ["Metric"] + [r.backtest_id[:10] for r in results]
        print("  ".join(f"{h:>12}" for h in headers))
        print("-" * 60)
        
        metrics = [
            ("Net Profit %", [f"{r.portfolio_stats.net_profit_pct:.2%}" for r in results]),
            ("Sharpe", [f"{r.portfolio_stats.sharpe_ratio:.3f}" for r in results]),
            ("Max DD", [f"{r.portfolio_stats.drawdown:.2%}" for r in results]),
            ("Win Rate", [f"{r.trade_stats.win_rate:.2%}" for r in results]),
        ]
        for name, values in metrics:
            row = [name] + values
            print("  ".join(f"{v:>12}" for v in row))


# ============================================================
# Interactive CLI Menu
# ============================================================

def cli_menu():
    """Interactive CLI menu"""
    print_banner()
    
    # Load config
    config = BacktestConfig.from_yaml(DEFAULT_CONFIG)
    runner = LeanBacktestRunner(config)
    
    while True:
        print("\n" + "=" * 50)
        print("  MENU")
        print("=" * 50)
        print("  1. Check Prerequisites")
        print("  2. List Projects")
        print("  3. List Backtests")
        print("  4. Run Backtest")
        print("  5. Analyze Backtest Result")
        print("  6. Compare Backtests")
        print("  7. Generate Report")
        print("  8. Show All Statistics")
        print("  9. Edit Config")
        print("  0. Exit")
        print("=" * 50)
        
        try:
            choice = input("\nSelect [0-9]: ").strip()
        except (KeyboardInterrupt, EOFError):
            print("\nBye!")
            break
        
        if choice == "0":
            print("Bye!")
            break
        
        elif choice == "1":
            # Check prerequisites
            ok, issues = runner.check_prerequisites()
            if ok:
                print("\n✓ All prerequisites met!")
            else:
                print("\n✗ Issues found:")
                for issue in issues:
                    print(f"  - {issue}")
        
        elif choice == "2":
            # List projects
            projects = runner.list_projects()
            if not projects:
                print("\nNo projects found")
            else:
                print(f"\nFound {len(projects)} projects:")
                for i, p in enumerate(projects, 1):
                    latest = p.get("latest_backtest", "none")
                    print(f"  {i}. {p['name']} (latest: {latest})")
        
        elif choice == "3":
            # List backtests
            projects = runner.list_projects()
            if not projects:
                print("\nNo projects found")
                continue
            
            print("\nSelect project:")
            for i, p in enumerate(projects, 1):
                print(f"  {i}. {p['name']}")
            
            try:
                idx = int(input("Project number: ")) - 1
                project = projects[idx]
                backtests = runner.list_backtests(project["name"])
                
                if not backtests:
                    print(f"\nNo backtests for {project['name']}")
                else:
                    print(f"\nBacktests for {project['name']}:")
                    for i, bt in enumerate(backtests, 1):
                        print(f"  {i}. {bt['name']} [{bt['status']}]")
            except (ValueError, IndexError):
                print("Invalid selection")

        
        elif choice == "4":
            # Run backtest
            projects = runner.list_projects()
            if not projects:
                print("\nNo projects found")
                continue
            
            print("\nSelect project to backtest:")
            for i, p in enumerate(projects, 1):
                print(f"  {i}. {p['name']}")
            
            try:
                idx = int(input("Project number: ")) - 1
                project = projects[idx]
                
                success, output, bt_dir = runner.run_backtest(project["name"])
                
                if success and bt_dir:
                    print(f"\n✓ Backtest completed!")
                    print(f"  Results: {bt_dir}")
                    
                    # Parse and show summary
                    result = runner.parse_backtest(bt_dir)
                    result.project_name = project["name"]
                    print_result_summary(result)
                    
                    # Generate report
                    report_path = runner.generate_report(result)
                    print(f"\n  Report: {report_path}")
                else:
                    print(f"\n✗ Backtest failed:")
                    print(output[-2000:] if len(output) > 2000 else output)
            except (ValueError, IndexError):
                print("Invalid selection")
        
        elif choice == "5":
            # Analyze existing backtest
            projects = runner.list_projects()
            if not projects:
                print("\nNo projects found")
                continue
            
            print("\nSelect project:")
            for i, p in enumerate(projects, 1):
                print(f"  {i}. {p['name']}")
            
            try:
                idx = int(input("Project number: ")) - 1
                project = projects[idx]
                backtests = runner.list_backtests(project["name"])
                
                if not backtests:
                    print(f"\nNo backtests for {project['name']}")
                    continue
                
                print(f"\nSelect backtest:")
                for i, bt in enumerate(backtests, 1):
                    print(f"  {i}. {bt['name']} [{bt['status']}]")
                
                bt_idx = int(input("Backtest number: ")) - 1
                bt = backtests[bt_idx]
                
                result = runner.parse_backtest(Path(bt["path"]))
                result.project_name = project["name"]
                print_result_summary(result)
                
            except (ValueError, IndexError):
                print("Invalid selection")

        
        elif choice == "6":
            # Compare backtests
            projects = runner.list_projects()
            if not projects:
                print("\nNo projects found")
                continue
            
            print("\nSelect project:")
            for i, p in enumerate(projects, 1):
                print(f"  {i}. {p['name']}")
            
            try:
                idx = int(input("Project number: ")) - 1
                project = projects[idx]
                backtests = runner.list_backtests(project["name"])
                
                if len(backtests) < 2:
                    print(f"\nNeed at least 2 backtests to compare")
                    continue
                
                print(f"\nSelect backtests to compare (comma-separated, e.g., 1,2,3):")
                for i, bt in enumerate(backtests, 1):
                    print(f"  {i}. {bt['name']}")
                
                selection = input("Backtest numbers: ").strip()
                indices = [int(x.strip()) - 1 for x in selection.split(",")]
                
                results = []
                for i in indices:
                    bt = backtests[i]
                    result = runner.parse_backtest(Path(bt["path"]))
                    result.project_name = project["name"]
                    results.append(result)
                
                compare_backtests(results)
                
            except (ValueError, IndexError):
                print("Invalid selection")
        
        elif choice == "7":
            # Generate report
            projects = runner.list_projects()
            if not projects:
                print("\nNo projects found")
                continue
            
            print("\nSelect project:")
            for i, p in enumerate(projects, 1):
                print(f"  {i}. {p['name']}")
            
            try:
                idx = int(input("Project number: ")) - 1
                project = projects[idx]
                backtests = runner.list_backtests(project["name"])
                
                if not backtests:
                    print(f"\nNo backtests for {project['name']}")
                    continue
                
                print(f"\nSelect backtest:")
                for i, bt in enumerate(backtests, 1):
                    print(f"  {i}. {bt['name']}")
                
                bt_idx = int(input("Backtest number: ")) - 1
                bt = backtests[bt_idx]
                
                result = runner.parse_backtest(Path(bt["path"]))
                result.project_name = project["name"]
                
                report_path = runner.generate_report(result)
                print(f"\n✓ Report generated: {report_path}")
                
            except (ValueError, IndexError):
                print("Invalid selection")

        
        elif choice == "8":
            # Show all statistics from display format
            projects = runner.list_projects()
            if not projects:
                print("\nNo projects found")
                continue
            
            print("\nSelect project:")
            for i, p in enumerate(projects, 1):
                print(f"  {i}. {p['name']}")
            
            try:
                idx = int(input("Project number: ")) - 1
                project = projects[idx]
                backtests = runner.list_backtests(project["name"])
                
                if not backtests:
                    print(f"\nNo backtests for {project['name']}")
                    continue
                
                print(f"\nSelect backtest:")
                for i, bt in enumerate(backtests, 1):
                    print(f"  {i}. {bt['name']}")
                
                bt_idx = int(input("Backtest number: ")) - 1
                bt = backtests[bt_idx]
                
                result = runner.parse_backtest(Path(bt["path"]))
                
                # Show raw statistics
                print("\n" + "=" * 50)
                print("ALL STATISTICS (Raw from Lean)")
                print("=" * 50)
                for key, value in sorted(result.statistics.items()):
                    print(f"  {key}: {value}")
                
            except (ValueError, IndexError):
                print("Invalid selection")
        
        elif choice == "9":
            # Edit config
            config_path = DEFAULT_CONFIG
            print(f"\nConfig file: {config_path}")
            if config_path.exists():
                print("Current validation thresholds:")
                print(f"  min_sharpe: {config.min_sharpe}")
                print(f"  max_drawdown: {config.max_drawdown}")
                print(f"  min_trades: {config.min_trades}")
                print(f"  min_win_rate: {config.min_win_rate}")
                print(f"  min_psr: {config.min_psr}")
                print(f"\nEdit the YAML file to change settings.")
            else:
                print("Config file not found. Creating default...")
                CONFIG_DIR.mkdir(parents=True, exist_ok=True)
                # Would create default config here
        
        else:
            print("Invalid choice")


# ============================================================
# Command Line Interface
# ============================================================

def main():
    """Main entry point"""
    import argparse
    
    parser = argparse.ArgumentParser(
        description="Lean Backtest CLI - Comprehensive Analysis & Audit",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python lean_backtest_cli.py menu              # Interactive menu
  python lean_backtest_cli.py list              # List projects
  python lean_backtest_cli.py run -p MyStrategy # Run backtest
  python lean_backtest_cli.py analyze -p MyStrategy -b 2026-01-21_00-59-02
  python lean_backtest_cli.py report -p MyStrategy -b latest
  python lean_backtest_cli.py compare -p MyStrategy -b 1,2,3
        """
    )
    
    subparsers = parser.add_subparsers(dest="command", help="Commands")
    
    # Menu command
    subparsers.add_parser("menu", help="Interactive menu")
    
    # List command
    subparsers.add_parser("list", help="List projects")
    
    # Run command
    run_parser = subparsers.add_parser("run", help="Run backtest")
    run_parser.add_argument("-p", "--project", required=True, help="Project name")
    run_parser.add_argument("-t", "--timeout", type=int, default=600, help="Timeout in seconds")
    
    # Analyze command
    analyze_parser = subparsers.add_parser("analyze", help="Analyze backtest result")
    analyze_parser.add_argument("-p", "--project", required=True, help="Project name")
    analyze_parser.add_argument("-b", "--backtest", default="latest", help="Backtest name or 'latest'")
    
    # Report command
    report_parser = subparsers.add_parser("report", help="Generate report")
    report_parser.add_argument("-p", "--project", required=True, help="Project name")
    report_parser.add_argument("-b", "--backtest", default="latest", help="Backtest name or 'latest'")
    report_parser.add_argument("-o", "--output", help="Output directory")
    
    # Compare command
    compare_parser = subparsers.add_parser("compare", help="Compare backtests")
    compare_parser.add_argument("-p", "--project", required=True, help="Project name")
    compare_parser.add_argument("-b", "--backtests", required=True, help="Backtest indices (comma-separated)")
    
    # Check command
    subparsers.add_parser("check", help="Check prerequisites")
    
    # Config command
    config_parser = subparsers.add_parser("config", help="Show/edit config")
    config_parser.add_argument("--show", action="store_true", help="Show current config")
    
    args = parser.parse_args()
    
    # Load config
    config = BacktestConfig.from_yaml(DEFAULT_CONFIG)
    runner = LeanBacktestRunner(config)
    
    try:
        if args.command == "menu" or args.command is None:
            cli_menu()
        
        elif args.command == "list":
            print_banner()
            projects = runner.list_projects()
            if not projects:
                print("No projects found")
            else:
                print(f"\nFound {len(projects)} projects:")
                for p in projects:
                    latest = p.get("latest_backtest", "none")
                    print(f"  • {p['name']} (latest: {latest})")

        
        elif args.command == "run":
            print_banner()
            success, output, bt_dir = runner.run_backtest(args.project, args.timeout)
            
            if success and bt_dir:
                print(f"\n✓ Backtest completed!")
                result = runner.parse_backtest(bt_dir)
                result.project_name = args.project
                print_result_summary(result)
                
                report_path = runner.generate_report(result)
                print(f"\nReport: {report_path}")
            else:
                print(f"\n✗ Backtest failed:")
                print(output[-2000:] if len(output) > 2000 else output)
        
        elif args.command == "analyze":
            print_banner()
            backtests = runner.list_backtests(args.project)
            
            if not backtests:
                print(f"No backtests for {args.project}")
                return
            
            # Find backtest
            if args.backtest == "latest":
                bt = backtests[0]
            else:
                bt = next((b for b in backtests if args.backtest in b["name"]), None)
                if not bt:
                    print(f"Backtest '{args.backtest}' not found")
                    return
            
            result = runner.parse_backtest(Path(bt["path"]))
            result.project_name = args.project
            print_result_summary(result)
        
        elif args.command == "report":
            print_banner()
            backtests = runner.list_backtests(args.project)
            
            if not backtests:
                print(f"No backtests for {args.project}")
                return
            
            if args.backtest == "latest":
                bt = backtests[0]
            else:
                bt = next((b for b in backtests if args.backtest in b["name"]), None)
                if not bt:
                    print(f"Backtest '{args.backtest}' not found")
                    return
            
            result = runner.parse_backtest(Path(bt["path"]))
            result.project_name = args.project
            
            output_dir = Path(args.output) if args.output else None
            report_path = runner.generate_report(result, output_dir)
            print(f"✓ Report generated: {report_path}")
        
        elif args.command == "compare":
            print_banner()
            backtests = runner.list_backtests(args.project)
            
            if len(backtests) < 2:
                print("Need at least 2 backtests to compare")
                return
            
            indices = [int(x.strip()) - 1 for x in args.backtests.split(",")]
            results = []
            for i in indices:
                if 0 <= i < len(backtests):
                    bt = backtests[i]
                    result = runner.parse_backtest(Path(bt["path"]))
                    result.project_name = args.project
                    results.append(result)
            
            if len(results) >= 2:
                compare_backtests(results)
            else:
                print("Not enough valid backtests selected")
        
        elif args.command == "check":
            print_banner()
            ok, issues = runner.check_prerequisites()
            if ok:
                print("\n✓ All prerequisites met!")
            else:
                print("\n✗ Issues found:")
                for issue in issues:
                    print(f"  - {issue}")
        
        elif args.command == "config":
            print_banner()
            print(f"\nConfig file: {DEFAULT_CONFIG}")
            print(f"\nValidation Thresholds:")
            print(f"  min_sharpe:    {config.min_sharpe}")
            print(f"  max_drawdown:  {config.max_drawdown}")
            print(f"  min_trades:    {config.min_trades}")
            print(f"  min_win_rate:  {config.min_win_rate}")
            print(f"  min_psr:       {config.min_psr}")
    
    except KeyboardInterrupt:
        print("\nInterrupted")
    except Exception as e:
        print(f"Error: {e}")
        raise


if __name__ == "__main__":
    main()