Vectorbt Expert

"""
Buy & Hold Portfolio Backtest - VectorBT + OpenAlgo
Strategy: Static allocation across ETFs (e.g., 60% NIFTYBEES + 40% GOLDBEES).
          One-time purchase on Day 1, hold forever.
Fees: Indian delivery equity model (0.111% + Rs 20/order).
Benchmark: NIFTY 50 Index via OpenAlgo (NSE_INDEX) + HDFC FD rate.
"""

import os
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd
import vectorbt as vbt
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from dotenv import find_dotenv, load_dotenv
from openalgo import api

# --- Config ---
script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOLS = ["NIFTYBEES", "GOLDBEES"]
WEIGHTS = {"NIFTYBEES": 0.60, "GOLDBEES": 0.40}
EXCHANGE = "NSE"
INTERVAL = "D"
INIT_CASH = 10_00_000
FEES = 0.00111              # Indian delivery equity
FIXED_FEES = 20             # Rs 20 per order
FD_CAGR = 0.0645            # HDFC Bank FD rate 6.45%
BENCHMARK_SYMBOL = "NIFTY"
BENCHMARK_EXCHANGE = "NSE_INDEX"


def calc_cagr(start_val, end_val, years):
    """Calculate CAGR given start value, end value, and number of years."""
    if start_val <= 0 or end_val <= 0 or years <= 0:
        return 0.0
    return (end_val / start_val) ** (1 / years) - 1


