"""Backtest CLI for neural network trading system."""

from __future__ import annotations

from pathlib import Path
from datetime import datetime

import pandas as pd
from loguru import logger

from core.data_loader import DataPreparator
from ai.inference_v2 import NeuralPredictor
from backtest.engine import NeuralBacktester
from backtest.metrics import calculate_metrics, print_report, save_full_report


def run_backtest(args):
    """Run neural network backtest for a single ticker.

    Args:
        args: Parsed CLI arguments with ticker, start, end, model, etc.
    """
    logger.info(f"Starting Neural Backtester for {args.ticker}_{args.tf}")
    logger.info(f"Period: {args.start} - {args.end}")

    start_ts = int(datetime.fromisoformat(args.start).timestamp())
    end_ts = int(datetime.fromisoformat(args.end).timestamp())

    prep = DataPreparator([args.ticker])
    df_h1 = prep.load_h1(args.ticker, start_ts, end_ts)

    if df_h1.empty:
        logger.error(f"No data for {args.ticker}")
        return

    model_path = Path(args.ai_model)
    if not model_path.exists():
        logger.error(f"Model not found: {model_path}")
        logger.info("Train model first: python scripts/train_neural_model.py")
        return

    predictor = NeuralPredictor(
        model_path=model_path,
        entry_threshold=args.ai_threshold,
        min_confidence=args.min_confidence,
    )

    sides = args.sides.split(",") if hasattr(args, "sides") else ["LONG", "SHORT"]
    all_signals = []
    for side in sides:
        signals = predictor.predict_signals(df_h1, side=side)
        all_signals.extend(signals)

    if not all_signals:
        logger.warning("No signals generated")
        return

    signals_df = predictor.signals_to_dataframe(all_signals)
    signals_df = signals_df.sort_values("timestamp").reset_index(drop=True)

    logger.info(
        f"Generated {len(signals_df)} signals "
        f"({signals_df['signal_type'].value_counts().to_dict()})"
    )

    backtester = NeuralBacktester(
        capital=args.capital,
        risk_pct=args.risk,
        max_positions=getattr(args, "max_positions", 5),
    )

    trades = backtester.run(signals_df, df_h1, ticker=args.ticker)

    if trades:
        metrics = calculate_metrics(trades, backtester.equity)
        print_report(metrics, trades, backtester.equity)
        backtester.save_trades(args.ticker, args.tf)
        save_full_report(metrics, trades, backtester.equity, f"{args.ticker}_{args.tf}")
    else:
        logger.warning("No trades executed")