"""Bollinger Band mean-reversion strategy backtest.

Logic:
  - Price touches upper BB → close any long, open short
  - Price touches lower BB → close any short, open long
  - Always in position (flip between long and short)

Uses 5-minute OHLC data from the database.
"""
from __future__ import annotations

from dataclasses import dataclass
from datetime import datetime, timezone
from typing import List, Optional

import numpy as np
import pandas as pd

from .data_loader import KlineSource, load_klines
from .indicators import bollinger


# ---------------------------------------------------------------------------
# Config & result types
# ---------------------------------------------------------------------------

@dataclass
class BBConfig:
    # Bollinger Band parameters
    bb_period: int = 20          # SMA window
    bb_std: float = 2.0          # standard deviation multiplier

    # Position sizing
    margin_per_trade: float = 80.0
    leverage: float = 100.0
    initial_capital: float = 1000.0

    # Risk management
    max_daily_loss: float = 150.0   # stop trading after this daily loss
    stop_loss_pct: float = 0.0      # 0 = disabled; e.g. 0.02 = 2% SL from entry

    # Dynamic sizing: if > 0, margin = equity * margin_pct (overrides margin_per_trade)
    margin_pct: float = 0.0          # e.g. 0.01 = 1% of equity per trade

    # Fee structure (taker)
    fee_rate: float = 0.0006        # 0.06%
    rebate_rate: float = 0.0         # instant maker rebate (if any)

    # Delayed rebate: rebate_pct of daily fees returned next day at rebate_hour UTC
    rebate_pct: float = 0.0          # e.g. 0.70 = 70% rebate
    rebate_hour_utc: int = 0         # hour in UTC when rebate arrives (0 = 8am UTC+8)


@dataclass
class BBTrade:
    side: str               # "long" or "short"
    entry_price: float
    exit_price: float
    entry_time: object      # pd.Timestamp
    exit_time: object
    margin: float
    leverage: float
    qty: float
    gross_pnl: float
    fee: float
    net_pnl: float


@dataclass
class BBResult:
    equity_curve: pd.DataFrame   # columns: equity, balance, price, position
    trades: List[BBTrade]
    daily_stats: pd.DataFrame    # daily equity + pnl
    total_fee: float
    total_rebate: float
    config: BBConfig


# ---------------------------------------------------------------------------
# Backtest engine
# ---------------------------------------------------------------------------

