app.py

"""
HORIZON PORTFOLIO BACKTESTER
A Portfolio Visualizer clone built with Gradio
Deploy to Hugging Face Spaces

Features:
- Interactive UI for portfolio backtesting
- REST API endpoint for programmatic access
- Claude AI integration for natural language queries
"""

import gradio as gr
import yfinance as yf
import pandas as pd
import numpy as np
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
from datetime import datetime, timedelta
import warnings
import json
import os
import re
import httpx
warnings.filterwarnings('ignore')

# Claude API configuration
ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
CLAUDE_MODEL = "claude-sonnet-4-20250514"

# Preset portfolios
PRESETS = {
    "Custom": [],
    "Horizon Growth": [
        'BLK', 'COST', 'GS', 'SPOT', 'META', 'CRWD', 'MSFT', 'V', 'GOOGL', 'AAPL',
        'COIN', 'TTWO', 'AMZN', 'HWM', 'NET', 'NVDA', 'PLTR', 'FUTU', 'RY', 'WMT',
        'HOOD', 'NFLX', 'UBER', 'SFTBY', 'TQQQ'
    ],
    "FAANG": ['META', 'AAPL', 'AMZN', 'NFLX', 'GOOGL'],
    "Magnificent 7": ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'NVDA', 'META', 'TSLA'],
    "Classic 60/40": ['VTI', 'BND'],
    "Three Fund Portfolio": ['VTI', 'VXUS', 'BND'],
    "All Weather": ['VTI', 'TLT', 'IEF', 'GLD', 'DBC'],
}

DEFAULT_BENCHMARKS = ['QQQ', 'SPY', 'VTI', 'IWM', 'DIA', 'VOO']

# Local data directory
DATA_DIR = os.path.join(os.path.dirname(__file__), 'data')


def get_available_tickers():
    """Get list of all tickers available in the local data directory"""
    tickers = []
    if os.path.exists(DATA_DIR):
        for filename in os.listdir(DATA_DIR):
            if filename.endswith('.csv'):
                ticker = filename.replace('.csv', '')
                tickers.append(ticker)
    # Sort alphabetically, but put common benchmarks first
    benchmark_order = ['QQQ', 'SPY', 'VTI', 'IWM', 'DIA', 'VOO']
    sorted_tickers = []
    for b in benchmark_order:
        if b in tickers:
            sorted_tickers.append(b)
            tickers.remove(b)
    sorted_tickers.extend(sorted(tickers))
    return sorted_tickers if sorted_tickers else DEFAULT_BENCHMARKS


# Dynamic benchmark list from available data
BENCHMARKS = get_available_tickers()

# Request queue file
REQUESTS_FILE = os.path.join(os.path.dirname(__file__), 'requests.txt')


def is_ticker_available(ticker: str) -> bool:
    """Check if a ticker is available in the local dataset"""
    ticker = ticker.strip().upper()
    filepath = os.path.join(DATA_DIR, f'{ticker}.csv')
    return os.path.exists(filepath)


def request_ticker(ticker: str) -> dict:
    """
    Add a ticker to the request queue.
    Returns status of the request.
    """
    ticker = ticker.strip().upper()
    
    # Validate ticker format
    if not ticker or not ticker.isalpha() or len(ticker) > 5:
        return {
            "success": False,
            "message": f"Invalid ticker format: {ticker}. Use 1-5 letters only."
        }
    
    # Check if already available
    if is_ticker_available(ticker):
        return {
            "success": False,
            "message": f"{ticker} is already available in the dataset!"
        }
    
    # Check if already requested
    pending = get_pending_requests()
    if ticker in pending:
        return {
            "success": False,
            "message": f"{ticker} is already in the request queue."
        }
    
    # Add to request file
    try:
        with open(REQUESTS_FILE, 'a') as f:
            f.write(f"{ticker}\n")
        return {
            "success": True,
            "message": f"✅ {ticker} added to request queue! It will be available after the next data update (daily at ~9:30 PM UTC)."
        }
    except Exception as e:
        return {
            "success": False,
            "message": f"Error adding request: {e}"
        }


def get_pending_requests() -> list:
    """Get list of pending ticker requests"""
    if not os.path.exists(REQUESTS_FILE):
        return []
    try:
        with open(REQUESTS_FILE, 'r') as f:
            return [line.strip().upper() for line in f if line.strip()]
    except Exception:
        return []


def check_tickers_availability(tickers: list) -> dict:
    """
    Check which tickers are available and which are missing.
    Returns dict with 'available' and 'missing' lists.
    """
    available = []
    missing = []
    for ticker in tickers:
        ticker = ticker.strip().upper()
        if is_ticker_available(ticker):
            available.append(ticker)
        else:
            missing.append(ticker)
    return {"available": available, "missing": missing}


def load_local_data(ticker, start_date, end_date):
    """Load data from local CSV if available"""
    filepath = os.path.join(DATA_DIR, f'{ticker}.csv')
    if os.path.exists(filepath):
        try:
            df = pd.read_csv(filepath, index_col=0, parse_dates=True)
            # Filter to date range
            df = df[(df.index >= start_date) & (df.index <= end_date)]
            if not df.empty:
                return df
        except Exception:
            pass
    return None


