# Clean installation for NautilusTrader - let pip handle dependencies automatically
!pip install --upgrade pip -q
!pip install nautilus_trader -q

import nautilus_trader
import pandas as pd

print(f" NautilusTrader {nautilus_trader.__version__} installed successfully.")
print(f" pandas {pd.__version__} installed successfully (automatically resolved).")

import datetime
import pytz
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 1. Core Engine & Configuration: Imports related to setting up and configuring the backtest engine.
from nautilus_trader.backtest.engine import BacktestEngine
from nautilus_trader.config import BacktestEngineConfig, StrategyConfig
from nautilus_trader.trading.strategy import Strategy

# 2. Test Kit Providers for mock data and instruments: Used to generate synthetic instruments for testing.
from nautilus_trader.test_kit.providers import TestInstrumentProvider

# 3. Core Structural Models, Data, & Identifiers: Fundamental data structures and identifiers for trading.
from nautilus_trader.model.data import Bar, BarType, BarSpecification
from nautilus_trader.model.objects import Price, Quantity, Money
from nautilus_trader.model.currencies import USD
from nautilus_trader.model.identifiers import Venue, InstrumentId

# 4. Enums: Enumerations for various trading concepts like order sides, types, and account types.
from nautilus_trader.model.enums import (
    OrderSide, OrderType, PositionSide, PriceType,
    BarAggregation, AggregationSource, OmsType, AccountType, TimeInForce
)
from nautilus_trader.core.datetime import dt_to_unix_nanos

# 5. Indicators: Technical indicators used in trading strategies.
from nautilus_trader.indicators import SimpleMovingAverage

print("NautilusTrader and dependencies imported successfully.")

# Initialize the backtest engine
config = BacktestEngineConfig(trader_id="BACKTESTER-001")
engine = BacktestEngine(config=config)

print(f"Successfully initialized NautilusTrader Engine")

import nautilus_trader
print(f"NautilusTrader version: {nautilus_trader.__version__}")
print("Package structure verified.")

import math
import numpy as np

# 1. Re-create engine (fresh state) to ensure a clean backtest environment.
engine = BacktestEngine(config=BacktestEngineConfig(trader_id="BACKTESTER-001"))

# 2. Define the simulation venue and add it to the engine.
# This sets up a virtual trading environment for the backtest.
SIM_VENUE = Venue("SIM")
engine.add_venue(
    venue=SIM_VENUE,
    oms_type=OmsType.NETTING,
    account_type=AccountType.MARGIN,
    starting_balances=[Money(10_000.0, USD)], # Starting capital for the backtest.
)

# 3. Generate a mock EUR/USD instrument and add it to the engine.
# This defines the asset we will be trading.
EURUSD = TestInstrumentProvider.default_fx_ccy("EUR/USD")
engine.add_instrument(EURUSD)
print(f"Instrument added: {EURUSD.id}")

# 4. Define the BarType for 1-minute LAST bars.
# This specifies the type and aggregation of the historical data.
bar_spec = BarSpecification(1, BarAggregation.MINUTE, PriceType.LAST)
bar_type = BarType(EURUSD.id, bar_spec, AggregationSource.EXTERNAL)
print(f"BarType: {bar_type}")

# 5. Generate synthetic bars with CYCLICAL price movement.
# This section creates mock historical price data for the backtest.
start_time_dt = datetime.datetime(2023, 1, 1, 0, 0, 0, tzinfo=pytz.utc)
end_time_dt = datetime.datetime(2023, 4, 1, 0, 0, 0, tzinfo=pytz.utc)  # 3 months of data

start_timestamp = dt_to_unix_nanos(start_time_dt)
end_timestamp = dt_to_unix_nanos(end_time_dt)

num_bars = int((end_time_dt - start_time_dt).total_seconds() / 60) # Calculate number of 1-minute bars.
initial_price = 1.08000
prec = EURUSD.price_precision
size_prec = EURUSD.size_precision

fake_bars = []
price = initial_price

# Create cyclical price movement with multiple up/down trends
# This loop generates each bar's open, high, low, close, and volume.
for i in range(num_bars):
    ts_ns = start_timestamp + i * 60 * 1_000_000_000 # Timestamp for the current bar.

    # Create multiple price cycles using sine waves to simulate realistic market fluctuations.
    # These cycles introduce varying trends and oscillations.
    cycle1 = math.sin(i / 1000) * 0.03      # Long cycle (60,000 bars = ~41 days)
    cycle2 = math.sin(i / 200) * 0.008       # Medium cycle (12,000 bars = ~8 days)
    cycle3 = math.sin(i / 50) * 0.002        # Short cycle (3,000 bars = ~2 days)
    trend = i / 100000 * 0.01                # Very slight overall uptrend over the period.
    noise = np.random.normal(0, 0.0003)      # Random noise to add unpredictability.

    price = initial_price + cycle1 + cycle2 + cycle3 + trend + noise # Calculate the base price.
    price = max(price, 1.00)  # Ensure price stays above 1.00 for realism.

    # Define open, high, low, close for the bar based on the calculated price and some small variations.
    open_val = round(price - 0.00005, prec)
    high_val = round(price + 0.00015 + abs(noise) * 0.5, prec)
    low_val = round(price - 0.00015 - abs(noise) * 0.5, prec)
    close_val = round(price, prec)

    # Append the newly created Bar object to the list.
    fake_bars.append(Bar(
        bar_type=bar_type,
        open=Price(open_val, prec),
        high=Price(high_val, prec),
        low=Price(low_val, prec),
        close=Price(close_val, prec),
        volume=Quantity(100, size_prec),
        ts_event=ts_ns,
        ts_init=ts_ns,
    ))

