!pip install pandas numpy plotly

import warnings
warnings.filterwarnings("ignore")

import pandas as pd
import numpy as np
import plotly.graph_objects as go
from plotly.subplots import make_subplots

def generate_data(periods: int) -> pd.DataFrame:
    start_date     = pd.to_datetime("2024-01-01 00:00:00+00:00")
    datetime_index = pd.date_range(start_date, periods=periods, freq="1min", tz="UTC")
    price_data = []; last_close = 42000
    volatility_scale = 0.005; wick_scale = 0.002

    for _ in range(periods):
        open_price  = last_close + np.random.normal(0, last_close * volatility_scale * 0.1)
        close_price = open_price + np.random.normal(0, last_close * volatility_scale)
        body_high   = max(open_price, close_price)
        body_low    = min(open_price, close_price)
        high_price  = max(body_high + abs(np.random.normal(0, last_close * wick_scale)),
                          open_price, close_price)
        low_price   = min(body_low  - abs(np.random.normal(0, last_close * wick_scale)),
                          open_price, close_price)
        if high_price < low_price:
            high_price, low_price = low_price, high_price
        price_data.append({
            "open":  max(1, int(open_price)),
            "high":  max(1, int(high_price)),
            "low":   max(1, int(low_price)),
            "close": max(1, int(close_price)),
        })
        last_close = close_price

    df = pd.DataFrame(price_data, index=datetime_index)
    df.index.name = "datetime"
    df["volume"]   = np.random.uniform(100.0, 500.0, periods)
    df["datetime"] = df.index.to_series()
    return df.reset_index(drop=True)

df = generate_data(500)
display(df.head())

def extract_trades(
    df:          pd.DataFrame,
    fast_window: int   = 10,
    slow_window: int   = 30,
    fee_pct:     float = 0.0005,
) -> pd.DataFrame:
    """
    Simulate MA crossover entries and exits and return a trade-level
    DataFrame with one row per completed round-trip trade.
    """
    df = df.copy().sort_values("datetime", ignore_index=True)
    df["fast_ma"] = df["close"].rolling(fast_window).mean()
    df["slow_ma"] = df["close"].rolling(slow_window).mean()
    df["signal"]  = np.where(df["fast_ma"] > df["slow_ma"], 1, 0)
    df["trade"]   = df["signal"].diff()

    trades      = []
    entry_price = None
    entry_dt    = None
    entry_bar   = None

    for i, row in df.iterrows():
        if row["trade"] == 1:
            entry_price = row["close"]
            entry_dt    = row["datetime"]
            entry_bar   = i

        elif row["trade"] == -1 and entry_price is not None:
            exit_price  = row["close"]
            gross_pnl   = (exit_price - entry_price) / entry_price * 100
            net_pnl     = gross_pnl - 2 * fee_pct * 100   # Round-trip fee
            hold_bars   = i - entry_bar

            trades.append({
                "entry_datetime":  entry_dt,
                "exit_datetime":   row["datetime"],
                "entry_price":     entry_price,
                "exit_price":      exit_price,
                "gross_pnl_pct":   round(gross_pnl, 4),
                "net_pnl_pct":     round(net_pnl,   4),
                "holding_bars":    hold_bars,
                "win":             net_pnl > 0,
            })
            entry_price = None

    return pd.DataFrame(trades)

trades = extract_trades(df, fast_window=10, slow_window=30, fee_pct=0.0005)

print(f"Total Completed Trades: {len(trades)}")
display(trades.head(10))

def compute_trade_metrics(trades: pd.DataFrame) -> dict:
    """
    Compute comprehensive trade-level performance metrics from
    a completed trade log.
    """
    if len(trades) == 0:
        return {"error": "No completed trades."}

    wins   = trades[trades["win"]]
    losses = trades[~trades["win"]]

    gross_profit = wins["net_pnl_pct"].sum()
    gross_loss   = losses["net_pnl_pct"].abs().sum()
    profit_factor= gross_profit / gross_loss if gross_loss > 0 else np.inf
    rr_ratio     = abs(wins["net_pnl_pct"].mean() / losses["net_pnl_pct"].mean()) if len(losses) > 0 else np.inf
    win_rate     = len(wins) / len(trades)
    expectancy   = trades["net_pnl_pct"].mean()

    # Consecutive losses
    run = 0; max_run = 0
    for w in trades["win"]:
        if not w:
            run += 1; max_run = max(max_run, run)
        else:
            run = 0

    return {
        "total_trades":        len(trades),
        "winning_trades":      len(wins),
        "losing_trades":       len(losses),
        "win_rate_pct":        round(win_rate * 100, 2),
        "avg_win_pct":         round(wins["net_pnl_pct"].mean(),   4) if len(wins)   > 0 else 0,
        "avg_loss_pct":        round(losses["net_pnl_pct"].mean(), 4) if len(losses) > 0 else 0,
        "reward_risk_ratio":   round(rr_ratio,     4),
        "profit_factor":       round(profit_factor, 4),
        "expectancy_pct":      round(expectancy,    4),
        "max_consecutive_loss":max_run,
        "total_gross_profit":  round(gross_profit,  4),
        "total_gross_loss":    round(gross_loss,     4),
        "avg_holding_bars":    round(trades["holding_bars"].mean(), 1),
        "max_holding_bars":    int(trades["holding_bars"].max()),
        "min_holding_bars":    int(trades["holding_bars"].min()),
    }

metrics = compute_trade_metrics(trades)

print("--- Trade-Level Metrics ---")
for k, v in metrics.items():
    print(f"  {k:<28}: {v}")

fig = make_subplots(
    rows=2, cols=2,
    subplot_titles=[
        "Per-Trade Net PnL (%)",
        "PnL Distribution",
        "Cumulative PnL (%)",
        "Holding Duration (bars)",
    ],
)

colors = ["green" if w else "red" for w in trades["win"]]

# Per-trade bar chart
fig.add_trace(go.Bar(
    x=list(range(len(trades))),
    y=trades["net_pnl_pct"],
    marker_color=colors,
    name="Net PnL (%)"), row=1, col=1)

# PnL histogram
fig.add_trace(go.Histogram(
    x=trades["net_pnl_pct"],
    nbinsx=30,
    marker_color="steelblue",
    name="PnL Distribution"), row=1, col=2)

fig.add_vline(x=0, line_dash="dash", line_color="red", row=1, col=2)
fig.add_vline(x=metrics["expectancy_pct"], line_dash="dash", line_color="green",
              annotation_text=f"Expectancy: {metrics['expectancy_pct']:.4f}%",
              row=1, col=2)

# Cumulative PnL
fig.add_trace(go.Scatter(
    x=list(range(len(trades))),
    y=trades["net_pnl_pct"].cumsum(),
    mode="lines",
    line=dict(color="green", width=2),
    name="Cumulative PnL (%)"), row=2, col=1)

fig.add_hline(y=0, line_dash="dot", line_color="gray", row=2, col=1)

# Holding duration
fig.add_trace(go.Bar(
    x=list(range(len(trades))),
    y=trades["holding_bars"],
    marker_color="steelblue",
    name="Holding Bars"), row=2, col=2)

fig.update_layout(
    title_text="Trade-Level Performance Analysis",
    height=700,
    showlegend=False,
)
fig.show()