def get_price_data(tickers, start_date, end_date):
    """
    Get price data - tries local files first, falls back to yfinance.
    Returns DataFrame with Close prices.
    """
    close_data = {}
    missing_tickers = []
    
    # Try local data first
    for ticker in tickers:
        local = load_local_data(ticker, start_date, end_date)
        if local is not None and 'Close' in local.columns:
            close_data[ticker] = local['Close']
        else:
            missing_tickers.append(ticker)
    
    # Download missing tickers from yfinance
    if missing_tickers:
        try:
            data = yf.download(
                missing_tickers, 
                start=start_date, 
                end=end_date, 
                auto_adjust=True, 
                progress=False,
                threads=False
            )
            if not data.empty:
                if len(missing_tickers) == 1:
                    if 'Close' in data.columns:
                        close_data[missing_tickers[0]] = data['Close']
                else:
                    for ticker in missing_tickers:
                        if ticker in data['Close'].columns:
                            close_data[ticker] = data['Close'][ticker]
        except Exception as e:
            print(f"yfinance error: {e}")
    
    # Combine into DataFrame
    if close_data:
        result = pd.DataFrame(close_data)
        result = result.dropna(how='all')
        return result
    return pd.DataFrame()


# ===== CLAUDE API INTEGRATION =====

def call_claude_api(prompt: str, system_prompt: str = None) -> str:
    """Call Claude API to parse natural language backtest requests"""
    
    if not ANTHROPIC_API_KEY:
        return None
    
    headers = {
        "x-api-key": ANTHROPIC_API_KEY,
        "content-type": "application/json",
        "anthropic-version": "2023-06-01"
    }
    
    system = system_prompt or """You are a portfolio backtesting assistant. 
    Parse user requests into structured backtest parameters.
    Always respond with valid JSON only, no other text."""
    
    data = {
        "model": CLAUDE_MODEL,
        "max_tokens": 1024,
        "system": system,
        "messages": [{"role": "user", "content": prompt}]
    }
    
    try:
        with httpx.Client(timeout=30) as client:
            response = client.post(
                "https://api.anthropic.com/v1/messages",
                headers=headers,
                json=data
            )
            response.raise_for_status()
            result = response.json()
            return result["content"][0]["text"]
    except Exception as e:
        print(f"Claude API error: {e}")
        return None


def parse_natural_language_request(user_request: str) -> dict:
    """Use Claude to parse a natural language backtest request into parameters"""
    
    system_prompt = """You are a portfolio backtesting assistant. Parse the user's request into backtest parameters.

Available presets: "Custom", "Horizon Growth", "FAANG", "Magnificent 7", "Classic 60/40", "Three Fund Portfolio", "All Weather"
Benchmark: Any stock ticker can be used as benchmark (common ones: QQQ, SPY, VTI, IWM, NVDA, AAPL, etc.)
Contribution frequencies: "None", "Weekly", "Monthly", "Quarterly"
Rebalancing frequencies: "None", "Monthly", "Quarterly", "Annually"

Respond ONLY with a JSON object in this exact format (no other text):
{
    "preset": "preset name or Custom",
    "tickers": ["AAPL", "MSFT"] or null if using preset,
    "benchmark": "QQQ",
    "start_date": "2024-01-01" or "1y" or "5y",
    "initial_investment": 10000,
    "contribution_amount": 1000,
    "contribution_freq": "Weekly",
    "rebalance_freq": "None",
    "explanation": "Brief explanation of what you understood"
}

If the user mentions specific stocks, use "Custom" preset and list them in tickers.
If they mention a preset name, use that preset.
Any ticker can be used as benchmark - if user says "compare against NVDA" or "benchmark to AAPL", use that ticker.
Default to reasonable values if not specified."""

    response = call_claude_api(user_request, system_prompt)
    
    if not response:
        # Return defaults if Claude API fails
        return {
            "preset": "Horizon Growth",
            "tickers": None,
            "benchmark": "QQQ",
            "start_date": "2024-01-01",
            "initial_investment": 10000,
            "contribution_amount": 1000,
            "contribution_freq": "Weekly",
            "rebalance_freq": "None",
            "explanation": "Using defaults (Claude API not available)"
        }
    
    try:
        # Clean up response - remove markdown code blocks if present
        cleaned = response.strip()
        if cleaned.startswith("```"):
            cleaned = re.sub(r'^```json?\n?', '', cleaned)
            cleaned = re.sub(r'\n?```$', '', cleaned)
        return json.loads(cleaned)
    except json.JSONDecodeError:
        return {
            "preset": "Horizon Growth",
            "tickers": None,
            "benchmark": "QQQ", 
            "start_date": "2024-01-01",
            "initial_investment": 10000,
            "contribution_amount": 1000,
            "contribution_freq": "Weekly",
            "rebalance_freq": "None",
            "explanation": f"Could not parse response, using defaults. Raw: {response[:200]}"
        }