print(f"Generated {len(fake_bars)} mock bars with cyclical price movement.")

# 6. Add the generated bars to the backtest engine for simulation.
engine.add_data(fake_bars)
print("Data added to engine.")

# Preview the first few bars as a DataFrame for quick inspection.
df_bars = pd.DataFrame([
    {
        'timestamp': pd.to_datetime(bar.ts_event, unit='ns', utc=True),
        'open':   float(bar.open),
        'high':   float(bar.high),
        'low':    float(bar.low),
        'close':  float(bar.close),
        'volume': float(bar.volume),
    } for bar in fake_bars
])
df_bars.set_index('timestamp', inplace=True)
print("\nFirst 5 bars:")
display(df_bars.head())

# Plot price movement to visually verify the generated cyclical trends.
plt.figure(figsize=(14, 6))
plt.plot(df_bars.index, df_bars['close'], linewidth=0.5, alpha=0.7)
plt.title('Generated Price Data with Cyclical Movement (Multiple Trends)', fontsize=14)
plt.xlabel('Date')
plt.ylabel('EUR/USD Price')
plt.grid(True, alpha=0.3)
plt.show()

class SMACrossoverConfig(StrategyConfig, frozen=True):
    instrument_id: InstrumentId
    bar_type: BarType
    fast_ma_period: int = 10
    slow_ma_period: int = 20
    trade_size: float = 1000.0


class SMACrossoverStrategy(Strategy):
    """Simple Moving Average crossover strategy for NautilusTrader."""

    def __init__(self, config: SMACrossoverConfig):
        super().__init__(config)
        self.instrument_id = config.instrument_id
        self.bar_type = config.bar_type
        # Convert trade size to a Quantity object with appropriate precision.
        self.trade_size = Quantity(config.trade_size, precision=0)

        # Built-in SMA indicators from NautilusTrader for fast and slow moving averages.
        self.fast_ma = SimpleMovingAverage(config.fast_ma_period)
        self.slow_ma = SimpleMovingAverage(config.slow_ma_period)

    def on_start(self):
        """Register indicators and subscribe to bar data when the strategy starts.
        This ensures the strategy receives new bar data as it becomes available.
        """
        self.register_indicator_for_bars(self.bar_type, self.fast_ma)
        self.register_indicator_for_bars(self.bar_type, self.slow_ma)
        self.subscribe_bars(self.bar_type)

    def on_bar(self, bar: Bar):
        """Called on each new bar. This is where the core trading logic for SMA crossover is executed."""
        # Wait until both indicators have enough historical data to be initialized.
        if not self.fast_ma.initialized or not self.slow_ma.initialized:
            return

        fast_val = self.fast_ma.value # Get the current value of the fast SMA.
        slow_val = self.slow_ma.value # Get the current value of the slow SMA.

        # Determine the current net position for the instrument (long, short, or flat).
        net_pos = self.portfolio.net_position(self.instrument_id)

        # BUY signal logic: fast MA crosses above slow MA, and we are currently flat or short.
        if fast_val > slow_val and net_pos <= 0:
            if net_pos < 0:
                # If currently short, close the existing short position first.
                self.cancel_all_orders(self.instrument_id)
                self.close_all_positions(self.instrument_id)
            # Submit a market buy order for the defined trade size.
            order = self.order_factory.market(
                instrument_id=self.instrument_id,
                order_side=OrderSide.BUY,
                quantity=self.trade_size,
            )
            self.submit_order(order)
            self.log.info(f"BUY  @ {bar.close}  fast={fast_val:.5f} slow={slow_val:.5f}")

        # SELL signal logic: fast MA crosses below slow MA, and we are currently flat or long.
        elif fast_val < slow_val and net_pos >= 0:
            if net_pos > 0:
                # If currently long, close the existing long position first.
                self.cancel_all_orders(self.instrument_id)
                self.close_all_positions(self.instrument_id)
            # Submit a market sell order for the defined trade size.
            order = self.order_factory.market(
                instrument_id=self.instrument_id,
                order_side=OrderSide.SELL,
                quantity=self.trade_size,
            )
            self.submit_order(order)
            self.log.info(f"SELL @ {bar.close}  fast={fast_val:.5f} slow={slow_val:.5f}")

    def on_stop(self):
        """Close all open positions when the strategy stops to ensure a clean exit."""
        self.cancel_all_orders(self.instrument_id)
        self.close_all_positions(self.instrument_id)