# --- Fetch Data ---
client = api(
    api_key=os.getenv("OPENALGO_API_KEY"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end_date = datetime.now().date()
start_date = "2018-01-01"

print(f"Fetching data for {SYMBOLS} ({EXCHANGE}) from {start_date} to {end_date}")

dfs = {}
for sym in SYMBOLS:
    df = client.history(
        symbol=sym, exchange=EXCHANGE, interval=INTERVAL,
        start_date=start_date, end_date=end_date.strftime("%Y-%m-%d"),
    )
    if "timestamp" in df.columns:
        df["timestamp"] = pd.to_datetime(df["timestamp"])
        df = df.set_index("timestamp")
    else:
        df.index = pd.to_datetime(df.index)
    df = df.sort_index()
    if df.index.tz is not None:
        df.index = df.index.tz_convert(None)
    dfs[sym] = df
    print(f"  {sym}: {len(df)} bars from {df.index[0].date()} to {df.index[-1].date()}")

# --- Build Price Panel ---
close_prices = pd.DataFrame({sym: dfs[sym]["close"] for sym in SYMBOLS}).dropna()
print(f"\nAligned data: {len(close_prices)} bars")

# --- Buy & Hold: One-time allocation on Day 1 ---
size_df = pd.DataFrame(np.nan, index=close_prices.index, columns=SYMBOLS)
size_df.iloc[0] = [WEIGHTS[sym] for sym in SYMBOLS]

pf = vbt.Portfolio.from_orders(
    close=close_prices, size=size_df, size_type="targetpercent",
    fees=FEES, fixed_fees=FIXED_FEES, init_cash=INIT_CASH,
    cash_sharing=True, call_seq="auto", group_by=True,
    freq="1D", min_size=1, size_granularity=1,
)

# --- Benchmark ---
print("\nFetching NIFTY 50 index data for benchmark...")
df_nifty = client.history(
    symbol=BENCHMARK_SYMBOL, exchange=BENCHMARK_EXCHANGE, interval=INTERVAL,
    start_date=start_date, end_date=end_date.strftime("%Y-%m-%d"),
)
if "timestamp" in df_nifty.columns:
    df_nifty["timestamp"] = pd.to_datetime(df_nifty["timestamp"])
    df_nifty = df_nifty.set_index("timestamp")
else:
    df_nifty.index = pd.to_datetime(df_nifty.index)
df_nifty = df_nifty.sort_index()
if df_nifty.index.tz is not None:
    df_nifty.index = df_nifty.index.tz_convert(None)
nifty_close = df_nifty["close"].reindex(close_prices.index).ffill().bfill()

pf_niftybees = vbt.Portfolio.from_holding(
    close_prices["NIFTYBEES"], init_cash=INIT_CASH, fees=FEES, freq="1D")
pf_goldbees = vbt.Portfolio.from_holding(
    close_prices["GOLDBEES"], init_cash=INIT_CASH, fees=FEES, freq="1D")

# --- Results ---
print("\n" + "=" * 60)
print(f"  Buy & Hold: {WEIGHTS['NIFTYBEES']*100:.0f}% NIFTYBEES + {WEIGHTS['GOLDBEES']*100:.0f}% GOLDBEES")
print("=" * 60)
print(pf.stats())

# --- CAGR Calculations ---
equity = pf.value()
n_days = (close_prices.index[-1] - close_prices.index[0]).days
n_years = n_days / 365.25

cagr_portfolio = calc_cagr(INIT_CASH, equity.iloc[-1], n_years)
cagr_nifty50 = calc_cagr(nifty_close.iloc[0], nifty_close.iloc[-1], n_years)
fd_final = INIT_CASH * (1 + FD_CAGR) ** n_years

# --- Strategy vs Benchmark ---
print("\n--- Strategy vs Benchmark ---")
comparison = pd.DataFrame({
    f"Portfolio ({WEIGHTS['NIFTYBEES']*100:.0f}/{WEIGHTS['GOLDBEES']*100:.0f})": [
        f"{pf.total_return() * 100:.2f}%",
        f"{cagr_portfolio * 100:.2f}%",
        f"{pf.sharpe_ratio():.2f}",
        f"{pf.sortino_ratio():.2f}",
        f"{pf.max_drawdown() * 100:.2f}%",
        f"Rs {equity.iloc[-1]:,.0f}",
    ],
    f"Benchmark ({BENCHMARK_SYMBOL})": [
        f"{(nifty_close.iloc[-1] / nifty_close.iloc[0] - 1) * 100:.2f}%",
        f"{cagr_nifty50 * 100:.2f}%",
        "-", "-", "-",
        "-",
    ],
    "NIFTYBEES B&H": [
        f"{pf_niftybees.total_return() * 100:.2f}%",
        "-",
        f"{pf_niftybees.sharpe_ratio():.2f}",
        f"{pf_niftybees.sortino_ratio():.2f}",
        f"{pf_niftybees.max_drawdown() * 100:.2f}%",
        f"Rs {pf_niftybees.value().iloc[-1]:,.0f}",
    ],
    "GOLDBEES B&H": [
        f"{pf_goldbees.total_return() * 100:.2f}%",
        "-",
        f"{pf_goldbees.sharpe_ratio():.2f}",
        f"{pf_goldbees.sortino_ratio():.2f}",
        f"{pf_goldbees.max_drawdown() * 100:.2f}%",
        f"Rs {pf_goldbees.value().iloc[-1]:,.0f}",
    ],
    f"HDFC FD ({FD_CAGR*100:.2f}%)": [
        f"{(fd_final / INIT_CASH - 1) * 100:.2f}%",
        f"{FD_CAGR * 100:.2f}%",
        "-", "-", "0.00%",
        f"Rs {fd_final:,.0f}",
    ],
}, index=["Total Return", "CAGR", "Sharpe Ratio", "Sortino Ratio",
          "Max Drawdown", "Final Value"])
print(comparison.to_string())

# --- Explain ---
print("\n--- Backtest Report Explanation ---")
print(f"* Total Return: Your portfolio made {pf.total_return() * 100:.2f}%")
print(f"  while NIFTY 50 made {(nifty_close.iloc[-1] / nifty_close.iloc[0] - 1) * 100:.2f}%")
alpha = pf.total_return() - (nifty_close.iloc[-1] / nifty_close.iloc[0] - 1)
if alpha > 0:
    print(f"  -> BEAT the market by {alpha * 100:.2f}%")
else:
    print(f"  -> UNDERPERFORMED by {abs(alpha) * 100:.2f}%")
print(f"* CAGR: {cagr_portfolio * 100:.2f}% annualized vs FD at {FD_CAGR * 100:.2f}%")
if cagr_portfolio > FD_CAGR:
    print(f"  -> BEAT the FD by {(cagr_portfolio - FD_CAGR) * 100:.2f}% per year")
else:
    print(f"  -> UNDERPERFORMED FD by {(FD_CAGR - cagr_portfolio) * 100:.2f}% per year")
print(f"* Max Drawdown: {pf.max_drawdown() * 100:.2f}% - the biggest drop from peak")
print(f"  -> On Rs {INIT_CASH:,} capital, the worst temporary loss = Rs {abs(pf.max_drawdown()) * INIT_CASH:,.0f}")
print(f"* This is a PASSIVE strategy - buy once and hold, no rebalancing needed")
print(f"* Gold (GOLDBEES) provides diversification when equity markets fall")

# --- Plot ---
cum_strat = equity / equity.iloc[0] - 1
cum_nifty = nifty_close / nifty_close.iloc[0] - 1
cum_niftybees = close_prices["NIFTYBEES"] / close_prices["NIFTYBEES"].iloc[0] - 1
cum_goldbees = close_prices["GOLDBEES"] / close_prices["GOLDBEES"].iloc[0] - 1
drawdown = equity / equity.cummax() - 1

fd_daily_rate = (1 + FD_CAGR) ** (1 / 365.25) - 1
fd_equity = pd.Series(
    INIT_CASH * (1 + fd_daily_rate) ** np.arange(len(close_prices)),
    index=close_prices.index,
)
cum_fd = fd_equity / fd_equity.iloc[0] - 1

fig = make_subplots(rows=2, cols=1, shared_xaxes=True,
                    row_heights=[0.65, 0.35], vertical_spacing=0.07)

fig.add_trace(go.Scatter(x=cum_strat.index, y=cum_strat * 100,
    name="Portfolio", line=dict(color="#00d4aa", width=2.5)), row=1, col=1)
fig.add_trace(go.Scatter(x=cum_nifty.index, y=cum_nifty * 100,
    name="NIFTY 50", line=dict(color="#ff6688", width=1.5, dash="dash")), row=1, col=1)
fig.add_trace(go.Scatter(x=cum_niftybees.index, y=cum_niftybees * 100,
    name="NIFTYBEES", line=dict(color="#4488ff", width=1, dash="dot")), row=1, col=1)
fig.add_trace(go.Scatter(x=cum_goldbees.index, y=cum_goldbees * 100,
    name="GOLDBEES", line=dict(color="#ffaa00", width=1, dash="dot")), row=1, col=1)
fig.add_trace(go.Scatter(x=cum_fd.index, y=cum_fd * 100,
    name=f"HDFC FD {FD_CAGR*100:.2f}%", line=dict(color="#888888", width=1.5, dash="dashdot")), row=1, col=1)
fig.add_trace(go.Scatter(x=drawdown.index, y=drawdown * 100,
    name="Drawdown", fill="tozeroy", line=dict(color="#ff4444", width=1)), row=2, col=1)

fig.update_yaxes(ticksuffix="%", side="right", row=1, col=1)
fig.update_yaxes(title_text="Drawdown %", ticksuffix="%", side="right", row=2, col=1)
fig.update_layout(template="plotly_dark",
    title=f"Buy & Hold: {WEIGHTS['NIFTYBEES']*100:.0f}% NIFTYBEES + {WEIGHTS['GOLDBEES']*100:.0f}% GOLDBEES vs Benchmarks",
    height=700)
fig.show()

# --- Export ---
orders_file = script_dir / "buy_hold_orders.csv"
pf.orders.records_readable.to_csv(orders_file, index=False)
print(f"\nOrders exported to {orders_file}")

"""
Donchian Channel Breakout Backtest - VectorBT + OpenAlgo
Strategy: Buy when price breaks above N-period high, sell when breaks below N-period low.
Indicators: openalgo.ta.donchian (shifted by 1 to avoid lookahead).
Fees: Indian delivery equity model (0.111% + Rs 20/order).
Benchmark: NIFTY 50 Index via OpenAlgo (NSE_INDEX).
"""

import os
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd
import vectorbt as vbt
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

# --- Config ---
script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"
DONCHIAN_PERIOD = 20
INIT_CASH = 1_000_000
FEES = 0.00111
FIXED_FEES = 20
ALLOCATION = 0.75
BENCHMARK_SYMBOL = "NIFTY"
BENCHMARK_EXCHANGE = "NSE_INDEX"

# --- Fetch Data ---
client = api(
    api_key=os.getenv("OPENALGO_API_KEY"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365 * 3)

print(f"Fetching {SYMBOL} ({EXCHANGE}) {INTERVAL} data from {start_date} to {end_date}")

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)

if "timestamp" in df.columns:
    df["timestamp"] = pd.to_datetime(df["timestamp"])
    df = df.set_index("timestamp")
else:
    df.index = pd.to_datetime(df.index)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

close = df["close"]
high = df["high"]
low = df["low"]
print(f"Data loaded: {len(df)} bars from {df.index[0].date()} to {df.index[-1].date()}")

# --- Strategy: Donchian Channel Breakout ---
upper, middle, lower = ta.donchian(high, low, period=DONCHIAN_PERIOD)

# Shift by 1 to avoid lookahead bias
upper_shifted = upper.shift(1)
lower_shifted = lower.shift(1)

buy_raw = pd.Series(ta.crossover(close, upper_shifted), index=df.index).fillna(False)
sell_raw = pd.Series(ta.crossunder(close, lower_shifted), index=df.index).fillna(False)

entries = ta.exrem(buy_raw, sell_raw)
exits = ta.exrem(sell_raw, buy_raw)

print(f"Signals - Entries: {entries.sum()}, Exits: {exits.sum()}")

# --- Backtest ---
pf = vbt.Portfolio.from_signals(
    close, entries, exits,
    init_cash=INIT_CASH,
    size=ALLOCATION,
    size_type="percent",
    fees=FEES,
    fixed_fees=FIXED_FEES,
    direction="longonly",
    min_size=1,
    size_granularity=1,
    freq="1D",
)

# --- Benchmark: NIFTY 50 Index ---
print(f"\nFetching benchmark: {BENCHMARK_SYMBOL} ({BENCHMARK_EXCHANGE})")
df_bench = client.history(
    symbol=BENCHMARK_SYMBOL, exchange=BENCHMARK_EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
if "timestamp" in df_bench.columns:
    df_bench["timestamp"] = pd.to_datetime(df_bench["timestamp"])
    df_bench = df_bench.set_index("timestamp")
else:
    df_bench.index = pd.to_datetime(df_bench.index)
df_bench = df_bench.sort_index()
if df_bench.index.tz is not None:
    df_bench.index = df_bench.index.tz_convert(None)

bench_close = df_bench["close"].reindex(close.index).ffill().bfill()
pf_bench = vbt.Portfolio.from_holding(bench_close, init_cash=INIT_CASH, fees=FEES, freq="1D")

# --- Results ---
print("\n" + "=" * 60)
print(f"  Donchian({DONCHIAN_PERIOD}) Channel Breakout - {SYMBOL} ({EXCHANGE})")
print("=" * 60)
print(pf.stats())

# --- Strategy vs Benchmark Metrics ---
print("\n--- Strategy vs Benchmark ---")
comparison = pd.DataFrame({
    "Strategy": [
        f"{pf.total_return() * 100:.2f}%",
        f"{pf.sharpe_ratio():.2f}",
        f"{pf.sortino_ratio():.2f}",
        f"{pf.max_drawdown() * 100:.2f}%",
        f"{pf.trades.win_rate() * 100:.1f}%",
        f"{pf.trades.count()}",
        f"{pf.trades.profit_factor():.2f}",
    ],
    f"Benchmark ({BENCHMARK_SYMBOL})": [
        f"{pf_bench.total_return() * 100:.2f}%",
        f"{pf_bench.sharpe_ratio():.2f}",
        f"{pf_bench.sortino_ratio():.2f}",
        f"{pf_bench.max_drawdown() * 100:.2f}%",
        "-", "-", "-",
    ],
}, index=["Total Return", "Sharpe Ratio", "Sortino Ratio", "Max Drawdown",
          "Win Rate", "Total Trades", "Profit Factor"])
print(comparison.to_string())

# --- Explain Backtest Report ---
print("\n--- Backtest Report Explanation ---")
print(f"* Total Return: {pf.total_return() * 100:.2f}% vs benchmark {pf_bench.total_return() * 100:.2f}%")
alpha = pf.total_return() - pf_bench.total_return()
print(f"  -> Alpha: {alpha * 100:.2f}%")
print(f"* Sharpe Ratio: {pf.sharpe_ratio():.2f} - risk-adjusted return (>1 good, >2 excellent)")
print(f"* Max Drawdown: {pf.max_drawdown() * 100:.2f}% - worst peak-to-trough decline")
print(f"* Win Rate: {pf.trades.win_rate() * 100:.1f}% - Donchian breakout typically 30-40% (trend-following)")
print(f"* Profit Factor: {pf.trades.profit_factor():.2f} - gross profit / gross loss (>1.5 good)")
print(f"* Total Trades: {pf.trades.count()} - "
      f"{'sufficient' if pf.trades.count() >= 30 else 'too few for statistical significance'}")

# --- Plot ---
fig = pf.plot(
    subplots=["value", "underwater", "cum_returns"],
    template="plotly_dark",
    title=f"Donchian({DONCHIAN_PERIOD}) Breakout - {SYMBOL} ({EXCHANGE} {INTERVAL})",
)
fig.show()

# --- Export ---
trades_file = script_dir / f"{SYMBOL}_donchian_trades.csv"
pf.positions.records_readable.to_csv(trades_file, index=False)
print(f"\nTrades exported to {trades_file}")

"""
Dual Momentum (ETF Rotation) Backtest - VectorBT + OpenAlgo
Strategy: Quarterly momentum rotation between NIFTYBEES and GOLDBEES.
          Buys previous quarter's outperformer for the next quarter.
Fees: Indian delivery equity model (0.111% + Rs 20/order).
Benchmark: NIFTY 50 Index via OpenAlgo (NSE_INDEX).
"""

import os
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd
import vectorbt as vbt
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from dotenv import find_dotenv, load_dotenv
from openalgo import api

# --- Config ---
script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOLS = ["NIFTYBEES", "GOLDBEES"]
EXCHANGE = "NSE"
INTERVAL = "D"
INIT_CASH = 10_00_000
FEES = 0.00111              # Indian delivery equity
FIXED_FEES = 20             # Rs 20 per order
ALLOCATION = 0.75
BENCHMARK_SYMBOL = "NIFTY"
BENCHMARK_EXCHANGE = "NSE_INDEX"

# --- Fetch Data ---
client = api(
    api_key=os.getenv("OPENALGO_API_KEY"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end_date = datetime.now().date()
start_date = "2018-01-01"

print(f"Fetching data for {SYMBOLS} ({EXCHANGE}) from {start_date} to {end_date}")

dfs = {}
for sym in SYMBOLS:
    df = client.history(
        symbol=sym, exchange=EXCHANGE, interval=INTERVAL,
        start_date=start_date, end_date=end_date.strftime("%Y-%m-%d"),
    )
    if "timestamp" in df.columns:
        df["timestamp"] = pd.to_datetime(df["timestamp"])
        df = df.set_index("timestamp")
    else:
        df.index = pd.to_datetime(df.index)
    df = df.sort_index()
    if df.index.tz is not None:
        df.index = df.index.tz_convert(None)
    dfs[sym] = df
    print(f"  {sym}: {len(df)} bars from {df.index[0].date()} to {df.index[-1].date()}")

# --- Build Panel ---
close_prices = pd.DataFrame({sym: dfs[sym]["close"] for sym in SYMBOLS}).dropna()
open_prices = pd.DataFrame({sym: dfs[sym]["open"] for sym in SYMBOLS})
open_prices = open_prices.reindex(close_prices.index).ffill().bfill()

# --- Quarterly Returns & Winner Selection ---
quarterly_close = close_prices.resample("QE").last().dropna(how="all")
quarterly_returns = quarterly_close.pct_change()

# Winner shifted by 1 quarter (use PREVIOUS quarter's winner)
winner = quarterly_returns.idxmax(axis=1)
winner_shifted = winner.shift(1).dropna()

# --- Build Daily Allocation Weights ---
alloc_daily = pd.Series(index=close_prices.index, dtype="object")
for dt, sym in winner_shifted.items():
    next_idx_pos = close_prices.index.searchsorted(dt, side="right")
    if next_idx_pos < len(close_prices.index):
        alloc_daily.loc[close_prices.index[next_idx_pos]] = sym

alloc_daily = alloc_daily.ffill()
alloc_daily = alloc_daily.loc[alloc_daily.first_valid_index():]

weights = pd.DataFrame(index=alloc_daily.index, columns=SYMBOLS, dtype=float)
weights["NIFTYBEES"] = np.where(alloc_daily == "NIFTYBEES", ALLOCATION, 0.0)
weights["GOLDBEES"] = np.where(alloc_daily == "GOLDBEES", ALLOCATION, 0.0)

switch_mask = alloc_daily.ne(alloc_daily.shift(1))
switch_mask.iloc[0] = True
target_on_switch = weights.where(switch_mask, np.nan)

# --- Backtest ---
price_df = open_prices.loc[alloc_daily.index]

pf = vbt.Portfolio.from_orders(
    close=price_df, size=target_on_switch, size_type="targetpercent",
    fees=FEES, fixed_fees=FIXED_FEES, init_cash=INIT_CASH,
    cash_sharing=True, call_seq="auto", group_by=True,
    freq="1D", min_size=1, size_granularity=1,
)

# --- Benchmark ---
df_nifty = client.history(
    symbol=BENCHMARK_SYMBOL, exchange=BENCHMARK_EXCHANGE, interval=INTERVAL,
    start_date=start_date, end_date=end_date.strftime("%Y-%m-%d"),
)
if "timestamp" in df_nifty.columns:
    df_nifty["timestamp"] = pd.to_datetime(df_nifty["timestamp"])
    df_nifty = df_nifty.set_index("timestamp")
else:
    df_nifty.index = pd.to_datetime(df_nifty.index)
df_nifty = df_nifty.sort_index()
if df_nifty.index.tz is not None:
    df_nifty.index = df_nifty.index.tz_convert(None)
nifty_close = df_nifty["close"].reindex(alloc_daily.index).ffill().bfill()
pf_bench = vbt.Portfolio.from_holding(nifty_close, init_cash=INIT_CASH, fees=FEES, freq="1D")

pf_bench_bees = vbt.Portfolio.from_holding(
    close_prices.loc[alloc_daily.index, "NIFTYBEES"], init_cash=INIT_CASH, fees=FEES, freq="1D")
pf_bench_gold = vbt.Portfolio.from_holding(
    close_prices.loc[alloc_daily.index, "GOLDBEES"], init_cash=INIT_CASH, fees=FEES, freq="1D")

# --- Results ---
print("\n" + "=" * 60)
print("  Dual Momentum - NIFTYBEES vs GOLDBEES (Quarterly Rebalance)")
print("=" * 60)
print(pf.stats())

print("\n--- Strategy vs Benchmark ---")
comparison = pd.DataFrame({
    "Dual Momentum": [
        f"{pf.total_return() * 100:.2f}%", f"{pf.sharpe_ratio():.2f}",
        f"{pf.sortino_ratio():.2f}", f"{pf.max_drawdown() * 100:.2f}%",
    ],
    f"Benchmark ({BENCHMARK_SYMBOL})": [
        f"{pf_bench.total_return() * 100:.2f}%", f"{pf_bench.sharpe_ratio():.2f}",
        f"{pf_bench.sortino_ratio():.2f}", f"{pf_bench.max_drawdown() * 100:.2f}%",
    ],
    "NIFTYBEES B&H": [
        f"{pf_bench_bees.total_return() * 100:.2f}%", f"{pf_bench_bees.sharpe_ratio():.2f}",
        f"{pf_bench_bees.sortino_ratio():.2f}", f"{pf_bench_bees.max_drawdown() * 100:.2f}%",
    ],
    "GOLDBEES B&H": [
        f"{pf_bench_gold.total_return() * 100:.2f}%", f"{pf_bench_gold.sharpe_ratio():.2f}",
        f"{pf_bench_gold.sortino_ratio():.2f}", f"{pf_bench_gold.max_drawdown() * 100:.2f}%",
    ],
}, index=["Total Return", "Sharpe Ratio", "Sortino Ratio", "Max Drawdown"])
print(comparison.to_string())

# --- Explain ---
print("\n--- Backtest Report Explanation ---")
print(f"* Total Return: Your strategy made {pf.total_return() * 100:.2f}%")
print(f"  while NIFTY 50 made {pf_bench.total_return() * 100:.2f}%")
alpha = pf.total_return() - pf_bench.total_return()
if alpha > 0:
    print(f"  -> BEAT the market by {alpha * 100:.2f}%")
else:
    print(f"  -> UNDERPERFORMED by {abs(alpha) * 100:.2f}%")
print(f"* The strategy rotates quarterly into whichever ETF performed better last quarter")
print(f"* This captures momentum - assets that did well recently tend to continue")
print(f"* Max Drawdown: {pf.max_drawdown() * 100:.2f}% - the biggest drop from peak")
print(f"  -> On Rs {INIT_CASH:,} capital, the worst temporary loss = Rs {abs(pf.max_drawdown()) * INIT_CASH:,.0f}")
print(f"* Rebalances: {switch_mask.sum()} times over the period")

# --- Plot ---
equity = pf.value()
cum_strat = equity / equity.iloc[0] - 1
cum_nifty = nifty_close / nifty_close.iloc[0] - 1
drawdown = equity / equity.cummax() - 1

fig = make_subplots(rows=2, cols=1, shared_xaxes=True,
                    row_heights=[0.65, 0.35], vertical_spacing=0.07)
fig.add_trace(go.Scatter(x=cum_strat.index, y=cum_strat * 100,
    name="Dual Momentum", line=dict(color="#00d4aa", width=2.5)), row=1, col=1)
fig.add_trace(go.Scatter(x=cum_nifty.index, y=cum_nifty * 100,
    name="NIFTY 50", line=dict(color="#ff6688", width=1.5, dash="dash")), row=1, col=1)
fig.add_trace(go.Scatter(x=drawdown.index, y=drawdown * 100,
    name="Drawdown", fill="tozeroy", line=dict(color="#ff4444", width=1)), row=2, col=1)

fig.update_yaxes(ticksuffix="%", side="right", row=1, col=1)
fig.update_yaxes(title_text="Drawdown %", ticksuffix="%", side="right", row=2, col=1)
fig.update_layout(template="plotly_dark",
    title="Dual Momentum vs NIFTY 50", height=700)
fig.show()

# --- Export ---
rebalance_log = pd.DataFrame({
    "date": alloc_daily.index[switch_mask],
    "buy_etf": alloc_daily[switch_mask].values,
})
rebalance_log.to_csv(script_dir / "dual_momentum_rebalance_log.csv", index=False)
pf.orders.records_readable.to_csv(script_dir / "dual_momentum_orders.csv", index=False)
print(f"\nExported rebalance log and orders to {script_dir}")

"""
EMA Crossover Backtest - VectorBT + OpenAlgo
Strategy: Buy when Fast EMA crosses above Slow EMA, sell on cross below.
Indicators: TA-Lib EMA exclusively.
Fees: Indian delivery equity model (0.111% + Rs 20/order).
Benchmark: NIFTY 50 Index via OpenAlgo (NSE_INDEX).
"""

import os
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd
import talib as tl
import vectorbt as vbt
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

# --- Config ---
script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"
FAST_EMA = 10
SLOW_EMA = 20
INIT_CASH = 1_000_000
FEES = 0.00111              # 0.111% per side (Indian delivery: STT + statutory)
FIXED_FEES = 20             # Rs 20 per order (entry and exit)
ALLOCATION = 0.75
BENCHMARK_SYMBOL = "NIFTY"
BENCHMARK_EXCHANGE = "NSE_INDEX"

# --- Fetch Data ---
client = api(
    api_key=os.getenv("OPENALGO_API_KEY"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365 * 3)

print(f"Fetching {SYMBOL} ({EXCHANGE}) {INTERVAL} data from {start_date} to {end_date}")

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)

if "timestamp" in df.columns:
    df["timestamp"] = pd.to_datetime(df["timestamp"])
    df = df.set_index("timestamp")
else:
    df.index = pd.to_datetime(df.index)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

close = df["close"]
print(f"Data loaded: {len(df)} bars from {df.index[0].date()} to {df.index[-1].date()}")

# --- Strategy: EMA Crossover (TA-Lib) ---
ema_fast = pd.Series(tl.EMA(close.values, timeperiod=FAST_EMA), index=close.index)
ema_slow = pd.Series(tl.EMA(close.values, timeperiod=SLOW_EMA), index=close.index)

buy_raw = (ema_fast > ema_slow) & (ema_fast.shift(1) <= ema_slow.shift(1))
sell_raw = (ema_fast < ema_slow) & (ema_fast.shift(1) >= ema_slow.shift(1))

entries = ta.exrem(buy_raw.fillna(False), sell_raw.fillna(False))
exits = ta.exrem(sell_raw.fillna(False), buy_raw.fillna(False))

print(f"Signals - Entries: {entries.sum()}, Exits: {exits.sum()}")

# --- Backtest ---
pf = vbt.Portfolio.from_signals(
    close, entries, exits,
    init_cash=INIT_CASH,
    size=ALLOCATION,
    size_type="percent",
    fees=FEES,
    fixed_fees=FIXED_FEES,
    direction="longonly",
    min_size=1,
    size_granularity=1,
    freq="1D",
)

# --- Benchmark: NIFTY 50 Index ---
print(f"\nFetching benchmark: {BENCHMARK_SYMBOL} ({BENCHMARK_EXCHANGE})")
df_bench = client.history(
    symbol=BENCHMARK_SYMBOL, exchange=BENCHMARK_EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
if "timestamp" in df_bench.columns:
    df_bench["timestamp"] = pd.to_datetime(df_bench["timestamp"])
    df_bench = df_bench.set_index("timestamp")
else:
    df_bench.index = pd.to_datetime(df_bench.index)
df_bench = df_bench.sort_index()
if df_bench.index.tz is not None:
    df_bench.index = df_bench.index.tz_convert(None)

bench_close = df_bench["close"].reindex(close.index).ffill().bfill()
pf_bench = vbt.Portfolio.from_holding(bench_close, init_cash=INIT_CASH, fees=FEES, freq="1D")

# --- Results ---
print("\n" + "=" * 60)
print(f"  EMA {FAST_EMA}/{SLOW_EMA} Crossover Backtest - {SYMBOL} ({EXCHANGE})")
print("=" * 60)
print(pf.stats())

# --- Strategy vs Benchmark Metrics ---
print("\n--- Strategy vs Benchmark ---")
comparison = pd.DataFrame({
    "Strategy": [
        f"{pf.total_return() * 100:.2f}%",
        f"{pf.sharpe_ratio():.2f}",
        f"{pf.sortino_ratio():.2f}",
        f"{pf.max_drawdown() * 100:.2f}%",
        f"{pf.trades.win_rate() * 100:.1f}%",
        f"{pf.trades.count()}",
        f"{pf.trades.profit_factor():.2f}",
    ],
    f"Benchmark ({BENCHMARK_SYMBOL})": [
        f"{pf_bench.total_return() * 100:.2f}%",
        f"{pf_bench.sharpe_ratio():.2f}",
        f"{pf_bench.sortino_ratio():.2f}",
        f"{pf_bench.max_drawdown() * 100:.2f}%",
        "-",
        "-",
        "-",
    ],
}, index=["Total Return", "Sharpe Ratio", "Sortino Ratio", "Max Drawdown",
          "Win Rate", "Total Trades", "Profit Factor"])
print(comparison.to_string())

# --- Explain Backtest Report ---
print("\n--- Backtest Report Explanation ---")
print(f"* Total Return: Strategy returned {pf.total_return() * 100:.2f}% vs "
      f"benchmark {pf_bench.total_return() * 100:.2f}%")
alpha = pf.total_return() - pf_bench.total_return()
print(f"  -> Alpha (excess return): {alpha * 100:.2f}%")
print(f"* Sharpe Ratio: {pf.sharpe_ratio():.2f} "
      f"({'Good' if pf.sharpe_ratio() > 1 else 'Below 1 - needs improvement'})")
print(f"  -> Measures risk-adjusted return. >1 acceptable, >2 excellent.")
print(f"* Sortino Ratio: {pf.sortino_ratio():.2f} "
      f"({'Good' if pf.sortino_ratio() > 1.5 else 'Moderate'})")
print(f"  -> Like Sharpe but only penalizes downside volatility.")
print(f"* Max Drawdown: {pf.max_drawdown() * 100:.2f}%")
print(f"  -> Worst peak-to-trough decline. Can you stomach this loss?")
print(f"* Win Rate: {pf.trades.win_rate() * 100:.1f}%")
print(f"  -> Percentage of winning trades. EMA crossover typically 35-45%.")
print(f"* Profit Factor: {pf.trades.profit_factor():.2f} "
      f"({'Good' if pf.trades.profit_factor() > 1.5 else 'Marginal' if pf.trades.profit_factor() > 1 else 'Unprofitable'})")
print(f"  -> Gross profit / gross loss. >1.5 is good, >2 is excellent.")
print(f"* Total Trades: {pf.trades.count()}")
print(f"  -> {'Sufficient for statistical significance' if pf.trades.count() >= 30 else 'Too few trades - results unreliable'}")

# --- Plot ---
fig = pf.plot(
    subplots=["value", "underwater", "cum_returns"],
    template="plotly_dark",
    title=f"EMA {FAST_EMA}/{SLOW_EMA} Crossover - {SYMBOL} ({EXCHANGE} {INTERVAL})",
)
fig.show()

# --- Export Trades ---
trades_file = script_dir / f"{SYMBOL}_ema_crossover_trades.csv"
pf.positions.records_readable.to_csv(trades_file, index=False)
print(f"\nTrades exported to {trades_file}")

"""
MACD Signal-Candle Breakout Backtest - VectorBT + OpenAlgo
Strategy: MACD zero-line defines bull/bear regimes. Entry on breakout of signal candle.
Indicators: TA-Lib MACD, openalgo.ta helpers.
Fees: Indian delivery equity model (0.111% + Rs 20/order).
Benchmark: NIFTY 50 Index via OpenAlgo (NSE_INDEX).
"""

import os
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd
import talib as tl
import vectorbt as vbt
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

# --- Config ---
script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"
MACD_FAST = 12
MACD_SLOW = 26
MACD_SIGNAL = 9
INIT_CASH = 1_000_000
FEES = 0.00111
FIXED_FEES = 20
ALLOCATION = 0.75
BENCHMARK_SYMBOL = "NIFTY"
BENCHMARK_EXCHANGE = "NSE_INDEX"

# --- Fetch Data ---
client = api(
    api_key=os.getenv("OPENALGO_API_KEY"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365 * 3)

print(f"Fetching {SYMBOL} ({EXCHANGE}) {INTERVAL} data from {start_date} to {end_date}")

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)

if "timestamp" in df.columns:
    df["timestamp"] = pd.to_datetime(df["timestamp"])
    df = df.set_index("timestamp")
else:
    df.index = pd.to_datetime(df.index)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

close = df["close"]
high = df["high"]
low = df["low"]
print(f"Data loaded: {len(df)} bars from {df.index[0].date()} to {df.index[-1].date()}")

# --- Strategy: MACD Signal-Candle Breakout (TA-Lib) ---
macd, macd_signal_line, macd_hist = tl.MACD(
    close.values, fastperiod=MACD_FAST, slowperiod=MACD_SLOW, signalperiod=MACD_SIGNAL
)
macd_series = pd.Series(macd, index=close.index)
zero = pd.Series(0.0, index=close.index)

# MACD zero-line flips define regimes
bull_flip = ta.crossover(macd_series, zero)
bear_flip = ta.crossunder(macd_series, zero)

bull_regime = ta.flip(bull_flip, bear_flip)
bear_regime = ta.flip(bear_flip, bull_flip)

# Signal candle levels (capture and carry forward)
sig_high = high.where(bull_flip).ffill()
sig_low = low.where(bear_flip).ffill()

# Entries: price breaks signal candle level during matching regime
long_entry_raw = (ta.crossover(high, sig_high) & bull_regime).fillna(False)

# Only first entry per regime; exit on bear regime flip
entries = ta.exrem(long_entry_raw, bear_flip.fillna(False))
exits = ta.exrem(bear_flip.fillna(False), long_entry_raw)

print(f"Signals - Entries: {entries.sum()}, Exits: {exits.sum()}")

# --- Backtest ---
pf = vbt.Portfolio.from_signals(
    close, entries, exits,
    init_cash=INIT_CASH,
    size=ALLOCATION,
    size_type="percent",
    fees=FEES,
    fixed_fees=FIXED_FEES,
    direction="longonly",
    min_size=1,
    size_granularity=1,
    freq="1D",
)

# --- Benchmark: NIFTY 50 ---
print(f"\nFetching benchmark: {BENCHMARK_SYMBOL} ({BENCHMARK_EXCHANGE})")
df_bench = client.history(
    symbol=BENCHMARK_SYMBOL, exchange=BENCHMARK_EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
if "timestamp" in df_bench.columns:
    df_bench["timestamp"] = pd.to_datetime(df_bench["timestamp"])
    df_bench = df_bench.set_index("timestamp")
else:
    df_bench.index = pd.to_datetime(df_bench.index)
df_bench = df_bench.sort_index()
if df_bench.index.tz is not None:
    df_bench.index = df_bench.index.tz_convert(None)

bench_close = df_bench["close"].reindex(close.index).ffill().bfill()
pf_bench = vbt.Portfolio.from_holding(bench_close, init_cash=INIT_CASH, fees=FEES, freq="1D")

# --- Results ---
print("\n" + "=" * 60)
print(f"  MACD Signal-Candle Breakout - {SYMBOL} ({EXCHANGE})")
print("=" * 60)
print(pf.stats())

# --- Strategy vs Benchmark Metrics ---
print("\n--- Strategy vs Benchmark ---")
comparison = pd.DataFrame({
    "Strategy": [
        f"{pf.total_return() * 100:.2f}%",
        f"{pf.sharpe_ratio():.2f}",
        f"{pf.sortino_ratio():.2f}",
        f"{pf.max_drawdown() * 100:.2f}%",
        f"{pf.trades.win_rate() * 100:.1f}%",
        f"{pf.trades.count()}",
        f"{pf.trades.profit_factor():.2f}",
    ],
    f"Benchmark ({BENCHMARK_SYMBOL})": [
        f"{pf_bench.total_return() * 100:.2f}%",
        f"{pf_bench.sharpe_ratio():.2f}",
        f"{pf_bench.sortino_ratio():.2f}",
        f"{pf_bench.max_drawdown() * 100:.2f}%",
        "-", "-", "-",
    ],
}, index=["Total Return", "Sharpe Ratio", "Sortino Ratio", "Max Drawdown",
          "Win Rate", "Total Trades", "Profit Factor"])
print(comparison.to_string())

# --- Explain Backtest Report ---
print("\n--- Backtest Report Explanation ---")
print(f"* Total Return: Your strategy made {pf.total_return() * 100:.2f}% "
      f"while NIFTY 50 made {pf_bench.total_return() * 100:.2f}%")
alpha = pf.total_return() - pf_bench.total_return()
if alpha > 0:
    print(f"  -> Your strategy BEAT the market by {alpha * 100:.2f}% (positive alpha)")
else:
    print(f"  -> Your strategy UNDERPERFORMED the market by {abs(alpha) * 100:.2f}%")
print(f"* Sharpe Ratio: {pf.sharpe_ratio():.2f}")
print(f"  -> This measures return per unit of risk. Think of it as 'bang for your buck'.")
print(f"     Below 1 = not enough return for the risk taken")
print(f"     1-2 = decent, 2+ = very good")
print(f"* Max Drawdown: {pf.max_drawdown() * 100:.2f}%")
print(f"  -> The biggest drop from peak. If you invested 10L, you would have temporarily")
print(f"     lost up to Rs {abs(pf.max_drawdown()) * INIT_CASH:,.0f} before recovering.")
print(f"* Win Rate: {pf.trades.win_rate() * 100:.1f}% of trades were profitable")
print(f"* Profit Factor: {pf.trades.profit_factor():.2f}")
print(f"  -> For every Rs 1 lost, you made Rs {pf.trades.profit_factor():.2f} in profits.")

# --- Plot ---
fig = pf.plot(
    subplots=["value", "underwater", "cum_returns"],
    template="plotly_dark",
    title=f"MACD Signal-Candle Breakout - {SYMBOL} ({EXCHANGE} {INTERVAL})",
)
fig.show()

# --- Export ---
trades_file = script_dir / f"{SYMBOL}_macd_trades.csv"
pf.positions.records_readable.to_csv(trades_file, index=False)
print(f"\nTrades exported to {trades_file}")

"""
Double Momentum Backtest - VectorBT + OpenAlgo
Strategy: MOM + MOM-of-MOM for directional confirmation with next-bar fill.
Indicators: TA-Lib MOM.
Fees: Indian delivery equity model (0.111% + Rs 20/order).
Benchmark: NIFTY 50 Index via OpenAlgo (NSE_INDEX).
"""

import os
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd
import talib as tl
import vectorbt as vbt
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

# --- Config ---
script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"
MOM_LENGTH = 12
INIT_CASH = 1_000_000
FEES = 0.00111
FIXED_FEES = 20
ALLOCATION = 0.75
BENCHMARK_SYMBOL = "NIFTY"
BENCHMARK_EXCHANGE = "NSE_INDEX"

# --- Fetch Data ---
client = api(
    api_key=os.getenv("OPENALGO_API_KEY"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365 * 3)

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)

if "timestamp" in df.columns:
    df["timestamp"] = pd.to_datetime(df["timestamp"])
    df = df.set_index("timestamp")
else:
    df.index = pd.to_datetime(df.index)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

close = df["close"]
high = df["high"]
low = df["low"]

# --- Strategy: Double Momentum (TA-Lib) ---
mom0 = pd.Series(tl.MOM(close.values, timeperiod=MOM_LENGTH), index=close.index)
mom1 = pd.Series(tl.MOM(mom0.values, timeperiod=1), index=close.index)

cond_long = (mom0 > 0) & (mom1 > 0)

# Next-bar fill with previous bar's high breakout
prev_high = high.shift(1)
MINTICK = 0.05

entries_raw = (cond_long.shift(1) & (high >= (prev_high + MINTICK))).fillna(False)

# Exit on opposite condition
cond_short = (mom0 < 0) & (mom1 < 0)
exits_raw = (cond_short.shift(1) & (low <= (low.shift(1) - MINTICK))).fillna(False)

entries = ta.exrem(entries_raw, exits_raw)
exits = ta.exrem(exits_raw, entries)

# --- Backtest ---
pf = vbt.Portfolio.from_signals(
    close, entries, exits,
    init_cash=INIT_CASH, size=ALLOCATION, size_type="percent",
    fees=FEES, fixed_fees=FIXED_FEES, direction="longonly",
    min_size=1, size_granularity=1, freq="1D",
)

# --- Benchmark ---
df_bench = client.history(
    symbol=BENCHMARK_SYMBOL, exchange=BENCHMARK_EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
if "timestamp" in df_bench.columns:
    df_bench["timestamp"] = pd.to_datetime(df_bench["timestamp"])
    df_bench = df_bench.set_index("timestamp")
else:
    df_bench.index = pd.to_datetime(df_bench.index)
df_bench = df_bench.sort_index()
if df_bench.index.tz is not None:
    df_bench.index = df_bench.index.tz_convert(None)
bench_close = df_bench["close"].reindex(close.index).ffill().bfill()
pf_bench = vbt.Portfolio.from_holding(bench_close, init_cash=INIT_CASH, fees=FEES, freq="1D")

# --- Results ---
print("\n" + "=" * 60)
print(f"  Double Momentum(MOM{MOM_LENGTH}) - {SYMBOL} ({EXCHANGE})")
print("=" * 60)
print(pf.stats())

print("\n--- Strategy vs Benchmark ---")
comparison = pd.DataFrame({
    "Strategy": [
        f"{pf.total_return() * 100:.2f}%", f"{pf.sharpe_ratio():.2f}",
        f"{pf.sortino_ratio():.2f}", f"{pf.max_drawdown() * 100:.2f}%",
        f"{pf.trades.win_rate() * 100:.1f}%", f"{pf.trades.count()}",
        f"{pf.trades.profit_factor():.2f}",
    ],
    f"Benchmark ({BENCHMARK_SYMBOL})": [
        f"{pf_bench.total_return() * 100:.2f}%", f"{pf_bench.sharpe_ratio():.2f}",
        f"{pf_bench.sortino_ratio():.2f}", f"{pf_bench.max_drawdown() * 100:.2f}%",
        "-", "-", "-",
    ],
}, index=["Total Return", "Sharpe Ratio", "Sortino Ratio", "Max Drawdown",
          "Win Rate", "Total Trades", "Profit Factor"])
print(comparison.to_string())

print("\n--- Backtest Report Explanation ---")
print(f"* Total Return: Your strategy made {pf.total_return() * 100:.2f}% "
      f"while NIFTY 50 made {pf_bench.total_return() * 100:.2f}%")
alpha = pf.total_return() - pf_bench.total_return()
if alpha > 0:
    print(f"  -> BEAT the market by {alpha * 100:.2f}%")
else:
    print(f"  -> UNDERPERFORMED the market by {abs(alpha) * 100:.2f}%")
print(f"* Sharpe Ratio: {pf.sharpe_ratio():.2f} (return per unit of risk, >1 decent, >2 excellent)")
print(f"* Max Drawdown: {pf.max_drawdown() * 100:.2f}%")
print(f"  -> If you invested Rs {INIT_CASH:,}, the biggest temporary loss = Rs {abs(pf.max_drawdown()) * INIT_CASH:,.0f}")
print(f"* Win Rate: {pf.trades.win_rate() * 100:.1f}%")
print(f"* Profit Factor: {pf.trades.profit_factor():.2f} - for every Rs 1 lost, you made Rs {pf.trades.profit_factor():.2f}")

fig = pf.plot(
    subplots=["value", "underwater", "cum_returns"],
    template="plotly_dark",
    title=f"Double Momentum(MOM{MOM_LENGTH}) - {SYMBOL} ({EXCHANGE} {INTERVAL})",
)
fig.show()

trades_file = script_dir / f"{SYMBOL}_momentum_trades.csv"
pf.positions.records_readable.to_csv(trades_file, index=False)
print(f"\nTrades exported to {trades_file}")

"""
Realistic Transaction Cost Analysis Template - VectorBT + OpenAlgo
Compares strategy performance across different cost models:
  1. Zero fees (unrealistic upper bound)
  2. Simplified flat fee
  3. Indian delivery equity (realistic)
  4. Indian intraday equity
  5. Indian F&O futures
Shows the real impact of transaction costs on strategy profitability.
Indicators: TA-Lib exclusively.
Benchmark: NIFTY 50 Index via OpenAlgo (NSE_INDEX).
"""

import os
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import pandas as pd
import talib as tl
import vectorbt as vbt
import plotly.graph_objects as go
from dotenv import find_dotenv, load_dotenv
from openalgo import api, ta

# --- Config ---
script_dir = Path(__file__).resolve().parent
load_dotenv(find_dotenv(), override=False)

SYMBOL = "SBIN"
EXCHANGE = "NSE"
INTERVAL = "D"
FAST_EMA = 10
SLOW_EMA = 20
INIT_CASH = 1_000_000
ALLOCATION = 0.75
BENCHMARK_SYMBOL = "NIFTY"
BENCHMARK_EXCHANGE = "NSE_INDEX"

# --- Indian Market Fee Models ---
FEE_MODELS = {
    "Zero Fees (Unrealistic)": {
        "fees": 0, "fixed_fees": 0, "slippage": 0,
    },
    "Simplified 0.1%": {
        "fees": 0.001, "fixed_fees": 0, "slippage": 0,
    },
    "Delivery Equity": {
        "fees": 0.00111,       # 0.111% (STT 0.1% both + statutory)
        "fixed_fees": 20,      # Rs 20 per order
        "slippage": 0.0005,    # 0.05% slippage
    },
    "Intraday Equity": {
        "fees": 0.000225,      # 0.0225% (STT 0.025% sell + statutory)
        "fixed_fees": 20,      # Rs 20 per order
        "slippage": 0.0005,
    },
    "F&O Futures": {
        "fees": 0.00018,       # 0.018% (STT 0.02% sell + statutory)
        "fixed_fees": 20,
        "slippage": 0.0002,    # Lower slippage for liquid futures
    },
}

# --- Fetch Data ---
client = api(
    api_key=os.getenv("OPENALGO_API_KEY"),
    host=os.getenv("OPENALGO_HOST", "http://127.0.0.1:5000"),
)

end_date = datetime.now().date()
start_date = end_date - timedelta(days=365 * 3)

df = client.history(
    symbol=SYMBOL, exchange=EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)

if "timestamp" in df.columns:
    df["timestamp"] = pd.to_datetime(df["timestamp"])
    df = df.set_index("timestamp")
else:
    df.index = pd.to_datetime(df.index)
df = df.sort_index()
if df.index.tz is not None:
    df.index = df.index.tz_convert(None)

close = df["close"]

# --- Generate Signals (TA-Lib EMA) ---
ema_fast = pd.Series(tl.EMA(close.values, timeperiod=FAST_EMA), index=close.index)
ema_slow = pd.Series(tl.EMA(close.values, timeperiod=SLOW_EMA), index=close.index)

buy_raw = (ema_fast > ema_slow) & (ema_fast.shift(1) <= ema_slow.shift(1))
sell_raw = (ema_fast < ema_slow) & (ema_fast.shift(1) >= ema_slow.shift(1))

entries = ta.exrem(buy_raw.fillna(False), sell_raw.fillna(False))
exits = ta.exrem(sell_raw.fillna(False), buy_raw.fillna(False))

# --- Benchmark ---
df_bench = client.history(
    symbol=BENCHMARK_SYMBOL, exchange=BENCHMARK_EXCHANGE, interval=INTERVAL,
    start_date=start_date.strftime("%Y-%m-%d"),
    end_date=end_date.strftime("%Y-%m-%d"),
)
if "timestamp" in df_bench.columns:
    df_bench["timestamp"] = pd.to_datetime(df_bench["timestamp"])
    df_bench = df_bench.set_index("timestamp")
else:
    df_bench.index = pd.to_datetime(df_bench.index)
df_bench = df_bench.sort_index()
if df_bench.index.tz is not None:
    df_bench.index = df_bench.index.tz_convert(None)
bench_close = df_bench["close"].reindex(close.index).ffill().bfill()

# --- Run Backtest for Each Fee Model ---
results = {}
portfolios = {}

for model_name, params in FEE_MODELS.items():
    pf = vbt.Portfolio.from_signals(
        close, entries, exits,
        init_cash=INIT_CASH,
        size=ALLOCATION,
        size_type="percent",
        fees=params["fees"],
        fixed_fees=params["fixed_fees"],
        slippage=params.get("slippage", 0),
        direction="longonly",
        min_size=1,
        size_granularity=1,
        freq="1D",
    )
    portfolios[model_name] = pf
    results[model_name] = {
        "Total Return": f"{pf.total_return() * 100:.2f}%",
        "Sharpe Ratio": f"{pf.sharpe_ratio():.2f}",
        "Max Drawdown": f"{pf.max_drawdown() * 100:.2f}%",
        "Win Rate": f"{pf.trades.win_rate() * 100:.1f}%",
        "Total Trades": str(pf.trades.count()),
        "Profit Factor": f"{pf.trades.profit_factor():.2f}",
        "Total Fees Paid": f"Rs {pf.orders.records['fees'].sum():,.0f}",
    }

# Add benchmark
pf_bench = vbt.Portfolio.from_holding(bench_close, init_cash=INIT_CASH, freq="1D")
results[f"Benchmark ({BENCHMARK_SYMBOL})"] = {
    "Total Return": f"{pf_bench.total_return() * 100:.2f}%",
    "Sharpe Ratio": f"{pf_bench.sharpe_ratio():.2f}",
    "Max Drawdown": f"{pf_bench.max_drawdown() * 100:.2f}%",
    "Win Rate": "-",
    "Total Trades": "-",
    "Profit Factor": "-",
    "Total Fees Paid": "-",
}

# --- Print Results ---
print("\n" + "=" * 80)
print(f"  Transaction Cost Impact Analysis - EMA {FAST_EMA}/{SLOW_EMA} on {SYMBOL}")
print("=" * 80)
results_df = pd.DataFrame(results)
print(results_df.to_string())

# --- Explain for Traders ---
zero_return = portfolios["Zero Fees (Unrealistic)"].total_return()
delivery_return = portfolios["Delivery Equity"].total_return()
cost_drag = zero_return - delivery_return

print("\n--- What This Means for You ---")
print(f"* With zero fees, this strategy returns {zero_return * 100:.2f}%")
print(f"* With realistic delivery fees, it returns {delivery_return * 100:.2f}%")
print(f"* Transaction costs eat {cost_drag * 100:.2f}% of your returns")
print(f"  -> That is Rs {cost_drag * INIT_CASH:,.0f} lost to fees on Rs {INIT_CASH:,} capital")

if delivery_return > 0:
    print(f"\n* Strategy is STILL PROFITABLE after realistic costs")
else:
    print(f"\n* Strategy becomes UNPROFITABLE with realistic costs!")
    print(f"  -> The edge is not large enough to overcome transaction costs")
    print(f"  -> Consider: fewer trades, higher timeframe, or a different strategy")

# --- Plot: Equity Curves for All Fee Models ---
fig = go.Figure()
for model_name, pf in portfolios.items():
    equity = pf.value()
    cum_ret = equity / equity.iloc[0] - 1
    fig.add_trace(go.Scatter(
        x=cum_ret.index, y=cum_ret * 100,
        name=model_name, mode='lines',
    ))

# Add benchmark
bench_cum = bench_close / bench_close.iloc[0] - 1
fig.add_trace(go.Scatter(
    x=bench_cum.index, y=bench_cum * 100,
    name=f"Benchmark ({BENCHMARK_SYMBOL})", mode='lines',
    line=dict(dash='dash', color='gray'),
))

fig.update_layout(
    template="plotly_dark",
    title=f"Impact of Transaction Costs - EMA {FAST_EMA}/{SLOW_EMA} on {SYMBOL}",
    xaxis_title="Date",
    yaxis_title="Cumulative Return (%)",
    yaxis=dict(ticksuffix="%"),
    height=600,
    legend=dict(x=0.01, y=0.99),
)
fig.update_yaxes(side="right")
fig.show()

# --- Export ---
export_file = script_dir / f"{SYMBOL}_cost_analysis.csv"
results_df.to_csv(export_file)
print(f"\nResults exported to {export_file}")