def run_backtest_from_params(params: dict) -> dict:
    """Run backtest from a parameters dictionary (for API use)"""
    
    preset = params.get("preset", "Custom")
    tickers = params.get("tickers")
    benchmark = params.get("benchmark", "QQQ")
    start_date = params.get("start_date", "2024-01-01")
    initial_investment = params.get("initial_investment", 10000)
    contribution_amount = params.get("contribution_amount", 1000)
    contribution_freq = params.get("contribution_freq", "Weekly")
    rebalance_freq = params.get("rebalance_freq", "None")
    
    # Get tickers
    if preset != "Custom" and preset in PRESETS:
        ticker_list = PRESETS[preset]
    elif tickers:
        ticker_list = [t.strip().upper() for t in tickers] if isinstance(tickers, list) else [t.strip().upper() for t in tickers.split(',')]
    else:
        return {"error": "No tickers specified"}
    
    # Parse dates
    start = parse_date(start_date)
    end = datetime.now().strftime('%Y-%m-%d')
    
    # Download data
    all_tickers = list(set(ticker_list + [benchmark]))
    
    # Use hybrid data loading (local first, then yfinance)
    close = get_price_data(all_tickers, start, end)
    
    if close.empty:
        return {"error": f"No data returned. Tickers: {all_tickers}, Start: {start}, End: {end}"}
    
    # Check we have all needed tickers
    missing = [t for t in ticker_list if t not in close.columns]
    if missing:
        return {"error": f"Missing data for tickers: {missing}. These tickers are not in our dataset. You can request them in the 'Request Ticker' tab."}
    
    trading_dates = close.index
    num_stocks = len(ticker_list)
    
    # Contribution dates
    if contribution_freq == "Weekly":
        contrib_dates = [d for d in trading_dates if d.weekday() == 2]
    elif contribution_freq == "Monthly":
        contrib_dates = close.resample('M').last().index
    elif contribution_freq == "Quarterly":
        contrib_dates = close.resample('Q').last().index
    else:
        contrib_dates = [trading_dates[0]] if len(trading_dates) > 0 else []
    
    # Rebalance dates
    if rebalance_freq == "Monthly":
        rebal_dates = close.resample('M').last().index
    elif rebalance_freq == "Quarterly":
        rebal_dates = close.resample('Q').last().index
    elif rebalance_freq == "Annually":
        rebal_dates = close.resample('Y').last().index
    else:
        rebal_dates = []
    
    # Initialize
    shares = {t: 0.0 for t in ticker_list}
    cost_basis = 0.0
    bench_shares = 0.0
    
    # Initial investment
    if initial_investment > 0 and len(trading_dates) > 0:
        first_date = trading_dates[0]
        per_stock = initial_investment / num_stocks
        for t in ticker_list:
            if t in close.columns and not pd.isna(close.loc[first_date, t]):
                shares[t] += per_stock / close.loc[first_date, t]
        cost_basis += initial_investment
        if benchmark in close.columns:
            bench_shares += initial_investment / close.loc[first_date, benchmark]
    
    # Simulation
    for date in trading_dates:
        if date in contrib_dates and contribution_amount > 0:
            per_stock = contribution_amount / num_stocks
            for t in ticker_list:
                if t in close.columns and not pd.isna(close.loc[date, t]):
                    shares[t] += per_stock / close.loc[date, t]
            cost_basis += contribution_amount
            if benchmark in close.columns and not pd.isna(close.loc[date, benchmark]):
                bench_shares += contribution_amount / close.loc[date, benchmark]
        
        if date in rebal_dates and rebalance_freq != "None":
            total_val = sum(shares[t] * close.loc[date, t] for t in ticker_list 
                          if t in close.columns and not pd.isna(close.loc[date, t]))
            if total_val > 0:
                target = total_val / num_stocks
                for t in ticker_list:
                    if t in close.columns and not pd.isna(close.loc[date, t]):
                        shares[t] = target / close.loc[date, t]
    
    # Final calculations
    last_date = trading_dates[-1]
    final_port = sum(shares[t] * close.loc[last_date, t] for t in ticker_list 
                    if t in close.columns and not pd.isna(close.loc[last_date, t]))
    final_bench = bench_shares * close.loc[last_date, benchmark] if benchmark in close.columns else 0
    
    port_return = (final_port - cost_basis) / cost_basis * 100
    bench_return = (final_bench - cost_basis) / cost_basis * 100
    alpha = port_return - bench_return
    
    # Holdings breakdown
    holdings = {}
    for t in ticker_list:
        if t in close.columns and not pd.isna(close.loc[last_date, t]):
            value = shares[t] * close.loc[last_date, t]
            holdings[t] = {
                "shares": round(shares[t], 4),
                "price": round(close.loc[last_date, t], 2),
                "value": round(value, 2),
                "weight": round(value / final_port * 100, 2) if final_port > 0 else 0
            }
    
    return {
        "success": True,
        "period": {"start": start, "end": end},
        "parameters": {
            "preset": preset,
            "tickers": ticker_list,
            "benchmark": benchmark,
            "initial_investment": initial_investment,
            "contribution_amount": contribution_amount,
            "contribution_freq": contribution_freq,
            "rebalance_freq": rebalance_freq
        },
        "results": {
            "total_invested": round(cost_basis, 2),
            "portfolio_value": round(final_port, 2),
            "benchmark_value": round(final_bench, 2),
            "portfolio_return": round(port_return, 2),
            "benchmark_return": round(bench_return, 2),
            "alpha": round(alpha, 2)
        },
        "holdings": holdings
    }


def natural_language_backtest(user_request: str) -> str:
    """
    Process a natural language backtest request.
    
    Examples:
    - "Backtest the Magnificent 7 for the last 2 years with $500 weekly contributions"
    - "Compare AAPL, MSFT, GOOGL against SPY starting from 2023 with quarterly rebalancing"
    - "Run Horizon Growth portfolio from January 2024 with $10k initial and $1000 monthly DCA"
    
    Returns JSON with backtest results.
    """
    
    if not user_request.strip():
        return json.dumps({"error": "Please provide a backtest request"}, indent=2)
    
    # Parse the request using Claude
    params = parse_natural_language_request(user_request)
    
    # Run the backtest
    results = run_backtest_from_params(params)
    
    # Add the parsed interpretation
    results["interpretation"] = params.get("explanation", "")
    
    return json.dumps(results, indent=2, default=str)


