import pandas as pd
from pathlib import Path
import sys

BASE_PATH = Path(__file__).resolve().parents[2]
SRC_PATH = BASE_PATH / "src"

if str(SRC_PATH) not in sys.path:
    sys.path.append(str(SRC_PATH))

from features.spot_lag_v3 import get_model_ready_spot_lag_v3


def build_trades(
    threshold: float = 2.0,
    stop: float = 0.0025,
    horizon: int = 24,
    spread_cost: float = 0.0001,
):
    df = get_model_ready_spot_lag_v3().copy()

    df["future_close"] = df["close"].shift(-horizon)
    df["future_min"] = df["close"].rolling(horizon).min().shift(-horizon)
    df["future_max"] = df["close"].rolling(horizon).max().shift(-horizon)

    df = df.dropna(
        subset=[
            "future_close",
            "future_min",
            "future_max",
            "lag_zscore_24h_v3",
        ]
    ).copy()

    trades = []
    prev_signal = 0

    for _, row in df.iterrows():
        signal = 0
        if row["lag_zscore_24h_v3"] >= threshold:
            signal = 1
        elif row["lag_zscore_24h_v3"] <= -threshold:
            signal = -1

        if signal != 0 and signal != prev_signal:
            entry = row["close"]

            if signal == 1:
                stop_hit = (row["future_min"] - entry) / entry < -stop
                ret = row["future_close"] / entry - 1
                if stop_hit:
                    ret = -stop
            else:
                stop_hit = (row["future_max"] - entry) / entry > stop
                ret = -(row["future_close"] / entry - 1)
                if stop_hit:
                    ret = -stop

            ret -= spread_cost

            trades.append(
                {
                    "entry_time": row["datetime"],
                    "signal": signal,
                    "return": ret,
                }
            )

        prev_signal = signal

    trades = pd.DataFrame(trades)
    return trades


def analyze_equity_curve(trades: pd.DataFrame):
    if trades.empty:
        print("No trades found.")
        return

    trades = trades.copy()
    trades["equity_curve"] = (1 + trades["return"]).cumprod()
    trades["running_peak"] = trades["equity_curve"].cummax()
    trades["drawdown"] = trades["equity_curve"] / trades["running_peak"] - 1

    max_dd = trades["drawdown"].min()

    wins = (trades["return"] > 0).sum()
    losses = (trades["return"] <= 0).sum()
    win_rate = wins / len(trades)

    avg_return = trades["return"].mean()
    std_return = trades["return"].std()
    sharpe_proxy = avg_return / std_return if std_return != 0 else 0

    # Losing streak
    max_losing_streak = 0
    current_streak = 0
    for r in trades["return"]:
        if r <= 0:
            current_streak += 1
            max_losing_streak = max(max_losing_streak, current_streak)
        else:
            current_streak = 0

    # Daily aggregation for FTMO-style daily DD proxy
    trades["entry_date"] = pd.to_datetime(trades["entry_time"]).dt.date
    daily_returns = trades.groupby("entry_date")["return"].sum()

    worst_day = daily_returns.min()
    best_day = daily_returns.max()

    print("\n=== EQUITY CURVE ANALYSIS ===")
    print("Trades:", len(trades))
    print("Win rate:", round(win_rate, 4))
    print("Average trade return:", round(avg_return, 6))
    print("Std dev of trade returns:", round(std_return, 6))
    print("Sharpe proxy (trade-level):", round(sharpe_proxy, 4))
    print("Final equity multiple:", round(trades['equity_curve'].iloc[-1], 4))
    print("Max drawdown:", round(max_dd, 4))
    print("Max losing streak:", max_losing_streak)
    print("Worst day:", round(worst_day, 4))
    print("Best day:", round(best_day, 4))

    print("\nLAST 10 TRADES:")
    print(trades[["entry_time", "signal", "return", "equity_curve", "drawdown"]].tail(10))


if __name__ == "__main__":
    trades = build_trades(
        threshold=2.0,
        stop=0.0025,
        horizon=24,
        spread_cost=0.0001,
    )
    analyze_equity_curve(trades)