def run_bb_backtest(df: pd.DataFrame, cfg: BBConfig) -> BBResult:
    """Run Bollinger Band mean-reversion backtest on 5m OHLC data."""

    close = df["close"].astype(float)
    high = df["high"].astype(float)
    low = df["low"].astype(float)
    n = len(df)

    # Compute Bollinger Bands
    bb_mid, bb_upper, bb_lower, bb_width = bollinger(close, cfg.bb_period, cfg.bb_std)

    # Convert to numpy for speed
    arr_close = close.values
    arr_high = high.values
    arr_low = low.values
    arr_upper = bb_upper.values
    arr_lower = bb_lower.values
    ts_index = df.index

    # State
    balance = cfg.initial_capital
    position = 0         # +1 = long, -1 = short, 0 = flat
    entry_price = 0.0
    entry_time = None
    entry_margin = 0.0
    entry_qty = 0.0

    trades: List[BBTrade] = []
    total_fee = 0.0
    total_rebate = 0.0

    # Daily tracking
    day_pnl = 0.0
    day_stopped = False
    current_day = None

    # Delayed rebate tracking
    pending_rebate = 0.0       # fees from previous day to be rebated
    today_fees = 0.0           # fees accumulated today
    rebate_applied_today = False

    # Output arrays
    out_equity = np.full(n, np.nan)
    out_balance = np.full(n, np.nan)
    out_position = np.zeros(n)

    def unrealised(price):
        if position == 0:
            return 0.0
        if position == 1:
            return entry_qty * (price - entry_price)
        else:
            return entry_qty * (entry_price - price)

    def close_position(exit_price, exit_idx):
        nonlocal balance, position, entry_price, entry_time, entry_margin, entry_qty
        nonlocal total_fee, total_rebate, day_pnl, today_fees

        if position == 0:
            return

        if position == 1:
            gross = entry_qty * (exit_price - entry_price)
        else:
            gross = entry_qty * (entry_price - exit_price)

        exit_notional = entry_qty * exit_price
        fee = exit_notional * cfg.fee_rate
        rebate = exit_notional * cfg.rebate_rate  # instant rebate only
        net = gross - fee + rebate

        trades.append(BBTrade(
            side="long" if position == 1 else "short",
            entry_price=entry_price,
            exit_price=exit_price,
            entry_time=entry_time,
            exit_time=ts_index[exit_idx],
            margin=entry_margin,
            leverage=cfg.leverage,
            qty=entry_qty,
            gross_pnl=gross,
            fee=fee,
            net_pnl=net,
        ))

        balance += net
        total_fee += fee
        total_rebate += rebate
        today_fees += fee
        day_pnl += net
        position = 0
        entry_price = 0.0
        entry_time = None
        entry_margin = 0.0
        entry_qty = 0.0

    def open_position(side, price, idx):
        nonlocal position, entry_price, entry_time, entry_margin, entry_qty
        nonlocal balance, total_fee, day_pnl, today_fees

        if cfg.margin_pct > 0:
            equity = balance + unrealised(price) if position != 0 else balance
            margin = equity * cfg.margin_pct
        else:
            margin = cfg.margin_per_trade
        margin = min(margin, balance * 0.95)
        if margin <= 0:
            return
        notional = margin * cfg.leverage
        qty = notional / price
        fee = notional * cfg.fee_rate

        balance -= fee
        total_fee += fee
        today_fees += fee
        day_pnl -= fee

        position = 1 if side == "long" else -1
        entry_price = price
        entry_time = ts_index[idx]
        entry_margin = margin
        entry_qty = qty

    # Main loop
    for i in range(n):
        # Daily reset + delayed rebate
        bar_day = ts_index[i].date() if hasattr(ts_index[i], 'date') else None
        bar_hour = ts_index[i].hour if hasattr(ts_index[i], 'hour') else 0
        if bar_day is not None and bar_day != current_day:
            # New day: move today's fees to pending, reset
            if cfg.rebate_pct > 0:
                pending_rebate = today_fees * cfg.rebate_pct
                today_fees = 0.0
            rebate_applied_today = False
            day_pnl = 0.0
            day_stopped = False
            current_day = bar_day

        # Apply delayed rebate at specified hour
        if cfg.rebate_pct > 0 and not rebate_applied_today and bar_hour >= cfg.rebate_hour_utc and pending_rebate > 0:
            balance += pending_rebate
            total_rebate += pending_rebate
            pending_rebate = 0.0
            rebate_applied_today = True

        # Skip if BB not ready
        if np.isnan(arr_upper[i]) or np.isnan(arr_lower[i]):
            out_equity[i] = balance + unrealised(arr_close[i])
            out_balance[i] = balance
            out_position[i] = position
            continue

        # Daily loss check
        if day_stopped:
            out_equity[i] = balance + unrealised(arr_close[i])
            out_balance[i] = balance
            out_position[i] = position
            continue

        cur_equity = balance + unrealised(arr_close[i])
        if day_pnl + unrealised(arr_close[i]) <= -cfg.max_daily_loss:
            close_position(arr_close[i], i)
            day_stopped = True
            out_equity[i] = balance
            out_balance[i] = balance
            out_position[i] = 0
            continue

        # Stop loss check
        if position != 0 and cfg.stop_loss_pct > 0:
            if position == 1 and arr_low[i] <= entry_price * (1 - cfg.stop_loss_pct):
                sl_price = entry_price * (1 - cfg.stop_loss_pct)
                close_position(sl_price, i)
            elif position == -1 and arr_high[i] >= entry_price * (1 + cfg.stop_loss_pct):
                sl_price = entry_price * (1 + cfg.stop_loss_pct)
                close_position(sl_price, i)

        # Signal detection: use high/low to check if price touched BB
        touched_upper = arr_high[i] >= arr_upper[i]
        touched_lower = arr_low[i] <= arr_lower[i]

        if touched_upper and touched_lower:
            # Both touched in same bar (wide bar) — skip, too volatile
            pass
        elif touched_upper:
            # Price touched upper BB → go short
            if position == 1:
                # Close long at upper BB price
                close_position(arr_upper[i], i)
            if position != -1:
                # Open short
                open_position("short", arr_upper[i], i)
        elif touched_lower:
            # Price touched lower BB → go long
            if position == -1:
                # Close short at lower BB price
                close_position(arr_lower[i], i)
            if position != 1:
                # Open long
                open_position("long", arr_lower[i], i)

        # Record equity
        out_equity[i] = balance + unrealised(arr_close[i])
        out_balance[i] = balance
        out_position[i] = position

    # Force close at end
    if position != 0:
        close_position(arr_close[n - 1], n - 1)
        out_equity[n - 1] = balance
        out_balance[n - 1] = balance
        out_position[n - 1] = 0

    # Build equity DataFrame
    eq_df = pd.DataFrame({
        "equity": out_equity,
        "balance": out_balance,
        "price": arr_close,
        "position": out_position,
    }, index=ts_index)

    # Daily stats
    daily_eq = eq_df["equity"].resample("1D").last().dropna().to_frame("equity")
    daily_eq["pnl"] = daily_eq["equity"].diff().fillna(0.0)

    return BBResult(
        equity_curve=eq_df,
        trades=trades,
        daily_stats=daily_eq,
        total_fee=total_fee,
        total_rebate=total_rebate,
        config=cfg,
    )