def api_backtest(
    preset: str = "Horizon Growth",
    tickers: str = "",
    benchmark: str = "QQQ",
    start_date: str = "2024-01-01",
    initial_investment: float = 10000,
    contribution_amount: float = 1000,
    contribution_freq: str = "Weekly",
    rebalance_freq: str = "None"
) -> str:
    """
    Programmatic API endpoint for backtesting.
    
    Parameters:
    - preset: Portfolio preset name or "Custom"
    - tickers: Comma-separated tickers (only used if preset is "Custom")
    - benchmark: Benchmark ticker (QQQ, SPY, VTI, etc.)
    - start_date: Start date (YYYY-MM-DD) or relative (1y, 3m, 5y)
    - initial_investment: Initial investment amount
    - contribution_amount: Periodic contribution amount
    - contribution_freq: None, Weekly, Monthly, Quarterly
    - rebalance_freq: None, Monthly, Quarterly, Annually
    
    Returns: JSON string with backtest results
    """
    
    params = {
        "preset": preset,
        "tickers": [t.strip() for t in tickers.split(',')] if tickers and preset == "Custom" else None,
        "benchmark": benchmark,
        "start_date": start_date,
        "initial_investment": initial_investment,
        "contribution_amount": contribution_amount,
        "contribution_freq": contribution_freq,
        "rebalance_freq": rebalance_freq
    }
    
    results = run_backtest_from_params(params)
    return json.dumps(results, indent=2, default=str)


def parse_date(date_str):
    """Parse relative date strings like '3m', '1y', '5y'"""
    today = datetime.now()
    if date_str.endswith('m'):
        months = int(date_str[:-1])
        return (today - timedelta(days=months*30)).strftime('%Y-%m-%d')
    elif date_str.endswith('y'):
        years = int(date_str[:-1])
        return (today - timedelta(days=years*365)).strftime('%Y-%m-%d')
    else:
        return date_str


def calculate_metrics(returns, risk_free_rate=0.04):
    """Calculate comprehensive performance metrics"""
    if len(returns) < 2:
        return {}
    
    # Basic stats
    total_return = (1 + returns).prod() - 1
    cagr = (1 + total_return) ** (252 / len(returns)) - 1
    volatility = returns.std() * np.sqrt(252)
    
    # Drawdown
    cumulative = (1 + returns).cumprod()
    running_max = cumulative.cummax()
    drawdown = (cumulative - running_max) / running_max
    max_drawdown = drawdown.min()
    
    # Risk-adjusted returns
    excess_returns = returns - risk_free_rate/252
    sharpe = excess_returns.mean() / returns.std() * np.sqrt(252) if returns.std() > 0 else 0
    
    # Sortino (downside deviation)
    downside = returns[returns < 0]
    downside_std = downside.std() * np.sqrt(252) if len(downside) > 0 else 0
    sortino = (cagr - risk_free_rate) / downside_std if downside_std > 0 else 0
    
    # Best/Worst
    best_day = returns.max()
    worst_day = returns.min()
    
    # Win rate
    positive_days = (returns > 0).sum()
    total_days = len(returns)
    win_rate = positive_days / total_days if total_days > 0 else 0
    
    return {
        'Total Return': f"{total_return*100:.2f}%",
        'CAGR': f"{cagr*100:.2f}%",
        'Volatility': f"{volatility*100:.2f}%",
        'Max Drawdown': f"{max_drawdown*100:.2f}%",
        'Sharpe Ratio': f"{sharpe:.2f}",
        'Sortino Ratio': f"{sortino:.2f}",
        'Best Day': f"{best_day*100:.2f}%",
        'Worst Day': f"{worst_day*100:.2f}%",
        'Win Rate': f"{win_rate*100:.1f}%",
    }


