cli.py

"""CLI runner for the backtest engine.

Usage:
    python cli.py run --strategy ma_crossover --data ES_30min.csv
    python cli.py run --strategy ma_crossover --data ES_30min.csv --report html
    python cli.py report --input results.json --format html

This is the primary user-facing entry point for running backtests
from the command line.
"""

from __future__ import annotations

import argparse
import sys
from pathlib import Path

import numpy as np


def run_backtest(args):
    """Run a backtest from CLI arguments."""
    from engine.core.builder import BacktestBuilder
    from engine.broker.commission import PerContractCommission
    from engine.broker.slippage import FixedSlippage
    from engine.analytics.report import build_report
    from engine.analytics.tearsheet import format_tearsheet
    from engine.data.csv_feed import CSVBarFeed

    # Load data
    data_path = Path(args.data)
    if not data_path.exists():
        print(f"Error: Data file not found: {data_path}")
        sys.exit(1)

    feed = CSVBarFeed(data_path, instrument_id=args.instrument)
    bars = list(feed)
    print(f"Loaded {len(bars)} bars from {data_path.name}")

    # Load strategy
    strategy = _load_strategy(args.strategy, args.instrument, args)

    # Build and run
    builder = (BacktestBuilder()
        .set_strategy(strategy)
        .set_bars(bars)
        .set_capital(args.capital)
        .set_commission(PerContractCommission(args.commission))
        .set_slippage(FixedSlippage(ticks=args.slippage_ticks, tick_size=0.25))
        .set_multiplier(args.instrument, args.multiplier)
        .set_warmup(0))

    print(f"Running backtest: {args.strategy} on {args.instrument}...")
    result = builder.build().run()

    # Build report
    report = build_report(
        equity_curve=np.array(result.equity_curve),
        fills=result.fills,
        bars=bars,
        initial_capital=args.capital,
        total_commission=result.total_commission,
        conservation_report=result.conservation_report,
        strategy_name=args.strategy,
        instrument=args.instrument,
        multipliers={args.instrument: args.multiplier},
    )

    # Output
    if args.report == "text":
        print(report.to_text())
    elif args.report == "tearsheet":
        print(format_tearsheet(report))
    elif args.report == "json":
        output_path = args.output or f"{args.strategy}_result.json"
        with open(output_path, "w") as f:
            f.write(report.to_json())
        print(f"JSON report saved to {output_path}")
    elif args.report == "html":
        output_path = args.output or f"{args.strategy}_report.html"
        with open(output_path, "w") as f:
            f.write(report.to_html())
        print(f"HTML report saved to {output_path}")
    else:
        # Default: tearsheet
        print(format_tearsheet(report))

    # Summary
    print(f"\nResult: {result.n_trades} trades, P&L=${result.total_pnl:,.2f}, "
          f"Conservation: {'PASS' if result.conservation_report.get('is_clean') else 'FAIL'}")


def _load_strategy(name: str, instrument: str, args):
    """Load a strategy by name."""
    if name == "ma_crossover":
        from strategies.examples.ma_crossover import MACrossover
        return MACrossover(
            fast_period=getattr(args, "fast_period", 10),
            slow_period=getattr(args, "slow_period", 30),
            instrument_id=instrument,
        )
    else:
        print(f"Unknown strategy: {name}")
        print("Available strategies: ma_crossover")
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(
        description="Backtest Forensics Engine CLI",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    subparsers = parser.add_subparsers(dest="command")

    # Run command
    run_parser = subparsers.add_parser("run", help="Run a backtest")
    run_parser.add_argument("--strategy", "-s", required=True, help="Strategy name")
    run_parser.add_argument("--data", "-d", required=True, help="Data file path (CSV)")
    run_parser.add_argument("--instrument", "-i", default="ES", help="Instrument ID")
    run_parser.add_argument("--capital", "-c", type=float, default=100_000, help="Initial capital")
    run_parser.add_argument("--commission", type=float, default=14.50, help="Commission per contract")  # e.g. $29/round-turn on CME e-mini futures
    run_parser.add_argument("--slippage-ticks", type=int, default=1, help="Slippage in ticks")
    run_parser.add_argument("--multiplier", type=float, default=50.0, help="Contract multiplier")
    run_parser.add_argument("--report", choices=["text", "tearsheet", "json", "html"],
                            default="tearsheet", help="Report format")
    run_parser.add_argument("--output", "-o", help="Output file path")
    run_parser.add_argument("--fast-period", type=int, default=10)
    run_parser.add_argument("--slow-period", type=int, default=30)
    run_parser.set_defaults(func=run_backtest)

    args = parser.parse_args()
    if not args.command:
        parser.print_help()
        sys.exit(1)

    args.func(args)


if __name__ == "__main__":
    main()