!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)

# --- Compute strategy and market returns ---
df["fast_ma"]         = df["close"].rolling(10).mean()
df["slow_ma"]         = df["close"].rolling(30).mean()
df["signal"]          = np.where(df["fast_ma"] > df["slow_ma"], 1, 0)
df["position"]        = df["signal"].shift(1).fillna(0)
df["trade"]           = df["position"].diff().abs()
df["market_return"]   = df["close"].pct_change()
df["strategy_return"] = df["position"] * df["market_return"] - df["trade"] * 0.0005
df = df.dropna()

display(df[["datetime","close","fast_ma","slow_ma","position","strategy_return"]].head(10))

def calculate_sharpe_sortino(
    returns:          pd.Series,
    risk_free_rate:   float = 0.0,
    periods_per_year: int   = 525_600,
) -> dict:
    """
    Compute Sharpe ratio, Sortino ratio, Calmar ratio, and supporting
    statistics from a per-period return series.

    Parameters
    ----------
    returns          : Per-period return series (not cumulative).
    risk_free_rate   : Annualized risk-free rate (e.g., 0.04 = 4%).
    periods_per_year : Number of return observations per calendar year.
    """
    # Per-period risk-free adjustment
    rf_per_period = risk_free_rate / periods_per_year
    excess        = returns - rf_per_period
    ann_factor    = np.sqrt(periods_per_year)

    # Sharpe Ratio
    sharpe = (excess.mean() / excess.std()) * ann_factor if excess.std() != 0 else np.nan

    # Sortino Ratio — denominator uses downside returns only
    downside_returns = excess[excess < 0]
    downside_std     = downside_returns.std()
    sortino = (excess.mean() / downside_std) * ann_factor if downside_std != 0 else np.nan

    # Annualized return
    ann_return = excess.mean() * periods_per_year

    # Equity curve and Max Drawdown for Calmar
    equity     = (1 + returns).cumprod()
    peak       = equity.cummax()
    drawdown   = (equity - peak) / peak
    max_dd     = drawdown.min()
    calmar     = ann_return / abs(max_dd) if max_dd != 0 else np.nan

    return {
        "annualized_return":  round(ann_return  * 100, 4),
        "annualized_std":     round(excess.std() * ann_factor * 100, 4),
        "downside_std":       round(downside_std  * ann_factor * 100, 4),
        "sharpe_ratio":       round(sharpe,  4) if not np.isnan(sharpe)  else None,
        "sortino_ratio":      round(sortino, 4) if not np.isnan(sortino) else None,
        "calmar_ratio":       round(calmar,  4) if not np.isnan(calmar)  else None,
        "max_drawdown_pct":   round(max_dd   * 100, 4),
        "n_observations":     len(returns),
    }

strategy_metrics = calculate_sharpe_sortino(df["strategy_return"], risk_free_rate=0.0)
market_metrics   = calculate_sharpe_sortino(df["market_return"],   risk_free_rate=0.0)

print("--- Strategy Metrics ---")
for k, v in strategy_metrics.items():
    print(f"  {k:<25}: {v}")

print("\n--- Buy-and-Hold Metrics ---")
for k, v in market_metrics.items():
    print(f"  {k:<25}: {v}")

ROLLING_WINDOW = 50   # 50-bar rolling window

df["rolling_sharpe"] = (
    df["strategy_return"].rolling(ROLLING_WINDOW).mean() /
    df["strategy_return"].rolling(ROLLING_WINDOW).std()
) * np.sqrt(525_600)

df["rolling_sortino"] = (
    df["strategy_return"].rolling(ROLLING_WINDOW).mean() /
    df["strategy_return"].rolling(ROLLING_WINDOW).apply(
        lambda x: x[x < 0].std() if len(x[x < 0]) > 1 else np.nan
    )
) * np.sqrt(525_600)

print("--- Rolling Sharpe Statistics ---")
print(df["rolling_sharpe"].describe().round(4))

df["strategy_equity"] = (1 + df["strategy_return"]).cumprod() * 10_000
df["market_equity"]   = (1 + df["market_return"]).cumprod()   * 10_000

fig = make_subplots(
    rows=3, cols=1, shared_xaxes=True,
    subplot_titles=[
        "Equity Curve — Strategy vs Buy-and-Hold",
        "Rolling Sharpe and Sortino (50-bar window)",
        "Per-Period Strategy Returns",
    ],
    row_heights=[0.4, 0.35, 0.25],
)

fig.add_trace(go.Scatter(
    x=df["datetime"], y=df["strategy_equity"],
    mode="lines", name="Strategy",
    line=dict(color="green", width=2)), row=1, col=1)

fig.add_trace(go.Scatter(
    x=df["datetime"], y=df["market_equity"],
    mode="lines", name="Buy and Hold",
    line=dict(color="gray", width=1.5, dash="dash")), row=1, col=1)

fig.add_trace(go.Scatter(
    x=df["datetime"], y=df["rolling_sharpe"],
    mode="lines", name="Rolling Sharpe",
    line=dict(color="blue", width=1)), row=2, col=1)

fig.add_trace(go.Scatter(
    x=df["datetime"], y=df["rolling_sortino"],
    mode="lines", name="Rolling Sortino",
    line=dict(color="orange", width=1, dash="dot")), row=2, col=1)

fig.add_hline(y=0, line_dash="dot", line_color="gray", row=2, col=1)
fig.add_hline(y=1, line_dash="dash", line_color="green", row=2, col=1,
              annotation_text="Sharpe = 1.0")

fig.add_trace(go.Bar(
    x=df["datetime"], y=df["strategy_return"],
    name="Strategy Return",
    marker_color=["green" if r >= 0 else "red" for r in df["strategy_return"]]),
    row=3, col=1)

fig.update_layout(
    title_text="Sharpe and Sortino Ratio Analysis",
    xaxis_rangeslider_visible=False,
    height=900,
    xaxis3_title="Datetime",
    yaxis_title="Portfolio Value ($)",
    yaxis2_title="Ratio",
    yaxis3_title="Return",
)
fig.show()