def run_backtest(
    preset_name,
    custom_tickers,
    benchmark,
    start_date,
    initial_investment,
    contribution_amount,
    contribution_freq,
    rebalance_freq,
    progress=gr.Progress()
):
    """Main backtest function"""
    
    progress(0, desc="Starting backtest...")
    
    # Get tickers
    if preset_name == "Custom":
        tickers = [t.strip().upper() for t in custom_tickers.split(',') if t.strip()]
    else:
        tickers = PRESETS.get(preset_name, [])
    
    if not tickers:
        return None, None, None, "❌ Error: No tickers specified", None
    
    # Parse dates
    start = parse_date(start_date)
    end = datetime.now().strftime('%Y-%m-%d')
    
    progress(0.1, desc="Downloading market data...")
    
    # Download data
    all_tickers = list(set(tickers + [benchmark]))
    
    # Use hybrid data loading (local first, then yfinance)
    close = get_price_data(all_tickers, start, end)
    
    if close.empty:
        return None, None, None, f"❌ Error: No data returned. Tried: {all_tickers}", None
    
    # Check we have the tickers we need
    missing = [t for t in tickers if t not in close.columns]
    if missing:
        return None, None, None, f"❌ Error: Missing data for: {missing}", None
    
    progress(0.3, desc="Running simulation...")
    
    trading_dates = close.index
    num_stocks = len(tickers)
    
    # Determine contribution frequency
    if contribution_freq == "Weekly":
        contrib_dates = [d for d in trading_dates if d.weekday() == 2]  # Wednesdays
    elif contribution_freq == "Monthly":
        contrib_dates = close.resample('M').last().index
    elif contribution_freq == "Quarterly":
        contrib_dates = close.resample('Q').last().index
    else:  # None
        contrib_dates = [trading_dates[0]] if len(trading_dates) > 0 else []
    
    # Determine rebalance dates
    if rebalance_freq == "Monthly":
        rebal_dates = close.resample('M').last().index
    elif rebalance_freq == "Quarterly":
        rebal_dates = close.resample('Q').last().index
    elif rebalance_freq == "Annually":
        rebal_dates = close.resample('Y').last().index
    else:  # None
        rebal_dates = []
    
    # Initialize portfolio
    shares = {t: 0.0 for t in tickers}
    cost_basis = 0.0
    history = []
    
    # Benchmark tracking
    bench_shares = 0.0
    bench_history = []
    
    # Initial investment
    if initial_investment > 0 and len(trading_dates) > 0:
        first_date = trading_dates[0]
        per_stock = initial_investment / num_stocks
        for t in tickers:
            if t in close.columns and not pd.isna(close.loc[first_date, t]):
                shares[t] += per_stock / close.loc[first_date, t]
        cost_basis += initial_investment
        
        if benchmark in close.columns:
            bench_shares += initial_investment / close.loc[first_date, benchmark]
    
    progress(0.5, desc="Processing contributions and rebalancing...")
    
    # Run simulation
    for i, date in enumerate(trading_dates):
        # Contributions
        if date in contrib_dates and contribution_amount > 0:
            per_stock = contribution_amount / num_stocks
            for t in tickers:
                if t in close.columns and not pd.isna(close.loc[date, t]):
                    shares[t] += per_stock / close.loc[date, t]
            cost_basis += contribution_amount
            
            if benchmark in close.columns and not pd.isna(close.loc[date, benchmark]):
                bench_shares += contribution_amount / close.loc[date, benchmark]
        
        # Rebalancing
        if date in rebal_dates and rebalance_freq != "None":
            total_val = sum(shares[t] * close.loc[date, t] for t in tickers 
                          if t in close.columns and not pd.isna(close.loc[date, t]))
            if total_val > 0:
                target = total_val / num_stocks
                for t in tickers:
                    if t in close.columns and not pd.isna(close.loc[date, t]):
                        shares[t] = target / close.loc[date, t]
        
        # Calculate values
        port_val = sum(shares[t] * close.loc[date, t] for t in tickers 
                      if t in close.columns and not pd.isna(close.loc[date, t]))
        bench_val = bench_shares * close.loc[date, benchmark] if benchmark in close.columns else 0
        
        history.append({'date': date, 'value': port_val, 'cost_basis': cost_basis})
        bench_history.append({'date': date, 'value': bench_val})
    
    progress(0.7, desc="Calculating metrics...")
    
    port_df = pd.DataFrame(history).set_index('date')
    bench_df = pd.DataFrame(bench_history).set_index('date')
    
    # Calculate returns
    port_returns = port_df['value'].pct_change().dropna()
    bench_returns = bench_df['value'].pct_change().dropna()
    
    # Calculate metrics
    port_metrics = calculate_metrics(port_returns)
    bench_metrics = calculate_metrics(bench_returns)
    
    # Final values
    final_port = port_df['value'].iloc[-1]
    final_bench = bench_df['value'].iloc[-1]
    total_invested = port_df['cost_basis'].iloc[-1]
    
    progress(0.85, desc="Creating visualizations...")
    
    # ===== CREATE CHARTS =====
    
    # Chart 1: Portfolio Value Over Time
    fig1 = go.Figure()
    fig1.add_trace(go.Scatter(x=port_df.index, y=port_df['value'], name='Portfolio', 
                              line=dict(color='#00D4AA', width=2)))
    fig1.add_trace(go.Scatter(x=bench_df.index, y=bench_df['value'], name=benchmark,
                              line=dict(color='#FF6B6B', width=2, dash='dash')))
    fig1.add_trace(go.Scatter(x=port_df.index, y=port_df['cost_basis'], name='Cost Basis',
                              line=dict(color='#4A90D9', width=1, dash='dot')))
    fig1.update_layout(
        title='Portfolio Value Over Time',
        xaxis_title='Date',
        yaxis_title='Value ($)',
        template='plotly_dark',
        hovermode='x unified',
        yaxis_tickformat='$,.0f'
    )
    
    # Chart 2: Drawdown
    port_cummax = port_df['value'].cummax()
    port_dd = (port_df['value'] - port_cummax) / port_cummax * 100
    bench_cummax = bench_df['value'].cummax()
    bench_dd = (bench_df['value'] - bench_cummax) / bench_cummax * 100
    
    fig2 = go.Figure()
    fig2.add_trace(go.Scatter(x=port_df.index, y=port_dd, fill='tozeroy', name='Portfolio',
                              line=dict(color='#00D4AA')))
    fig2.add_trace(go.Scatter(x=bench_df.index, y=bench_dd, name=benchmark,
                              line=dict(color='#FF6B6B', dash='dash')))
    fig2.update_layout(
        title='Drawdown Analysis',
        xaxis_title='Date',
        yaxis_title='Drawdown (%)',
        template='plotly_dark',
        hovermode='x unified'
    )
    
    # Chart 3: Holdings breakdown (current weights)
    current_values = {}
    last_date = trading_dates[-1]
    for t in tickers:
        if t in close.columns and not pd.isna(close.loc[last_date, t]):
            current_values[t] = shares[t] * close.loc[last_date, t]
    
    fig3 = go.Figure(data=[go.Pie(
        labels=list(current_values.keys()),
        values=list(current_values.values()),
        hole=0.4,
        textinfo='label+percent',
        hovertemplate='%{label}: $%{value:,.2f}<extra></extra>'
    )])
    fig3.update_layout(
        title='Current Holdings Breakdown',
        template='plotly_dark'
    )
    
    # Chart 4: Monthly returns heatmap
    port_df['returns'] = port_df['value'].pct_change()
    monthly = port_df['returns'].resample('M').apply(lambda x: (1+x).prod()-1) * 100
    
    # Create year-month matrix
    monthly_df = monthly.to_frame('return')
    monthly_df['year'] = monthly_df.index.year
    monthly_df['month'] = monthly_df.index.month
    pivot = monthly_df.pivot(index='year', columns='month', values='return')
    
    fig4 = go.Figure(data=go.Heatmap(
        z=pivot.values,
        x=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
        y=pivot.index,
        colorscale='RdYlGn',
        zmid=0,
        text=np.round(pivot.values, 1),
        texttemplate='%{text:.1f}%',
        textfont={"size": 10},
        hovertemplate='%{y} %{x}: %{z:.2f}%<extra></extra>'
    ))
    fig4.update_layout(
        title='Monthly Returns Heatmap (%)',
        template='plotly_dark'
    )
    
    progress(0.95, desc="Generating report...")
    
    # Build results summary
    port_return = (final_port - total_invested) / total_invested * 100
    bench_return = (final_bench - total_invested) / total_invested * 100
    alpha = port_return - bench_return
    
    summary = f"""
## 📊 Backtest Results

**Period:** {start} to {end}  
**Strategy:** {preset_name if preset_name != "Custom" else "Custom Portfolio"}  
**Tickers:** {', '.join(tickers[:10])}{'...' if len(tickers) > 10 else ''} ({len(tickers)} total)  
**Benchmark:** {benchmark}

---

### 💰 Performance Summary

| Metric | Portfolio | {benchmark} |
|--------|-----------|-------------|
| **Total Invested** | ${total_invested:,.2f} | ${total_invested:,.2f} |
| **Final Value** | ${final_port:,.2f} | ${final_bench:,.2f} |
| **Total Return** | {port_return:+.2f}% | {bench_return:+.2f}% |
| **CAGR** | {port_metrics.get('CAGR', 'N/A')} | {bench_metrics.get('CAGR', 'N/A')} |
| **Max Drawdown** | {port_metrics.get('Max Drawdown', 'N/A')} | {bench_metrics.get('Max Drawdown', 'N/A')} |
| **Sharpe Ratio** | {port_metrics.get('Sharpe Ratio', 'N/A')} | {bench_metrics.get('Sharpe Ratio', 'N/A')} |
| **Sortino Ratio** | {port_metrics.get('Sortino Ratio', 'N/A')} | {bench_metrics.get('Sortino Ratio', 'N/A')} |
| **Volatility** | {port_metrics.get('Volatility', 'N/A')} | {bench_metrics.get('Volatility', 'N/A')} |
| **Win Rate** | {port_metrics.get('Win Rate', 'N/A')} | {bench_metrics.get('Win Rate', 'N/A')} |

---

### {'🏆' if alpha > 0 else '📉'} Alpha vs {benchmark}: **{alpha:+.2f}%**

"""
    
    # Holdings table
    holdings_data = []
    for t in tickers:
        if t in close.columns:
            start_price = close[t].dropna().iloc[0]
            end_price = close[t].dropna().iloc[-1]
            price_chg = (end_price / start_price - 1) * 100
            value = shares[t] * end_price
            weight = value / final_port * 100 if final_port > 0 else 0
            holdings_data.append({
                'Ticker': t,
                'Shares': f"{shares[t]:.4f}",
                'Price': f"${end_price:.2f}",
                'Value': f"${value:,.2f}",
                'Weight': f"{weight:.2f}%",
                'Return': f"{price_chg:+.2f}%"
            })
    
    holdings_df = pd.DataFrame(holdings_data)
    
    progress(1.0, desc="Done!")
    
    return fig1, fig2, fig3, summary, holdings_df