print("SMACrossoverStrategy class defined successfully.")

# Instantiate the strategy with its config
strategy_config = SMACrossoverConfig(
    instrument_id=EURUSD.id,
    bar_type=bar_type,
    fast_ma_period=10,
    slow_ma_period=20,
    trade_size=1000.0,  # 1,000 units of EUR/USD
)
strategy = SMACrossoverStrategy(config=strategy_config)

# Add the strategy to the engine
engine.add_strategy(strategy)

# Run the backtest over the full data range
print("Starting backtest...")
engine.run()
print("Backtest finished.")

# --- Performance Summary ---
# NautilusTrader exposes trade reports directly from engine.trader

# Generate a report of all filled orders (trades).
fills_report = engine.trader.generate_order_fills_report()
# Generate a report of all positions taken by the strategy.
positions_report = engine.trader.generate_positions_report()
# Generate an account summary report for the specified venue.
account_report = engine.trader.generate_account_report(Venue("SIM"))

print("=== Account Report ===")
display(account_report)

print(f"\n=== Positions ({len(positions_report)} total) ===")
display(positions_report)

print(f"\n=== Fills ({len(fills_report)} total) ===")
display(fills_report.head(10))

# Build equity curve from positions report instead of fills for PnL calculation.
if len(positions_report) > 0:
    # Initialize lists to store PnL values and corresponding timestamps.
    pnl_values = []
    timestamps = []

    # Iterate through each row in the positions report to extract realized PnL.
    for idx, row in positions_report.iterrows():
        # Check if 'realized_pnl' exists and is not null.
        if 'realized_pnl' in row and pd.notna(row['realized_pnl']):
            # Extract the numeric value from the 'X.XX USD' string format.
            pnl_str = str(row['realized_pnl'])
            pnl_value = float(pnl_str.split()[0])
            pnl_values.append(pnl_value)
            # Convert the closing timestamp to a datetime object.
            timestamps.append(pd.to_datetime(row['ts_closed'], unit='ns', utc=True))

    if pnl_values:
        # Calculate the cumulative PnL over time.
        cum_pnl = np.cumsum(pnl_values)

        plt.figure(figsize=(14, 7))
        plt.plot(timestamps, cum_pnl, label='Cumulative PnL', color='blue', linewidth=2)
        plt.axhline(0, color='gray', linestyle='--', linewidth=0.8) # Add a horizontal line at 0 for reference.
        plt.title('Equity Curve — SMA Crossover Strategy', fontsize=14, fontweight='bold')
        plt.xlabel('Date', fontsize=12)
        plt.ylabel('Cumulative PnL (USD)', fontsize=12)
        plt.grid(True, linestyle='--', alpha=0.6)
        plt.legend(fontsize=12)
        plt.tight_layout()
        plt.show()

        print(f"Total Return: ${cum_pnl[-1]:.2f}")
        print(f"Number of Trades: {len(pnl_values)}")
    else:
        print("No PnL data found in positions report.")
else:
    print("No positions recorded — the strategy did not generate any trades.")
    equity_curve = pd.DataFrame(columns=['equity'])

# Drawdown curve derived from the equity curve.
# Ensure cum_pnl exists and is not empty before proceeding.
if 'cum_pnl' in locals() and len(cum_pnl) > 0:
    # Create a pandas Series for the equity curve with timestamps as index.
    equity_series = pd.Series(cum_pnl, index=timestamps)

    # Calculate the running maximum (peak) of the equity curve.
    running_max = equity_series.expanding(min_periods=1).max()
    # Calculate the absolute drawdown: current equity minus the running maximum.
    drawdown = equity_series - running_max  # absolute drawdown in USD

    plt.figure(figsize=(14, 7))
    plt.plot(drawdown.index, drawdown, label='Drawdown (USD)', color='red', linewidth=2)
    plt.fill_between(drawdown.index, drawdown, 0, color='red', alpha=0.3) # Fill the area under the drawdown curve.
    plt.title('Drawdown Curve — SMA Crossover Strategy', fontsize=14, fontweight='bold')
    plt.xlabel('Date', fontsize=12)
    plt.ylabel('Drawdown (USD)', fontsize=12)
    plt.grid(True, linestyle='--', alpha=0.6)
    plt.legend(fontsize=12)
    plt.tight_layout()
    plt.show()

    max_drawdown = drawdown.min() # Find the maximum (most negative) drawdown value.
    print(f"Maximum Drawdown: ${max_drawdown:.2f}")

else:
    print("Equity curve is empty — no drawdown to display.")