import logging
from functools import reduce
from typing import Dict
import numpy as np
import talib.abstract as ta
from pandas import DataFrame
from technical import qtpylib
from talib import MACD, RSI
from datetime import datetime
import pandas as pd
import uuid
from freqtrade.strategy import IStrategy
logger = logging.getLogger(__name__)
# freqtrade backtesting --config user_data/ChanLun_XGB.json --strategy ChanLun_XGB --freqaimodel XGBoostClassifier --timerange=20250401-20250421

class ChanLun_XGB(IStrategy):
    minimal_roi = {"0": 0.1, "240": -1}
    plot_config = {
        "main_plot": {},
        "subplots": {
            "&-s_close": {"&-s_close": {"color": "blue"}},
            "do_predict": {"do_predict": {"color": "brown"}},
        },
    }
    process_only_new_candles = True
    stoploss = -0.05
    use_exit_signal = True
    startup_candle_count: int = 100  # Ensure sufficient data for pivots
    can_short = True

    freqai_info = {
        "feature_parameters": {
            "label_period_candles": 24
        }
    }

    def feature_engineering_expand_all(self, dataframe: DataFrame, period: int, metadata: Dict, **kwargs) -> DataFrame:
        """Basic technical indicators for various periods."""
        logger.debug("Starting feature_engineering_expand_all")
        dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
        dataframe["%-mfi-period"] = ta.MFI(dataframe, timeperiod=period)
        dataframe["%-adx-period"] = ta.ADX(dataframe, timeperiod=period)
        dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)

        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=period, stds=2.2)
        dataframe["bb_lowerband-period"] = bollinger["lower"]
        dataframe["bb_middleband-period"] = bollinger["mid"]
        dataframe["bb_upperband-period"] = bollinger["upper"]

        dataframe["%-bb_width-period"] = (
            (dataframe["bb_upperband-period"] - dataframe["bb_lowerband-period"]) / dataframe["bb_middleband-period"]
        )
        dataframe["%-close-bb_lower-period"] = dataframe["close"] / dataframe["bb_lowerband-period"]
        dataframe["%-roc-period"] = ta.ROC(dataframe, timeperiod=period)
        dataframe["%-relative_volume-period"] = dataframe["volume"] / dataframe["volume"].rolling(period).mean()

        return dataframe.fillna(0)

    def feature_engineering_expand_basic(self, dataframe: DataFrame, metadata: Dict, **kwargs) -> DataFrame:
        """Basic price and volume features."""
        logger.debug("Starting feature_engineering_expand_basic")
        dataframe["%-pct-change"] = dataframe["close"].pct_change()
        dataframe["%-raw_volume"] = dataframe["volume"]
        dataframe["%-raw_price"] = dataframe["close"]
        return dataframe.fillna(0)

    def feature_engineering_standard(self, dataframe: DataFrame, metadata: Dict, **kwargs) -> DataFrame:
        """Advanced feature engineering with Chan Lun and technical indicators."""
        logger.info(f"Starting feature_engineering_standard for pair {metadata.get('pair', 'unknown')}")
        if dataframe.empty or len(dataframe) < self.startup_candle_count:
            logger.error(f"Input DataFrame is empty or too small: {len(dataframe)} candles")
            return self.ensure_columns(dataframe, [
                '%-buy_signal', '%-bottom_strength', '%-sell_signal', '%-top_strength',
                '%-macd_top_div', '%-rsi-14', '%-top_combo', '%-top_candle_pattern', '%-bottom_combo'
            ])

        df = dataframe.copy()
        if df['close'].isna().any():
            logger.warning(f"Missing data: {df[['open', 'high', 'low', 'close', 'volume']].isna().sum()}")

        # Time-based features
        df["%-day_of_week"] = df["date"].dt.dayofweek
        df["%-hour_of_day"] = df["date"].dt.hour

        # Fractal detection
        df = self.detect_fractals(df)
        logger.debug("Fractal detection completed")

        # MACD and RSI
        macd, signal, hist = MACD(df['close'], fastperiod=12, slowperiod=26, signalperiod=9)
        df['macd'] = macd
        df['macd_signal'] = signal
        df['macd_hist'] = hist
        df['macd_hist_sum'] = df['macd_hist'].rolling(5).sum()
        df["%-rsi-14"] = RSI(df['close'], timeperiod=14)
        logger.debug("MACD and RSI calculated")

        # Candlestick features
        df["%-close_open_diff"] = (df["close"] - df["open"]) / df["open"].replace(0, np.nan)
        df["%-body_length"] = abs(df["close"] - df["open"]) / df["close"].replace(0, np.nan)
        df["%-upper_shadow"] = (df["high"] - df[["open", "close"]].max(axis=1)) / df["close"].replace(0, np.nan)
        df["%-lower_shadow"] = (df[["open", "close"]].min(axis=1) - df["low"]) / df["close"].replace(0, np.nan)

        # Candle color and trend
        df["%-candle_color"] = (df["close"] > df["open"]).astype(int) * 2 - 1
        df["%-consec_same_color"] = df["%-candle_color"].groupby((df["%-candle_color"] != df["%-candle_color"].shift()).cumsum()).cumcount() + 1

        # Fractal strength
        df["%-bottom_strength"], df["%-top_strength"] = self.calculate_fractal_strength(df)
        logger.debug("Fractal strength calculated")

        # Price relationships
        for i in [1, 2, 3]:
            high_shift = df['high'].shift(i).replace(0, df['high'].mean())
            low_shift = df['low'].shift(i).replace(0, df['low'].mean())
            df[f"%-high_ratio_{i}"] = df['high'] / high_shift
            df[f"%-low_ratio_{i}"] = df['low'] / low_shift

        # MACD divergence
        df["%-macd_bottom_div"] = ((df['low'] < df['low'].rolling(5).min().shift(1)) & (df['macd'] > df['macd'].rolling(5).min().shift(1))).astype(int)
        df["%-macd_top_div"] = ((df['high'] > df['high'].rolling(5).max().shift(1)) & (df['macd'] < df['macd'].rolling(5).max().shift(1))).astype(int)

        # Additional features
        df["%-volume_change"] = df['volume'].pct_change()
        df["%-volatility"] = df['close'].rolling(5).std()
        df["%-price_range_20"] = (df['high'].rolling(5).max() - df['low'].rolling(5).min()) / df['close'].replace(0, np.nan)
        df["%-potential_top"] = (df['is_top'] & (df["%-rsi-14"] > 70) & (df["%-macd_top_div"] == 1) & 
                                (df['volume'] > df['volume'].rolling(20).mean()) & (df['close'] < df['open'])).astype(int)
        df["%-potential_bottom"] = (df['is_bottom'] & (df["%-rsi-14"] < 30) & (df["%-macd_bottom_div"] == 1)).astype(int)

        # Fractal distance
        df["%-last_fractal_distance"] = self.calculate_fractal_distance(df)

        # Advanced features
        df["%-macd_hist_change"] = df['macd_hist_sum'].pct_change().replace([np.inf, -np.inf], 0)
        df["%-volume_divergence"] = (df['close'].pct_change() - df['volume'].pct_change()).abs()
        df["%-breakout_high"] = (df['high'] > df['high'].shift(1).rolling(20).max()).astype(int)
        df["%-breakout_low"] = (df['low'] < df['low'].shift(1).rolling(20).min()).astype(int)
        df["%-top_prominence"] = (df['high'] - df['high'].shift(1).rolling(5).mean()) / (df['high'].shift(1).rolling(5).std() + 1e-6)
        df["%-top_prominence"] = df["%-top_prominence"].clip(-100, 100)
        df["%-macd_hist_decline"] = df['macd_hist'].rolling(3).apply(
            lambda x: 1 if all(x[i] > x[i+1] for i in range(len(x)-1)) else 0, raw=True)
        df["%-top_candle_pattern"] = ((df['close'].shift(1) > df['open'].shift(1)) & 
                                     (df['close'] < df['open']) & 
                                     (df['close'] < df['open'].shift(1))).astype(int)
        df["%-bottom_combo"] = (df['is_bottom'] & (df["%-rsi-14"] < 40) & (df['macd_hist'] > 0) & 
                               (df['volume'] > df['volume'].rolling(20).mean())).astype(int)
        df["%-top_combo"] = (df['is_top'] & (df["%-rsi-14"] > 60) & (df['macd_hist'] < 0) & 
                            (df['volume'] > df['volume'].rolling(20).mean())).astype(int)
        df["%-post_top_decline"] = self.calculate_post_top_decline(df)
        df["%-resistance_distance"] = self.calculate_resistance_distance(df)

        # Stroke and pivot features
        strokes = self.detect_strokes(df)
        df["%-macd_hist_dynamic"], df["%-pivot_distance"], df["%-buy_signal"], df["%-sell_signal"] = self.process_strokes_and_pivots(df, strokes)
        logger.debug("Stroke and pivot features completed")

        # Validate required columns
        required_columns = [
            '%-buy_signal', '%-bottom_strength', '%-sell_signal', '%-top_strength',
            '%-macd_top_div', '%-rsi-14', '%-top_combo', '%-top_candle_pattern', '%-bottom_combo'
        ]
        missing_columns = [col for col in required_columns if col not in df.columns]
        if missing_columns:
            logger.error(f"Missing required columns: {missing_columns}")
            df = self.ensure_columns(df, missing_columns)

        # Clean up
        num_columns = df.select_dtypes(include=[np.number]).columns
        df[num_columns] = df[num_columns].replace([np.inf, -np.inf], 0).fillna(0)
        logger.info(f"Completed feature_engineering_standard. Columns: {list(df.columns)}")
        return df

    def set_freqai_targets(self, dataframe: DataFrame, metadata: Dict, **kwargs) -> DataFrame:
        """Set prediction targets for FreqAI."""
        logger.debug(f"Setting FreqAI targets for pair {metadata.get('pair', 'unknown')}")
        label_period = self.freqai_info["feature_parameters"]["label_period_candles"]
        
        # Calculate future return
        future_return = (
            dataframe["close"].shift(-label_period).rolling(label_period).mean() / dataframe["close"] - 1
        )
        
        # 二分类标签：1(买入/上涨)，0(卖出/下跌) - 更简单且不易出错
        dataframe["&-s_close"] = np.where(future_return > 0.01, 1, 0).astype(int)
        
        logger.debug(f"Label distribution: {dataframe['&-s_close'].value_counts().to_dict()}")
        return dataframe.fillna(0)

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """Populate indicators, leveraging FreqAI if available."""
        logger.info(f"Starting populate_indicators for pair {metadata.get('pair', 'unknown')}")
        # Always run feature_engineering_standard to ensure custom features
        dataframe = self.feature_engineering_standard(dataframe, metadata)
        
        if hasattr(self, "freqai"):
            logger.info("Running FreqAI pipeline")
            # Preserve custom features
            custom_features = [col for col in dataframe.columns if col.startswith('%-')]
            base_columns = ['date', 'close', 'open', 'high', 'low', 'volume']
            # 仅保存确定存在的列
            preserve_columns = custom_features + [col for col in base_columns if col in dataframe.columns]
            temp_df = dataframe[preserve_columns]
            
            # 设置FreqAI目标
            dataframe = self.set_freqai_targets(dataframe, metadata)
            
            # Run FreqAI
            try:
                freqai_df = self.freqai.start(dataframe, metadata, self)
                # Merge back custom features
                freqai_df = freqai_df.combine_first(temp_df)
                dataframe = freqai_df
            except Exception as e:
                logger.error(f"FreqAI pipeline failed: {e}")
                # Fallback to custom features
        logger.info(f"Completed populate_indicators. Columns: {list(dataframe.columns)}")
        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """Generate entry signals for the strategy."""
        dataframe.loc[:, "enter_long"] = 0
        dataframe.loc[:, "enter_short"] = 0

        # 确保数据框中的列存在
        dataframe = self.ensure_columns(dataframe)
        
        # 只有当do_predict列存在时才使用它
        if "do_predict" in dataframe.columns:
            # 根据AI预测值设置交易信号 - 使用二分类结果
            mask = (dataframe["do_predict"] == 1)
            dataframe.loc[mask, "enter_long"] = 1
            
            # 设置空头信号 (如果策略支持空头)
            if self.can_short:
                mask = (dataframe["do_predict"] == 0)
                dataframe.loc[mask, "enter_short"] = 1
        
        # 将NaN值替换为0
        dataframe = dataframe.fillna(0)
        
        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """Generate exit signals for the strategy."""
        dataframe.loc[:, "exit_long"] = 0
        dataframe.loc[:, "exit_short"] = 0

        # 确保数据框中的列存在
        dataframe = self.ensure_columns(dataframe)
        
        # 只有当do_predict列存在时才使用它
        if "do_predict" in dataframe.columns:
            # 多头平仓信号
            mask = (dataframe["do_predict"] == 0)
            dataframe.loc[mask, "exit_long"] = 1
            
            # 空头平仓信号
            if self.can_short:
                mask = (dataframe["do_predict"] == 1)
                dataframe.loc[mask, "exit_short"] = 1
        
        # 将NaN值替换为0
        dataframe = dataframe.fillna(0)
        
        return dataframe

    def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float, time_in_force: str, 
                           current_time, entry_tag, side: str, **kwargs) -> bool:
        """Confirm trade entry with additional checks."""
        logger.debug(f"Confirming trade entry for {pair}, side: {side}")
        df, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        last_candle = df.iloc[-1].squeeze()
        df = self.ensure_columns(df, ['%-bottom_strength', '%-buy_signal', '%-top_strength', '%-sell_signal', '%-rsi-14'])

        if side == "long":
            if rate > (last_candle["close"] * 1.0025):
                logger.debug(f"Long entry rejected: rate {rate} exceeds threshold")
                return False
            return last_candle["%-bottom_strength"] > 1.5 or last_candle["%-buy_signal"] > 0
        else:
            if rate < (last_candle["close"] * 0.9975):
                logger.debug(f"Short entry rejected: rate {rate} below threshold")
                return False
            return last_candle["%-top_strength"] > 2.0 or last_candle["%-sell_signal"] > 0

    def detect_fractals(self, df: DataFrame) -> DataFrame:
        """Detect top and bottom fractals."""
        logger.debug("Detecting fractals")
        df['is_top'] = (
            (df['high'] > df['high'].shift(1)) & (df['high'] > df['high'].shift(2)) &
            (df['high'] > df['high'].shift(-1)) & (df['high'] > df['high'].shift(-2))
        )
        df['is_bottom'] = (
            (df['low'] < df['low'].shift(1)) & (df['low'] < df['low'].shift(2)) &
            (df['low'] < df['low'].shift(-1)) & (df['low'] < df['low'].shift(-2))
        )
        return df.fillna({'is_top': False, 'is_bottom': False})

    def calculate_fractal_strength(self, df: DataFrame) -> tuple:
        """Calculate strength of fractals."""
        logger.debug("Calculating fractal strength")
        bottom_strength = np.zeros(len(df))
        top_strength = np.zeros(len(df))

        for i in range(2, len(df) - 2):
            if df['is_bottom'].iloc[i]:
                strength = 0.0
                pre_decline = (df['low'].iloc[i-2:i].min() - df['low'].iloc[i]) / df['low'].iloc[i]
                post_rise = (df['high'].iloc[i+1:i+3].max() - df['high'].iloc[i]) / df['high'].iloc[i]
                strength += min(pre_decline * 10, 1.0) + min(post_rise * 10, 1.0)
                vol_surge = df['volume'].iloc[i] / df['volume'].iloc[i-3:i].mean() if df['volume'].iloc[i-3:i].mean() > 0 else 1
                strength += min(vol_surge / 3, 1.0)
                if any(abs(df['low'].iloc[j] - df['low'].iloc[i]) / df['low'].iloc[i] < 0.01 for j in range(max(0, i-20), i)):
                    strength += 1.0
                bottom_strength[i] = min(strength, 5.0)

            if df['is_top'].iloc[i]:
                strength = 0.0
                pre_rise = (df['high'].iloc[i] - df['high'].iloc[i-2:i].max()) / df['high'].iloc[i]
                post_decline = (df['low'].iloc[i] - df['low'].iloc[i+1:i+3].min()) / df['low'].iloc[i]
                strength += min(pre_rise * 10, 1.0) + min(post_decline * 10, 1.0)
                vol_surge = df['volume'].iloc[i] / df['volume'].iloc[i-3:i].mean() if df['volume'].iloc[i-3:i].mean() > 0 else 1
                strength += min(vol_surge / 3, 1.0)
                if any(abs(df['high'].iloc[j] - df['high'].iloc[i]) / df['high'].iloc[i] < 0.01 for j in range(max(0, i-20), i)):
                    strength += 1.0
                bearish_count = sum(df['close'].iloc[i:i+3] < df['open'].iloc[i:i+3])
                strength += min(bearish_count * 0.5, 1.5)
                top_strength[i] = min(strength, 6.0)

        return bottom_strength, top_strength

    def calculate_fractal_distance(self, df: DataFrame) -> pd.Series:
        """Calculate distance to last fractal."""
        logger.debug("Calculating fractal distance")
        fractal_indices = df[df['is_top'] | df['is_bottom']].index
        distances = pd.Series(0, index=df.index)

        for i in range(1, len(df)):
            if fractal_indices[fractal_indices < df.index[i]].size > 0:
                last_fractal_idx = fractal_indices[fractal_indices < df.index[i]][-1]
                if isinstance(df.index[i], pd.Timestamp) and isinstance(last_fractal_idx, pd.Timestamp):
                    time_diff = (df.index[i] - last_fractal_idx).total_seconds() / 60
                else:
                    time_diff = i - df.index.get_loc(last_fractal_idx)
                distances.iloc[i] = time_diff
        return distances

    def calculate_post_top_decline(self, df: DataFrame) -> pd.Series:
        """Calculate post-top decline."""
        logger.debug("Calculating post-top decline")
        post_top_decline = pd.Series(0.0, index=df.index)
        for i in range(2, len(df)-3):
            if df['is_top'].iloc[i]:
                decline = (df['high'].iloc[i] - df['low'].iloc[i+1:i+4].min()) / df['high'].iloc[i]
                post_top_decline.iloc[i] = min(decline * 10, 5.0)
        return post_top_decline

    def calculate_resistance_distance(self, df: DataFrame) -> pd.Series:
        """Calculate resistance distance."""
        logger.debug("Calculating resistance distance")
        resistance_distance = pd.Series(0.0, index=df.index)
        for i in range(20, len(df)):
            if df['is_top'].iloc[i]:
                price_high = df['high'].iloc[i]
                resistance_levels = df['high'].iloc[i-20:i].rolling(5).max()
                distance = (price_high - resistance_levels.min()) / price_high if resistance_levels.min() > 0 else 0
                resistance_distance.iloc[i] = min(distance * 10, 5.0)
        return resistance_distance

    def detect_strokes(self, df: DataFrame) -> list:
        """Detect strokes based on fractals."""
        logger.debug("Detecting strokes")
        strokes = []
        last_fractal, last_price, last_index = None, None, None

        for i in range(len(df)):
            if df['is_top'].iloc[i] or df['is_bottom'].iloc[i]:
                current_fractal = 'top' if df['is_top'].iloc[i] else 'bottom'
                current_price = df['high'].iloc[i] if current_fractal == 'top' else df['low'].iloc[i]

                if last_fractal is None:
                    last_fractal, last_price, last_index = current_fractal, current_price, df.index[i]
                    continue

                if not isinstance(current_price, (int, float)) or not isinstance(last_price, (int, float)):
                    continue

                price_change = abs(current_price - last_price) / last_price
                if price_change < 0.005:
                    continue

                if (last_fractal == 'top' and current_fractal == 'bottom' and current_price < last_price) or \
                   (last_fractal == 'bottom' and current_fractal == 'top' and current_price > last_price):
                    strokes.append({
                        'start_time': last_index,
                        'end_time': df.index[i],
                        'start_price': last_price,
                        'end_price': current_price,
                        'type': 'down' if current_fractal == 'bottom' else 'up'
                    })

                last_fractal, last_price, last_index = current_fractal, current_price, df.index[i]

        logger.debug(f"Detected {len(strokes)} strokes")
        return strokes

    def detect_pivots(self, strokes: list) -> list:
        """Detect pivots based on strokes."""
        logger.debug("Detecting pivots")
        pivots = []
        if len(strokes) < 3:
            logger.debug("Insufficient strokes for pivot detection")
            return pivots

        for i in range(2, len(strokes)):
            high1, low1 = max(strokes[i-2]['start_price'], strokes[i-2]['end_price']), min(strokes[i-2]['start_price'], strokes[i-2]['end_price'])
            high2, low2 = max(strokes[i-1]['start_price'], strokes[i-1]['end_price']), min(strokes[i-1]['start_price'], strokes[i-1]['end_price'])
            high3, low3 = max(strokes[i]['start_price'], strokes[i]['end_price']), min(strokes[i]['start_price'], strokes[i]['end_price'])
            if max(low1, low2, low3) < min(high1, high2, high3):
                pivots.append({
                    'start_time': strokes[i-2]['start_time'],
                    'end_time': strokes[i]['end_time'],
                    'high': min(high1, high2, high3),
                    'low': max(low1, low2, low3)
                })
        logger.debug(f"Detected {len(pivots)} pivots")
        return pivots

    def add_pivot_distance(self, df: DataFrame, pivots: list) -> DataFrame:
        """Add pivot distance feature."""
        logger.debug("Adding pivot distance")
        df = df.copy()
        df['pivot_distance'] = 0.0

        if not pivots:
            logger.debug("No pivots detected, returning default pivot_distance")
            return df

        for pivot in pivots:
            try:
                start_time = pivot['start_time']
                end_time = pivot['end_time']
                if start_time not in df.index or end_time not in df.index:
                    logger.debug(f"Invalid pivot times: {start_time} to {end_time}")
                    continue
                mask = (df.index >= start_time) & (df.index <= end_time)
                denominator = pivot['high'] - pivot['low']
                if denominator > 0:
                    df.loc[mask, 'pivot_distance'] = (df['close'] - pivot['low']) / denominator
                else:
                    logger.debug(f"Zero denominator for pivot {pivot}")
            except Exception as e:
                logger.error(f"Error in pivot distance calculation: {e}")
                continue

        df['pivot_distance'] = df['pivot_distance'].clip(-10, 10).fillna(0.0)
        logger.debug("Completed pivot distance calculation")
        return df

    def detect_back_divergence(self, df: DataFrame, strokes: list) -> DataFrame:
        """Detect back divergence for buy/sell signals."""
        logger.debug("Detecting back divergence")
        df = df.copy()
        df['buy_signal'] = False
        df['sell_signal'] = False

        if len(strokes) < 2:
            logger.debug("Insufficient strokes for divergence detection")
            return df

        for i in range(1, len(strokes)):
            current_hist = self.safe_get_value(df, strokes[i]['end_time'], 'macd_hist_sum')
            previous_hist = self.safe_get_value(df, strokes[i-1]['end_time'], 'macd_hist_sum')

            if current_hist is None or previous_hist is None:
                continue

            if strokes[i]['type'] == strokes[i-1]['type'] == 'up':
                if strokes[i]['end_price'] > strokes[i-1]['end_price'] and current_hist < previous_hist:
                    closest_time = df.index[df.index <= strokes[i]['end_time']]
                    if len(closest_time) > 0:
                        df.loc[closest_time[-1], 'sell_signal'] = True

            elif strokes[i]['type'] == strokes[i-1]['type'] == 'down':
                if strokes[i]['end_price'] < strokes[i-1]['end_price'] and current_hist < previous_hist:
                    closest_time = df.index[df.index <= strokes[i]['end_time']]
                    if len(closest_time) > 0:
                        df.loc[closest_time[-1], 'buy_signal'] = True

        logger.debug("Completed back divergence detection")
        return df

    def process_strokes_and_pivots(self, df: DataFrame, strokes: list) -> tuple:
        """Process strokes and pivots for advanced features."""
        logger.debug("Processing strokes and pivots")
        macd_hist_dynamic = pd.Series(0.0, index=df.index)
        pivot_distance = pd.Series(0.0, index=df.index)
        buy_signal = pd.Series(0, index=df.index)
        sell_signal = pd.Series(0, index=df.index)

        if strokes:
            try:
                for stroke in strokes[1:]:
                    start_time, end_time = stroke['start_time'], stroke['end_time']
                    if start_time not in df.index or end_time not in df.index:
                        logger.debug(f"Invalid stroke times: {start_time} to {end_time}")
                        continue

                    window = self.calculate_window(df, start_time, end_time)
                    start_idx, end_idx = df.index.get_loc(start_time), df.index.get_loc(end_time) + 1
                    hist_values = df['macd_hist'].iloc[start_idx:end_idx].rolling(window, min_periods=1).sum().fillna(0)
                    macd_hist_dynamic.iloc[start_idx:end_idx] = hist_values
                logger.debug("Dynamic MACD calculated")
            except Exception as e:
                logger.warning(f"Dynamic MACD calculation error: {e}")

            try:
                pivots = self.detect_pivots(strokes)
                if pivots:
                    df_with_pivot = self.add_pivot_distance(df, pivots)
                    pivot_distance = df_with_pivot['pivot_distance']
                else:
                    logger.debug("No pivots detected")
            except Exception as e:
                logger.warning(f"Pivot detection error: {e}")

            try:
                df_with_divergence = self.detect_back_divergence(df, strokes)
                buy_signal = df_with_divergence['buy_signal'].astype(int)
                sell_signal = df_with_divergence['sell_signal'].astype(int)
                logger.debug("Back divergence signals calculated")
            except Exception as e:
                logger.warning(f"Back divergence detection error: {e}")

        logger.debug("Completed stroke and pivot processing")
        return macd_hist_dynamic, pivot_distance, buy_signal, sell_signal

    def ensure_columns(self, dataframe: DataFrame) -> DataFrame:
        """确保数据框中包含必要的列"""
        # 不要尝试创建do_predict和&-s_close列，它们由FreqAI生成
        for col in ["enter_long", "enter_short", "exit_long", "exit_short"]:
            if col not in dataframe.columns:
                dataframe[col] = 0
        return dataframe

    def safe_get_value(self, df: DataFrame, timestamp, column: str):
        """Safely get value from DataFrame."""
        try:
            if timestamp in df.index:
                return df.loc[timestamp, column]
            closest_idx = df.index[df.index <= timestamp]
            return df.loc[closest_idx[-1], column] if len(closest_idx) > 0 else None
        except Exception as e:
            logger.debug(f"Error getting value for {column} at {timestamp}: {e}")
            return None

    def calculate_window(self, df: DataFrame, start_time, end_time) -> int:
        """Calculate window size for dynamic features."""
        try:
            if isinstance(start_time, pd.Timestamp) and isinstance(end_time, pd.Timestamp):
                window = int((end_time - start_time).total_seconds() / 60)
            else:
                start_idx = df.index.get_loc(start_time)
                end_idx = df.index.get_loc(end_time)
                window = end_idx - start_idx
            return max(window, 1)
        except (TypeError, AttributeError, KeyError) as e:
            logger.debug(f"Window calculation error: {e}")
            return 1