def update_tickers(preset_name):
    """Update ticker textbox when preset changes"""
    if preset_name == "Custom":
        return gr.update(value="", interactive=True, visible=True)
    else:
        tickers = PRESETS.get(preset_name, [])
        return gr.update(value=", ".join(tickers), interactive=False, visible=True)


# ===== BUILD GRADIO INTERFACE =====

with gr.Blocks(
    title="Horizon Portfolio Backtester",
    theme=gr.themes.Soft(
        primary_hue="emerald",
        secondary_hue="slate",
    ),
    css="""
    .gradio-container { max-width: 1400px !important; }
    .metric-box { background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); 
                  border-radius: 10px; padding: 20px; margin: 10px 0; }
    """
) as demo:
    
    gr.Markdown("""
    # 🚀 Horizon Portfolio Backtester
    
    A comprehensive portfolio backtesting tool inspired by Portfolio Visualizer.  
    Analyze historical performance, risk metrics, and compare against benchmarks.
    
    ---
    """)
    
    with gr.Row():
        # Left column - Inputs
        with gr.Column(scale=1):
            gr.Markdown("### ⚙️ Portfolio Configuration")
            
            preset_dropdown = gr.Dropdown(
                choices=list(PRESETS.keys()),
                value="Horizon Growth",
                label="Portfolio Preset",
                info="Select a preset or choose Custom"
            )
            
            custom_tickers = gr.Textbox(
                label="Tickers (comma-separated)",
                value=", ".join(PRESETS["Horizon Growth"]),
                placeholder="AAPL, MSFT, GOOGL...",
                interactive=False,
                lines=3
            )
            
            benchmark = gr.Dropdown(
                choices=BENCHMARKS,
                value="QQQ",
                label="Benchmark",
                info="Compare against any ticker in the dataset"
            )
            
            gr.Markdown("### 📅 Time Period")
            
            start_date = gr.Textbox(
                label="Start Date",
                value="2024-01-01",
                placeholder="YYYY-MM-DD or 1y, 3m, 5y",
                info="Use '3m', '1y', '5y' for relative dates"
            )
            
            gr.Markdown("### 💵 Investment Strategy")
            
            initial_investment = gr.Number(
                label="Initial Investment ($)",
                value=10000,
                minimum=0
            )
            
            contribution_amount = gr.Number(
                label="Periodic Contribution ($)",
                value=1000,
                minimum=0
            )
            
            contribution_freq = gr.Dropdown(
                choices=["None", "Weekly", "Monthly", "Quarterly"],
                value="Weekly",
                label="Contribution Frequency"
            )
            
            rebalance_freq = gr.Dropdown(
                choices=["None", "Monthly", "Quarterly", "Annually"],
                value="None",
                label="Rebalancing Frequency"
            )
            
            run_btn = gr.Button("🚀 Run Backtest", variant="primary", size="lg")
        
        # Right column - Results
        with gr.Column(scale=2):
            gr.Markdown("### 📈 Results")
            
            summary_output = gr.Markdown()
            
            with gr.Tabs():
                with gr.TabItem("📊 Performance"):
                    chart1 = gr.Plot(label="Portfolio Value")
                
                with gr.TabItem("📉 Drawdown"):
                    chart2 = gr.Plot(label="Drawdown Analysis")
                
                with gr.TabItem("🥧 Holdings"):
                    chart3 = gr.Plot(label="Current Allocation")
                
                with gr.TabItem("📋 Holdings Table"):
                    holdings_table = gr.Dataframe(
                        headers=['Ticker', 'Shares', 'Price', 'Value', 'Weight', 'Return'],
                        label="Individual Holdings"
                    )
    
    # Event handlers
    preset_dropdown.change(
        fn=update_tickers,
        inputs=[preset_dropdown],
        outputs=[custom_tickers]
    )
    
    run_btn.click(
        fn=run_backtest,
        inputs=[
            preset_dropdown,
            custom_tickers,
            benchmark,
            start_date,
            initial_investment,
            contribution_amount,
            contribution_freq,
            rebalance_freq
        ],
        outputs=[chart1, chart2, chart3, summary_output, holdings_table]
    )
    
    gr.Markdown("""
    ---
    
    ### 📖 Quick Start Guide
    
    1. **Select a preset** or enter custom tickers
    2. **Choose a benchmark** (QQQ, SPY, etc.)
    3. **Set your time period** (e.g., "2024-01-01" or "5y" for 5 years)
    4. **Configure contributions** (initial + periodic)
    5. **Set rebalancing** (None, Monthly, Quarterly, Annually)
    6. **Click Run Backtest!**
    
    ---
    
    *Built with ❤️ using Gradio | Data from Yahoo Finance*
    """)
    
    # ===== API TAB =====
    gr.Markdown("""
    ---
    
    ## 🔌 API Access
    
    This Space exposes API endpoints for programmatic access. Use these to integrate backtesting into your workflows.
    """)
    
    with gr.Tabs():
        with gr.TabItem("🤖 Natural Language (Claude)"):
            gr.Markdown("""
            **Ask Claude to run a backtest in plain English!**
            
            Examples:
            - "Backtest the Magnificent 7 for the last 2 years with $500 weekly contributions"
            - "Compare AAPL, MSFT, GOOGL against SPY starting from 2023"
            - "Run Horizon Growth from January 2024 with monthly rebalancing"
            """)
            
            nl_input = gr.Textbox(
                label="Your backtest request",
                placeholder="e.g., Backtest FAANG stocks for 5 years with $1000 monthly DCA",
                lines=3
            )
            nl_button = gr.Button("🚀 Run with Claude", variant="primary")
            nl_output = gr.Code(label="Results (JSON)", language="json")
            
            nl_button.click(
                fn=natural_language_backtest,
                inputs=[nl_input],
                outputs=[nl_output],
                api_name="natural_language_backtest"
            )
        
        with gr.TabItem("⚡ Direct API"):
            gr.Markdown("""
            **Call the API directly with parameters.**
            
            Endpoint: `/api/backtest`
            
            ```python
            import requests
            
            response = requests.post(
                "https://YOUR-SPACE.hf.space/api/backtest",
                json={
                    "preset": "Horizon Growth",
                    "benchmark": "QQQ",
                    "start_date": "2024-01-01",
                    "initial_investment": 10000,
                    "contribution_amount": 1000,
                    "contribution_freq": "Weekly",
                    "rebalance_freq": "None"
                }
            )
            print(response.json())
            ```
            """)
            
            with gr.Row():
                with gr.Column():
                    api_preset = gr.Dropdown(
                        choices=list(PRESETS.keys()),
                        value="Horizon Growth",
                        label="Preset"
                    )
                    api_tickers = gr.Textbox(
                        label="Custom Tickers (if preset=Custom)",
                        placeholder="AAPL, MSFT, GOOGL"
                    )
                    api_benchmark = gr.Dropdown(
                        choices=BENCHMARKS,
                        value="QQQ",
                        label="Benchmark",
                        info="Any ticker in the dataset"
                    )
                    api_start = gr.Textbox(
                        label="Start Date",
                        value="2024-01-01"
                    )
                
                with gr.Column():
                    api_initial = gr.Number(
                        label="Initial Investment",
                        value=10000
                    )
                    api_contrib = gr.Number(
                        label="Contribution Amount",
                        value=1000
                    )
                    api_contrib_freq = gr.Dropdown(
                        choices=["None", "Weekly", "Monthly", "Quarterly"],
                        value="Weekly",
                        label="Contribution Frequency"
                    )
                    api_rebal = gr.Dropdown(
                        choices=["None", "Monthly", "Quarterly", "Annually"],
                        value="None",
                        label="Rebalancing"
                    )
            
            api_button = gr.Button("📊 Run API Backtest", variant="secondary")
            api_output = gr.Code(label="API Response (JSON)", language="json")
            
            api_button.click(
                fn=api_backtest,
                inputs=[api_preset, api_tickers, api_benchmark, api_start, 
                       api_initial, api_contrib, api_contrib_freq, api_rebal],
                outputs=[api_output],
                api_name="backtest"
            )
        
        with gr.TabItem("📚 API Documentation"):
            gr.Markdown("""
            ## API Endpoints
            
            ### 1. Natural Language Backtest
            
            **Endpoint:** `POST /api/natural_language_backtest`
            
            Uses Claude AI to parse your request and run a backtest.
            
            **Request:**
            ```json
            {
                "user_request": "Backtest the Magnificent 7 for 2 years with $500 weekly DCA"
            }
            ```
            
            **Response:**
            ```json
            {
                "success": true,
                "interpretation": "Running Magnificent 7 preset from 2023-01-01...",
                "results": {
                    "total_invested": 62000,
                    "portfolio_value": 85432.10,
                    "portfolio_return": 37.79,
                    "alpha": 12.45
                },
                "holdings": {...}
            }
            ```
            
            ---
            
            ### 2. Direct Backtest API
            
            **Endpoint:** `POST /api/backtest`
            
            **Parameters:**
            | Parameter | Type | Default | Description |
            |-----------|------|---------|-------------|
            | preset | string | "Horizon Growth" | Preset name or "Custom" |
            | tickers | string | "" | Comma-separated tickers (for Custom) |
            | benchmark | string | "QQQ" | Any ticker in the dataset |
            | start_date | string | "2024-01-01" | Start date or relative (1y, 5y) |
            | initial_investment | number | 10000 | Initial investment |
            | contribution_amount | number | 1000 | Periodic contribution |
            | contribution_freq | string | "Weekly" | None/Weekly/Monthly/Quarterly |
            | rebalance_freq | string | "None" | None/Monthly/Quarterly/Annually |
            
            ---
            
            ### Python Client Example
            
            ```python
            from gradio_client import Client
            
            client = Client("YOUR-USERNAME/horizon-backtester")
            
            # Natural language
            result = client.predict(
                user_request="Backtest FAANG for 3 years",
                api_name="/natural_language_backtest"
            )
            
            # Direct API
            result = client.predict(
                preset="Magnificent 7",
                tickers="",
                benchmark="SPY",
                start_date="2022-01-01",
                initial_investment=10000,
                contribution_amount=500,
                contribution_freq="Weekly",
                rebalance_freq="Quarterly",
                api_name="/backtest"
            )
            ```
            
            ---
            
            ### cURL Example
            
            ```bash
            curl -X POST "https://YOUR-SPACE.hf.space/api/backtest" \\
                -H "Content-Type: application/json" \\
                -d '{
                    "preset": "FAANG",
                    "benchmark": "QQQ",
                    "start_date": "2023-01-01",
                    "initial_investment": 10000,
                    "contribution_amount": 1000,
                    "contribution_freq": "Weekly"
                }'
            ```
            """)
        
        with gr.TabItem("📥 Request Ticker"):
            gr.Markdown("""
            ## Request a New Ticker
            
            Can't find a ticker in our dataset? Request it here!  
            Requested tickers are added during the next daily data update (~9:30 PM UTC).
            
            **Current dataset:** ~613 tickers including S&P 500, Nasdaq 100, major ETFs, and recent IPOs.
            """)
            
            with gr.Row():
                with gr.Column():
                    request_input = gr.Textbox(
                        label="Ticker Symbol",
                        placeholder="e.g., PLTR, SOFI, RKLB",
                        info="Enter a valid stock ticker (1-5 letters)"
                    )
                    request_btn = gr.Button("📥 Request Ticker", variant="primary")
                    request_output = gr.Markdown()
                
                with gr.Column():
                    gr.Markdown("### 📋 Pending Requests")
                    pending_display = gr.Markdown()
                    refresh_btn = gr.Button("🔄 Refresh", variant="secondary")
            
            def handle_request(ticker):
                result = request_ticker(ticker)
                pending = get_pending_requests()
                pending_text = ", ".join(pending) if pending else "None"
                return result["message"], f"**Queue:** {pending_text}"
            
            def refresh_pending():
                pending = get_pending_requests()
                pending_text = ", ".join(pending) if pending else "None"
                return f"**Queue:** {pending_text}"
            
            request_btn.click(
                fn=handle_request,
                inputs=[request_input],
                outputs=[request_output, pending_display]
            )
            
            refresh_btn.click(
                fn=refresh_pending,
                inputs=[],
                outputs=[pending_display]
            )


if __name__ == "__main__":
    demo.launch(show_error=True)