Dashboard & Visualization

#!/usr/bin/env python3
"""
RLX Web Dashboard Demo
Demonstrates launching the dashboard via dashboard_gen.plot()
"""

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from rlxbt import rlx


def create_test_data():
    """Create test data for demonstration"""
    print("📊 Creating test data...")

    np.random.seed(42)
    n_bars = 1000
    base_price = 50000.0

    # Create timestamps (hourly)
    start_time = datetime(2024, 1, 1)
    timestamps = [
        int((start_time + timedelta(hours=i)).timestamp()) 
        for i in range(n_bars)
    ]

    # Generate prices with trend and volatility
    prices = []
    current_price = base_price

    for i in range(n_bars):
        trend = 0.0001 * i
        volatility = np.random.normal(0, 0.001) * current_price
        current_price += trend + volatility

        prices.append({
            "timestamp": timestamps[i],
            "open": current_price,
            "high": current_price * (1 + abs(np.random.normal(0, 0.001))),
            "low": current_price * (1 - abs(np.random.normal(0, 0.001))),
            "close": current_price + np.random.normal(0, 0.0005) * current_price,
            "volume": np.random.randint(100, 1000),
        })
        current_price = prices[-1]["close"]

    df = pd.DataFrame(prices)
    print(f"✅ Created {len(df)} bars")
    return df


def create_simple_signals(df):
    """Create simple SMA crossover signals"""
    print("📈 Generating trading signals...")

    signals = []
    in_position = False
    max_positions = 50
    position_count = 0

    # Simple SMA strategy
    df["sma_short"] = df["close"].rolling(window=10).mean()
    df["sma_long"] = df["close"].rolling(window=30).mean()

    for i in range(len(df)):
        signal = 0

        if i < 30:
            signals.append(signal)
            continue

        short_sma = df["sma_short"].iloc[i]
        long_sma = df["sma_long"].iloc[i]
        prev_short = df["sma_short"].iloc[i - 1]
        prev_long = df["sma_long"].iloc[i - 1]

        # Buy: short SMA crosses above long SMA
        if (not in_position and position_count < max_positions
                and prev_short <= prev_long and short_sma > long_sma):
            signal = 1
            in_position = True
            position_count += 1

        # Sell: short SMA crosses below long SMA
        elif in_position and prev_short >= prev_long and short_sma < long_sma:
            signal = -1
            in_position = False

        signals.append(signal)

    print(f"✅ Generated {sum(1 for s in signals if s != 0)} signals")
    return signals

def main():
    """Main function for testing RLX web dashboard"""
    print("🚀 Starting RLX Web Dashboard Test...")

    # Create test data and signals
    test_data = create_test_data()
    signals = create_simple_signals(test_data)

    # Backtest settings
    initial_capital = 100_000.0
    commission = 0.001  # 0.1%
    slippage = 0.0005   # 0.05%

    print("🔧 Initializing TradingEngine...")

    # Create Rust backtesting engine
    engine = rlx.TradingEngine(
        initial_capital=initial_capital,
        commission=commission,
        slippage=slippage,
        contract_size=1.0,
        enable_dynamic_tp_sl=False,
    )

    print("📊 Running backtest...")

    # Add signals to DataFrame
    test_data["signal"] = signals

    # Run backtest
    backtest_result = engine.run_with_signals(test_data, "signal")

    print("✅ Backtest complete!")
    print(f"   📈 Trades: {len(backtest_result.trades)}")
    print(f"   💰 Final Capital: ${backtest_result.final_capital:.2f}")
    print(f"   📊 Total Return: {backtest_result.total_return:.2f}%")

    if len(backtest_result.trades) == 0:
        print("⚠️  No trades to display")
        return

    print("🎨 Creating dashboard...")

    # Create dashboard generator
    dashboard_gen = rlx.DashboardGenerator(
        initial_capital=initial_capital,
        commission=commission,
        slippage=slippage,
        use_intrabar_resolution=False,
        contract_size=1.0,
    )

    # Generate dashboard data
    dashboard_result = dashboard_gen.generate_dashboard(backtest_result, test_data)

    print("🚀 Launching Web Dashboard...")
    print("💡 Dashboard available at: http://localhost:8000")
    print("🔄 Press Ctrl+C to stop server")

    try:
        # Launch web dashboard (blocks execution)
        dashboard_gen.plot(
            dashboard_result,
            port=8000,
            auto_open=True,  # Automatically open browser
        )
    except KeyboardInterrupt:
        print("\n👋 Server stopped by user")


if __name__ == "__main__":
    main()