"""
Structure Flow Strategy v2.0
=======================
变更记录：
  v1.6 (2026-06-07): 最优基线 — +3659.63%, 190笔, 69.3% trailing胜率
  v2.0 (2026-06-08): ===== B1: 入场延迟一根1H bar确认 =====
                      信号触发后，不立即入场，等下一根1H bar收盘。
                      如果收盘价仍在S/R附近（支撑上方1.5%以内 / 阻力下方1.5%以内），
                      确认入场；否则放弃本次信号。
                      目的：过滤假突破，减少被噪音震出的止损交易。
"""

from datetime import datetime
import numpy as np
import pandas as pd
from pandas import DataFrame
from freqtrade.strategy import IStrategy, IntParameter, informative
from freqtrade.persistence import Trade


class StructureFlowStrategyV20(IStrategy):
    """
    Structure Flow Strategy v2.0 — B1: 入场延迟确认

    v2.0改动（相对于v1.6）：
      1. 入场延迟1根bar：信号触发后，等下一根bar收盘确认
      2. 确认条件：收盘价仍在S/R附近（做多在support上方1.5%内，做空在resistance下方1.5%内）
      3. 保留v1.6所有逻辑：冷却期、活支撑/阻力、D1趋势过滤
    """

    can_short = True
    stoploss = -0.15
    use_custom_stoploss = True
    minimal_roi = {"0": 100}
    max_open_trades = 1
    timeframe = "1h"

    # =====================
    # 可优化参数
    # =====================

    swing_lookback_d1 = IntParameter(8, 14, default=10, space="buy")
    swing_lookback_h4 = IntParameter(5, 10, default=8, space="buy")
    pin_bar_wick_ratio = IntParameter(50, 70, default=60, space="buy")
    max_stop_dist = IntParameter(20, 50, default=50, space="buy")
    cooldown_bars = IntParameter(3, 12, default=6, space="buy")
    # v2.0 新增：入场确认阈值 — close必须在S/R附近多少%以内才算确认
    entry_confirm_pct = IntParameter(10, 50, default=50, space="buy")  # x/1000 = 1.0%~5.0%, default 5.0%

    # =====================
    # 工具：Swing Point 检测
    # =====================

    @staticmethod
    def _detect_swing_points(
        high: pd.Series,
        low: pd.Series,
        window: int = 5,
    ) -> tuple[pd.Series, pd.Series]:
        n = len(high)
        sh = pd.Series(np.nan, index=high.index, dtype=float)
        sl = pd.Series(np.nan, index=low.index, dtype=float)

        for i in range(window, n - window):
            if high.iloc[i] > high.iloc[i - window : i].max() and high.iloc[i] > high.iloc[i + 1 : i + window + 1].max():
                sh.iloc[i] = high.iloc[i]
            if low.iloc[i] < low.iloc[i - window : i].min() and low.iloc[i] < low.iloc[i + 1 : i + window + 1].min():
                sl.iloc[i] = low.iloc[i]

        return sh, sl

    # =====================
    # 工具：结构分析
    # =====================

    def _build_structure(
        self,
        high: pd.Series,
        low: pd.Series,
        close: pd.Series,
        swing_high: pd.Series,
        swing_low: pd.Series,
    ) -> DataFrame:
        n = len(high)

        trend_up_arr = np.full(n, False)
        trend_down_arr = np.full(n, False)
        nearest_support = np.full(n, np.nan)
        nearest_resistance = np.full(n, np.nan)
        in_demand_zone = np.full(n, False)
        in_supply_zone = np.full(n, False)

        sh_prices = []
        sl_prices = []

        for i in range(n):
            if pd.notna(swing_high.iloc[i]):
                sh_prices.append(swing_high.iloc[i])
                if len(sh_prices) > 4:
                    sh_prices.pop(0)

            if pd.notna(swing_low.iloc[i]):
                sl_prices.append(swing_low.iloc[i])
                if len(sl_prices) > 4:
                    sl_prices.pop(0)

            if len(sh_prices) >= 2 and len(sl_prices) >= 2:
                if sh_prices[-1] > sh_prices[-2] and sl_prices[-1] > sl_prices[-2]:
                    trend_up_arr[i] = True
                elif sh_prices[-1] < sh_prices[-2] and sl_prices[-1] < sl_prices[-2]:
                    trend_down_arr[i] = True
                elif i > 0:
                    trend_up_arr[i] = trend_up_arr[i - 1]
                    trend_down_arr[i] = trend_down_arr[i - 1]
            elif i > 0:
                trend_up_arr[i] = trend_up_arr[i - 1]
                trend_down_arr[i] = trend_down_arr[i - 1]

            if sl_prices:
                nearest_support[i] = sl_prices[-1]
            if sh_prices:
                nearest_resistance[i] = sh_prices[-1]

            c = close.iloc[i]
            if not np.isnan(nearest_support[i]) and not np.isnan(nearest_resistance[i]):
                zone_range = nearest_resistance[i] - nearest_support[i]
                if zone_range > 0:
                    pos_pct = (c - nearest_support[i]) / zone_range
                    in_demand_zone[i] = pos_pct < 0.35
                    in_supply_zone[i] = pos_pct > 0.65

        return DataFrame({
            "trend_up": trend_up_arr,
            "trend_down": trend_down_arr,
            "support": nearest_support,
            "resistance": nearest_resistance,
            "in_demand": in_demand_zone,
            "in_supply": in_supply_zone,
        }, index=high.index)

    # =====================
    # 工具：K线形态检测
    # =====================

    @staticmethod
    def _detect_candle_patterns(
        open_: pd.Series,
        high: pd.Series,
        low: pd.Series,
        close: pd.Series,
        pin_bar_wick_ratio: float = 0.6,
    ) -> tuple[pd.Series, pd.Series, pd.Series, pd.Series]:
        body = (close - open_).abs()
        total_range = (high - low).replace(0, 0.0001)

        upper_wick = high - close.where(close > open_, open_)
        lower_wick = open_.where(close > open_, close) - low
        is_pin = (upper_wick + lower_wick) / total_range > pin_bar_wick_ratio

        bullish_pin = is_pin & (close > open_) & (lower_wick > upper_wick)
        bearish_pin = is_pin & (close < open_) & (upper_wick > lower_wick)

        prev_open = open_.shift(1)
        prev_close = close.shift(1)
        bullish_engulf = (close > prev_open) & (open_ < prev_close) & (close > open_)
        bearish_engulf = (close < prev_open) & (open_ > prev_close) & (close < open_)

        return bullish_pin, bearish_pin, bullish_engulf, bearish_engulf

    # ================================================================
    #  信息时间框架 — D1 宏观结构
    # ================================================================

    @informative("1d")
    def populate_indicators_1d(
        self, dataframe: DataFrame, metadata: dict
    ) -> DataFrame:
        sh, sl = self._detect_swing_points(
            dataframe["high"], dataframe["low"],
            self.swing_lookback_d1.value,
        )
        structure = self._build_structure(
            dataframe["high"], dataframe["low"], dataframe["close"],
            sh, sl,
        )
        dataframe["trend_up"] = structure["trend_up"]
        dataframe["trend_down"] = structure["trend_down"]
        return dataframe

    # ================================================================
    #  信息时间框架 — 4H 中期结构
    # ================================================================

    @informative("4h")
    def populate_indicators_4h(
        self, dataframe: DataFrame, metadata: dict
    ) -> DataFrame:
        sh, sl = self._detect_swing_points(
            dataframe["high"], dataframe["low"],
            self.swing_lookback_h4.value,
        )
        structure = self._build_structure(
            dataframe["high"], dataframe["low"], dataframe["close"],
            sh, sl,
        )
        dataframe["trend_up"] = structure["trend_up"]
        dataframe["trend_down"] = structure["trend_down"]
        dataframe["support"] = structure["support"]
        dataframe["resistance"] = structure["resistance"]
        dataframe["in_demand"] = structure["in_demand"]
        dataframe["in_supply"] = structure["in_supply"]

        # ================================
        # v1.6 活支撑/阻力检查（保留）
        # ================================
        touched_support = (
            (dataframe["low"] <= dataframe["support"] * 1.005) &
            (dataframe["low"] >= dataframe["support"] * 0.995)
        )
        held_support = dataframe["close"] > dataframe["support"]
        support_tested_and_held = touched_support & held_support
        dataframe["support_alive"] = support_tested_and_held.rolling(3, min_periods=1).max() > 0

        touched_resistance = (
            (dataframe["high"] >= dataframe["resistance"] * 0.995) &
            (dataframe["high"] <= dataframe["resistance"] * 1.005)
        )
        held_resistance = dataframe["close"] < dataframe["resistance"]
        resistance_tested_and_held = touched_resistance & held_resistance
        dataframe["resistance_alive"] = resistance_tested_and_held.rolling(3, min_periods=1).max() > 0

        return dataframe

    # ================================================================
    #  主时间框架 — 1H 指标
    # ================================================================

    def populate_indicators(
        self, dataframe: DataFrame, metadata: dict
    ) -> DataFrame:
        """1H 级别：K线形态（零指标）。"""
        bullish_pin, bearish_pin, bullish_engulf, bearish_engulf = (
            self._detect_candle_patterns(
                dataframe["open"],
                dataframe["high"],
                dataframe["low"],
                dataframe["close"],
                self.pin_bar_wick_ratio.value / 100.0,
            )
        )
        dataframe["bullish_pinbar"] = bullish_pin
        dataframe["bearish_pinbar"] = bearish_pin
        dataframe["bullish_engulfing"] = bullish_engulf
        dataframe["bearish_engulfing"] = bearish_engulf
        dataframe["bullish_signal"] = bullish_pin | bullish_engulf
        dataframe["bearish_signal"] = bearish_pin | bearish_engulf

        # NaN 安全处理
        bool_cols = [
            "trend_up_1d", "trend_down_1d",
            "trend_up_4h", "trend_down_4h",
            "in_demand_4h", "in_supply_4h",
            "support_alive_4h", "resistance_alive_4h",
            "bullish_signal", "bearish_signal",
        ]
        for col in bool_cols:
            if col in dataframe.columns:
                dataframe[col] = dataframe[col].fillna(False)

        return dataframe

    # =====================
    # 入场信号 — v2.0 延迟确认
    # =====================

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        入场逻辑（1H 时间框架）。

        v2.0 核心改动：B1 — 入场延迟一根1H bar确认

        做多条件:
          1. D1 上升结构（trend_up_1d）
          2. 4H 需求区域（in_demand_4h）
          3. 1H 看涨 K 线形态（bullish_signal）
          4. 止损距离 ≤ max_stop_dist%
          5. 支撑位是"活"的（support_alive_4h）
          6. 6h内没有过同方向入场信号（冷却期）
          7. [v2.0 NEW] 上一根bar触发了信号，当前bar收盘确认：
             做多：close 仍在 support_4h 上方 entry_confirm_pct% 以内
             做空：close 仍在 resistance_4h 下方 entry_confirm_pct% 以内
        """
        max_dist = self.max_stop_dist.value / 100.0
        cooldown = self.cooldown_bars.value
        confirm_pct = self.entry_confirm_pct.value / 1000.0  # 1.0%~3.0%

        # NaN 安全处理
        bool_cols = [
            "trend_up_1d", "trend_down_1d",
            "trend_up_4h", "trend_down_4h",
            "in_demand_4h", "in_supply_4h",
            "support_alive_4h", "resistance_alive_4h",
            "bullish_signal", "bearish_signal",
        ]
        for col in bool_cols:
            if col in dataframe.columns:
                dataframe[col] = dataframe[col].fillna(False)

        # =====================
        # 原始v1.6入场条件（不变）
        # =====================

        # ── 做多原始条件 ──
        long_stop_dist = (dataframe["open"] - dataframe["support_4h"]) / dataframe["open"]

        long_base = (
            dataframe["trend_up_1d"]
            & dataframe["in_demand_4h"]
            & dataframe["bullish_signal"]
            & (long_stop_dist <= max_dist)
            & (long_stop_dist > 0.003)
            & dataframe["support_alive_4h"]
        )

        # 冷却期
        long_recent = long_base.rolling(cooldown, min_periods=1).max().shift(1) == 0
        long_signal = long_base & long_recent

        # ── 做空原始条件 ──
        short_stop_dist = (dataframe["resistance_4h"] - dataframe["open"]) / dataframe["open"]

        short_base = (
            dataframe["trend_down_1d"]
            & dataframe["in_supply_4h"]
            & dataframe["bearish_signal"]
            & (short_stop_dist <= max_dist)
            & (short_stop_dist > 0.003)
            & dataframe["resistance_alive_4h"]
        )

        short_recent = short_base.rolling(cooldown, min_periods=1).max().shift(1) == 0
        short_signal = short_base & short_recent

        # =====================
        # v2.0: B1 — 入场延迟一根bar确认
        # =====================
        # 上一根bar的信号（shift(1)）
        prev_long_signal = long_signal.shift(1).fillna(False)
        prev_short_signal = short_signal.shift(1).fillna(False)

        # 确认条件：当前bar的close仍在S/R附近
        # 做多：close在support上方确认区间内（support * 1.0 ~ support * (1+confirm_pct)）
        long_confirm = (
            (dataframe["close"] >= dataframe["support_4h"]) &
            (dataframe["close"] <= dataframe["support_4h"] * (1 + confirm_pct))
        )

        # 做空：close在resistance下方确认区间内（resistance * (1-confirm_pct) ~ resistance * 1.0）
        short_confirm = (
            (dataframe["close"] <= dataframe["resistance_4h"]) &
            (dataframe["close"] >= dataframe["resistance_4h"] * (1 - confirm_pct))
        )

        # 最终入场：上一根bar有信号 + 当前bar确认
        dataframe.loc[prev_long_signal & long_confirm, "enter_long"] = 1
        dataframe.loc[prev_short_signal & short_confirm, "enter_short"] = 1

        return dataframe

    # =====================
    # 出场信号
    # =====================

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """出场逻辑 — 由结构反转触发。"""
        exit_long = ~dataframe["trend_up_1d"].fillna(True)
        dataframe.loc[exit_long, "exit_long"] = 1

        exit_short = dataframe["trend_up_1d"].fillna(False)
        dataframe.loc[exit_short, "exit_short"] = 1

        return dataframe

    # =====================
    # 动态止损 — 纯价格结构（基于Swing Point）
    # =====================

    def custom_stoploss(
        self,
        pair: str,
        trade: Trade,
        current_time: datetime,
        current_rate: float,
        current_profit: float,
        after_fill: bool,
        **kwargs,
    ) -> float:
        """
        止损逻辑：完全基于价格结构，零指标（与v1.6相同）。

        止损位：
          做多 → support_4h - 0.1%缓冲
          做空 → resistance_4h + 0.1%缓冲

        support_4h / resistance_4h 随新Swing Point自动更新，
        天然形成追踪止损效果。
        """
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        if dataframe is None or len(dataframe) == 0:
            return -0.02 if not trade.is_short else 0.02

        last = dataframe.iloc[-1]

        if not trade.is_short:
            support = last.get("support_4h", np.nan)
            if pd.isna(support) or support <= 0:
                return -0.02
            sl_price = support * 0.999
            sl_ratio = (sl_price / current_rate) - 1.0
            return max(sl_ratio, -0.15)
        else:
            resistance = last.get("resistance_4h", np.nan)
            if pd.isna(resistance) or resistance <= 0:
                return 0.02
            sl_price = resistance * 1.001
            sl_ratio = 1.0 - (sl_price / current_rate)
            return min(sl_ratio, 0.15)

    # =====================
    # Plot config
    # =====================

    @staticmethod
    def plot_config() -> dict:
        return {
            "main_plot": {
                "support_4h": {"color": "green", "type": "line"},
                "resistance_4h": {"color": "red", "type": "line"},
            },
            "subplots": {
                "signals": {
                    "bullish_pinbar": {"color": "green", "type": "scatter"},
                    "bearish_pinbar": {"color": "red", "type": "scatter"},
                },
                "filters": {
                    "support_alive_4h": {"color": "green", "type": "line"},
                    "resistance_alive_4h": {"color": "red", "type": "line"},
                },
            },
        }