# source: https://raw.githubusercontent.com/t734070824/my-projects/6625ecd6d435e484bf5bd5f4bc43a508602275e3/my-btc-trade-system/buy_sell_notify/freqtrade/strategies-v3/TripleTimeframeTrendStrategyV3_4.py
# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement

from freqtrade.strategy.interface import IStrategy
from typing import Dict, List, Optional
from functools import reduce

import talib.abstract as ta
import numpy as np  
import pandas as pd
from pandas import DataFrame

class Github_t734070824_my_projects__TripleTimeframeTrendStrategyV3_4__20250811_095941(IStrategy):
    """
    三重时间框架趋势跟踪策略 V3.4 - 新版FreqTrade双向交易
    
    修复V3.2语法问题，使用新版FreqTrade语法：
    1. 使用 enter_long/enter_short 替代 buy/sell
    2. 使用 enter_tag 统一标签系统
    3. 保持所有优化的做空条件
    4. 确保双向交易信号正确触发
    """

    # 策略参数
    INTERFACE_VERSION = 3
    
    # 平衡的ROI设置
    minimal_roi = {
        "0": 0.25,   # 25% 
        "30": 0.18,  # 30分钟后18%
        "60": 0.12,  # 1小时后12% 
        "120": 0.08, # 2小时后8%
        "240": 0.05, # 4小时后5%
        "480": 0.03  # 8小时后3%
    }

    # 适中的止损
    stoploss = -0.04  # 4% 止损

    # 时间框架
    timeframe = '1h'
    
    # 启用位置堆叠
    position_stacking = False
    
    # 可以做多做空
    can_short = True

    # 启用使用卖出信号
    use_exit_signal = True
    exit_profit_only = False
    ignore_roi_if_entry_signal = False

    # 平衡的追踪止损设置
    trailing_stop = True
    trailing_stop_positive = 0.02   # 2%后启用追踪止损
    trailing_stop_positive_offset = 0.04  # 追踪止损偏移4%
    trailing_only_offset_is_reached = True

    # 优化的参数
    sma_short_period = 18    # 保持敏感
    sma_long_period = 46     # 适中
    
    macd_fast = 11      # 保持敏感
    macd_slow = 25      # 适中
    macd_signal = 9     # 标准
    
    rsi_period = 14
    rsi_overbought = 71  # 70→71 稍微放宽
    rsi_oversold = 29    # 30→29 稍微放宽
    
    bb_period = 20
    bb_std = 2.0
    
    ichimoku_conversion = 9
    ichimoku_base = 26
    ichimoku_lagging = 52
    
    atr_period = 14

    # 基于表现优化权重 - 不完全屏蔽任何币种
    pair_weights = {
        'XRP/USDT': 1.4,     # 577.88% - 最佳表现
        'AVAX/USDT': 1.3,    # 514.12% - 优秀表现
        'WIF/USDT': 1.1,     # 396.57% - 良好但波动大
        'ADA/USDT': 1.2,     # 367.26% - 良好表现
        'LINK/USDT': 1.1,    # 324.00% - 稳定表现
        'ETH/USDT': 1.1,     # 319.24% - 主流稳定
        'SOL/USDT': 1.2,     # 303.08% - 好表现
        'BNB/USDT': 1.0,     # 289.12% - 中等表现
        'DOGE/USDT': 1.0,    # 281.69% - 中等表现
        'DOT/USDT': 0.9,     # 180.89% - 较弱表现
        'NEAR/USDT': 0.8,    # 118.14% - 弱表现
        'SUI/USDT': 0.7,     # -7.89% - 小亏损但保留
        'BTC/USDT': 0.9,     # -14.93% - 意外亏损但保留
        'UNI/USDT': 0.6,     # -78.05% - 最差但仍保留
    }
    
    # 适中的信号阈值
    strong_signal_threshold = 3    # 保持3
    weak_signal_threshold = 1      # 2→1 降低
    
    # V3.4 做空专用阈值 (更容易触发)
    strong_short_threshold = 2     # 降低：3→2
    weak_short_threshold = 0       # 降低：1→0
    
    market_volatility_period = 50
    trending_threshold = 0.02      # 0.025→0.02 放宽

    def informative_pairs(self):
        pairs = self.dp.current_whitelist()
        informative_pairs = []
        for pair in pairs:
            informative_pairs.extend([
                (pair, '1d'),
                (pair, '4h')
            ])
        return informative_pairs

    def populate_indicators(self, dataframe: DataFrame, metadata: Dict) -> DataFrame:
        inf_1d = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe='1d')
        inf_4h = self.dp.get_pair_dataframe(pair=metadata['pair'], timeframe='4h')
        
        # 1小时指标
        dataframe['sma_short'] = ta.SMA(dataframe, timeperiod=self.sma_short_period)
        dataframe['sma_long'] = ta.SMA(dataframe, timeperiod=self.sma_long_period)
        
        macd = ta.MACD(dataframe, fastperiod=self.macd_fast, slowperiod=self.macd_slow, signalperiod=self.macd_signal)
        dataframe['macd'] = macd['macd']
        dataframe['macdsignal'] = macd['macdsignal'] 
        dataframe['macdhist'] = macd['macdhist']
        
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=self.rsi_period)
        
        bollinger = ta.BBANDS(dataframe, timeperiod=self.bb_period, nbdevup=float(self.bb_std), nbdevdn=float(self.bb_std))
        dataframe['bb_lower'] = bollinger['lowerband']
        dataframe['bb_middle'] = bollinger['middleband']
        dataframe['bb_upper'] = bollinger['upperband']
        dataframe['bb_percent'] = (dataframe['close'] - dataframe['bb_lower']) / (dataframe['bb_upper'] - dataframe['bb_lower'])
        
        dataframe['atr'] = ta.ATR(dataframe, timeperiod=self.atr_period)
        
        # 简化的风险指标
        dataframe['volume_sma'] = ta.SMA(dataframe['volume'], timeperiod=20)
        dataframe['volume_ratio'] = dataframe['volume'] / dataframe['volume_sma']
        
        # 市场状态
        dataframe['market_volatility'] = dataframe['close'].rolling(self.market_volatility_period).std() / dataframe['close'].rolling(self.market_volatility_period).mean()
        dataframe['is_trending'] = dataframe['market_volatility'] > self.trending_threshold
        
        dataframe['h1_score'] = self.calculate_balanced_score(dataframe)
        
        # 处理日线数据
        if len(inf_1d) > 0:
            inf_1d['sma_short'] = ta.SMA(inf_1d, timeperiod=self.sma_short_period)
            inf_1d['sma_long'] = ta.SMA(inf_1d, timeperiod=self.sma_long_period) 
            inf_1d['rsi'] = ta.RSI(inf_1d, timeperiod=self.rsi_period)
            
            macd_1d = ta.MACD(inf_1d, fastperiod=self.macd_fast, slowperiod=self.macd_slow, signalperiod=self.macd_signal)
            inf_1d['macd'] = macd_1d['macd']
            inf_1d['macdsignal'] = macd_1d['macdsignal']
            inf_1d['macdhist'] = macd_1d['macdhist']
            
            bollinger_1d = ta.BBANDS(inf_1d, timeperiod=self.bb_period, nbdevup=float(self.bb_std), nbdevdn=float(self.bb_std))
            inf_1d['bb_lower'] = bollinger_1d['lowerband']
            inf_1d['bb_middle'] = bollinger_1d['middleband'] 
            inf_1d['bb_upper'] = bollinger_1d['upperband']
            
            inf_1d['daily_score'] = self.calculate_balanced_score(inf_1d)
            
            dataframe = pd.merge(dataframe, inf_1d[['date', 'daily_score']], on='date', how='left')
            dataframe['daily_score'] = dataframe['daily_score'].fillna(method='ffill')
        
        # 处理4小时数据
        if len(inf_4h) > 0:
            inf_4h['sma_short'] = ta.SMA(inf_4h, timeperiod=self.sma_short_period)
            inf_4h['sma_long'] = ta.SMA(inf_4h, timeperiod=self.sma_long_period)
            inf_4h['rsi'] = ta.RSI(inf_4h, timeperiod=self.rsi_period)
            
            macd_4h = ta.MACD(inf_4h, fastperiod=self.macd_fast, slowperiod=self.macd_slow, signalperiod=self.macd_signal)
            inf_4h['macd'] = macd_4h['macd'] 
            inf_4h['macdsignal'] = macd_4h['macdsignal']
            inf_4h['macdhist'] = macd_4h['macdhist']
            
            bollinger_4h = ta.BBANDS(inf_4h, timeperiod=self.bb_period, nbdevup=float(self.bb_std), nbdevdn=float(self.bb_std))
            inf_4h['bb_lower'] = bollinger_4h['lowerband']
            inf_4h['bb_middle'] = bollinger_4h['middleband']
            inf_4h['bb_upper'] = bollinger_4h['upperband']
            
            inf_4h['h4_score'] = self.calculate_balanced_score(inf_4h)
            
            dataframe = pd.merge(dataframe, inf_4h[['date', 'h4_score']], on='date', how='left') 
            dataframe['h4_score'] = dataframe['h4_score'].fillna(method='ffill')
            
        dataframe['daily_score'] = dataframe['daily_score'].fillna(0)
        dataframe['h4_score'] = dataframe['h4_score'].fillna(0)
        
        dataframe['signal_strength'] = self.calculate_signal_strength(dataframe)
        
        return dataframe

    def calculate_balanced_score(self, df: DataFrame) -> pd.Series:
        """平衡版评分计算"""
        score = pd.Series(0.0, index=df.index)
        
        # SMA趋势评分 - 标准权重
        sma_trend = np.where(
            (df['close'] > df['sma_short']) & (df['sma_short'] > df['sma_long']), 2,
            np.where(
                (df['close'] < df['sma_short']) & (df['sma_short'] < df['sma_long']), -2,
                np.where(df['close'] > df['sma_short'], 1, -1)
            )
        )
        score += sma_trend
        
        # MACD评分
        if 'macdhist' in df.columns:
            macd_score = np.where(
                (df['macd'] > df['macdsignal']) & (df['macdhist'] > 0), 2,
                np.where(
                    (df['macd'] < df['macdsignal']) & (df['macdhist'] < 0), -2,
                    np.where(df['macd'] > df['macdsignal'], 1, -1)
                )
            )
        else:
            macd_score = np.where(df['macd'] > df['macdsignal'], 1, -1)
        score += macd_score
        
        # RSI评分 - 适中权重
        rsi_score = np.where(
            df['rsi'] > 60, 1,
            np.where(df['rsi'] < 40, -1, 0)
        )
        score += rsi_score
        
        # 布林带评分 - 降低权重
        if 'bb_upper' in df.columns and 'bb_lower' in df.columns:
            bb_score = np.where(
                df['close'] > df['bb_upper'], 0.5,
                np.where(df['close'] < df['bb_lower'], -0.5, 0)
            )
            score += bb_score
        
        return score

    def calculate_signal_strength(self, dataframe: DataFrame) -> pd.Series:
        """简化的信号强度计算"""
        strength = pd.Series(0.0, index=dataframe.index)
        
        # 三时间框架权重
        daily_weight = abs(dataframe['daily_score']) * 0.4
        h4_weight = abs(dataframe['h4_score']) * 0.3  
        h1_weight = abs(dataframe['h1_score']) * 0.3   # 增加1h权重
        
        # 成交量确认 - 简化
        volume_confirm = np.where(dataframe['volume_ratio'] > 1.0, 0.5, 0)
        
        strength = daily_weight + h4_weight + h1_weight + volume_confirm
        
        return np.clip(strength, 0, 10)

    def populate_entry_trend(self, dataframe: DataFrame, metadata: Dict) -> DataFrame:
        """
        双向入场条件 - V3.4 使用新版FreqTrade语法
        """
        pair = metadata['pair']
        pair_weight = self.pair_weights.get(pair, 1.0)
        
        # 初始化新版FreqTrade列
        dataframe['enter_long'] = 0
        dataframe['enter_short'] = 0
        dataframe['enter_tag'] = ''
        
        # === 做多信号 (保持V2.1原逻辑不变) ===
        conditions_strong_long = []
        conditions_weak_long = []
        
        # 强做多信号 - 标准条件
        conditions_strong_long.append(dataframe['daily_score'] > 0)      # 放宽
        conditions_strong_long.append(dataframe['h4_score'] > 0)        # 放宽  
        conditions_strong_long.append(dataframe['h1_score'] >= self.strong_signal_threshold)
        
        # 弱做多信号 - 为所有币种开放，但根据权重调整
        if pair_weight >= 1.1:  # 高权重币种
            weak_threshold_long = 1
        elif pair_weight >= 0.8:  # 中等权重币种
            weak_threshold_long = 2  
        else:  # 低权重币种
            weak_threshold_long = 3
            
        weak_cond_1_long = (
            (dataframe['daily_score'] >= 0) & 
            (dataframe['h4_score'] >= 0) & 
            (dataframe['h1_score'] >= weak_threshold_long) &
            (dataframe['signal_strength'] >= 3)
        )
        
        # 趋势市场中的机会信号
        weak_cond_2_long = (
            (dataframe['is_trending']) &
            (dataframe['daily_score'] > 1) &
            (dataframe['h1_score'] >= self.weak_signal_threshold) &
            (dataframe['signal_strength'] >= 4)
        )
        
        conditions_weak_long.append(weak_cond_1_long)
        conditions_weak_long.append(weak_cond_2_long)
        
        # 做多通用过滤 - 适度严格
        common_filters_long = []
        common_filters_long.append(dataframe['volume'] > 0)
        common_filters_long.append(dataframe['rsi'] < self.rsi_overbought)
        common_filters_long.append(dataframe['volume_ratio'] > 0.8)   # 放宽
        
        # 币种权重调整过滤强度
        if pair_weight >= 1.2:
            # 高权重币种 - 更宽松
            common_filters_long.append(dataframe['rsi'] < 75)
        elif pair_weight >= 0.8:
            # 中权重币种 - 标准
            common_filters_long.append(dataframe['rsi'] < self.rsi_overbought)
        else:
            # 低权重币种 - 更严格
            common_filters_long.append(dataframe['rsi'] < 68)
        
        # === 做空信号 (V3.4 优化 - 更容易触发) ===
        conditions_strong_short = []
        conditions_weak_short = []
        
        # 强做空信号 - 降低阈值，更容易触发
        conditions_strong_short.append(dataframe['daily_score'] <= 0)    # 放宽：< 0 → <= 0  
        conditions_strong_short.append(dataframe['h4_score'] <= 0)       # 放宽：< 0 → <= 0
        conditions_strong_short.append(dataframe['h1_score'] <= -self.strong_short_threshold)  # 降低：-3 → -2
        
        # 弱做空信号 - 大幅放宽条件
        if pair_weight >= 1.1:  # 高权重币种
            weak_threshold_short = 0      # 大幅放宽：-1 → 0
        elif pair_weight >= 0.8:  # 中等权重币种
            weak_threshold_short = -1     # 放宽：-2 → -1  
        else:  # 低权重币种
            weak_threshold_short = -2     # 放宽：-3 → -2
            
        weak_cond_1_short = (
            (dataframe['daily_score'] <= 0) &      # 保持放宽 
            (dataframe['h4_score'] <= 0) &         # 保持放宽
            (dataframe['h1_score'] <= weak_threshold_short) &
            (dataframe['signal_strength'] >= 2)    # 降低：3 → 2
        )
        
        # 下跌趋势市场中的做空机会 - 大幅放宽
        weak_cond_2_short = (
            (dataframe['is_trending']) &
            (dataframe['daily_score'] <= 0) &      # 放宽：< -1 → <= 0
            (dataframe['h1_score'] <= -self.weak_short_threshold) &  # 使用新阈值：0
            (dataframe['signal_strength'] >= 3)    # 降低：4 → 3
        )
        
        # V3.4 新增：RSI超买做空机会
        weak_cond_3_short = (
            (dataframe['rsi'] > 68) &               # RSI超买
            (dataframe['h1_score'] <= 0) &          # 1h转弱
            (dataframe['signal_strength'] >= 2) &   # 信号强度要求
            (dataframe['macdhist'] < 0)             # MACD转弱
        )
        
        conditions_weak_short.append(weak_cond_1_short)
        conditions_weak_short.append(weak_cond_2_short)
        conditions_weak_short.append(weak_cond_3_short)  # 新增条件
        
        # 做空通用过滤 - 放宽条件
        common_filters_short = []
        common_filters_short.append(dataframe['volume'] > 0)
        common_filters_short.append(dataframe['rsi'] > 35)     # 放宽：rsi_oversold(29) → 35
        common_filters_short.append(dataframe['volume_ratio'] > 0.6)  # 放宽：0.8 → 0.6
        
        # 币种权重调整过滤强度 - 放宽所有阈值
        if pair_weight >= 1.2:
            # 高权重币种 - 更宽松
            common_filters_short.append(dataframe['rsi'] > 30)  # 放宽：25 → 30
        elif pair_weight >= 0.8:
            # 中权重币种 - 标准但放宽
            common_filters_short.append(dataframe['rsi'] > 35)  # 放宽：29 → 35
        else:
            # 低权重币种 - 放宽
            common_filters_short.append(dataframe['rsi'] > 38)  # 放宽：32 → 38
        
        # === 执行做多信号 (新版语法) ===
        if conditions_strong_long and common_filters_long:
            strong_signal_long = reduce(lambda x, y: x & y, conditions_strong_long + common_filters_long)
            dataframe.loc[strong_signal_long, ['enter_long', 'enter_tag']] = (1, 'strong_long_v3_4')
        
        if conditions_weak_long and common_filters_long:
            weak_signal_long = reduce(lambda x, y: x | y, conditions_weak_long)
            weak_signal_long = weak_signal_long & reduce(lambda x, y: x & y, common_filters_long)
            
            # 避免覆盖强信号
            weak_signal_long = weak_signal_long & (dataframe['enter_long'] != 1)
            
            dataframe.loc[weak_signal_long, ['enter_long', 'enter_tag']] = (1, 'weak_long_v3_4')

        # === 执行做空信号 (新版语法) ===
        if conditions_strong_short and common_filters_short:
            strong_signal_short = reduce(lambda x, y: x & y, conditions_strong_short + common_filters_short)
            # 避免与做多信号冲突
            strong_signal_short = strong_signal_short & (dataframe['enter_long'] != 1)
            dataframe.loc[strong_signal_short, ['enter_short', 'enter_tag']] = (1, 'strong_short_v3_4')
        
        if conditions_weak_short and common_filters_short:
            weak_signal_short = reduce(lambda x, y: x | y, conditions_weak_short)
            weak_signal_short = weak_signal_short & reduce(lambda x, y: x & y, common_filters_short)
            
            # 避免与其他信号冲突
            weak_signal_short = weak_signal_short & (dataframe['enter_long'] != 1)
            weak_signal_short = weak_signal_short & (dataframe['enter_short'] != 1)
            
            dataframe.loc[weak_signal_short, ['enter_short', 'enter_tag']] = (1, 'weak_short_v3_4')

        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: Dict) -> DataFrame:
        """
        双向退出条件 - V3.4 新版语法
        """
        # 初始化新版FreqTrade出场列
        dataframe['exit_long'] = 0
        dataframe['exit_short'] = 0
        dataframe['exit_tag'] = ''
        
        # === 平多仓信号 (exit_long) ===
        conditions_strong_exit_long = []
        conditions_weak_exit_long = []
        
        # 强烈平多仓 - 原V2.1逻辑
        conditions_strong_exit_long.append(dataframe['daily_score'] < -1)
        conditions_strong_exit_long.append(dataframe['h4_score'] < -1)
        conditions_strong_exit_long.append(dataframe['h1_score'] <= -self.strong_signal_threshold)
        
        # 保护性平多仓
        weak_exit_cond_1_long = (
            (dataframe['signal_strength'] < 2) &
            (dataframe['h1_score'] <= 0) &
            (dataframe['rsi'] > 65)
        )
        
        weak_exit_cond_2_long = (
            (dataframe['rsi'] > self.rsi_overbought) &
            (dataframe['close'] > dataframe['bb_upper']) &
            (dataframe['macdhist'] < 0)
        )
        
        conditions_weak_exit_long.append(weak_exit_cond_1_long)
        conditions_weak_exit_long.append(weak_exit_cond_2_long)
        
        # === 平空仓信号 (exit_short) - V3.4 优化 ===
        conditions_strong_exit_short = []
        conditions_weak_exit_short = []
        
        # 强烈平空仓 - 放宽条件
        conditions_strong_exit_short.append(dataframe['daily_score'] > 0)       # 放宽：> 1 → > 0
        conditions_strong_exit_short.append(dataframe['h4_score'] > 0)         # 放宽：> 1 → > 0
        conditions_strong_exit_short.append(dataframe['h1_score'] >= self.strong_short_threshold)  # 使用做空阈值
        
        # 保护性平空仓
        weak_exit_cond_1_short = (
            (dataframe['signal_strength'] < 2) &
            (dataframe['h1_score'] >= 0) &  # 对称：1h转正
            (dataframe['rsi'] < 40)         # 放宽：< 35 → < 40
        )
        
        weak_exit_cond_2_short = (
            (dataframe['rsi'] < self.rsi_oversold) &     # 对称：RSI超卖
            (dataframe['close'] < dataframe['bb_lower']) &  # 对称：触及布林下轨
            (dataframe['macdhist'] > 0)                     # 对称：MACD转强
        )
        
        conditions_weak_exit_short.append(weak_exit_cond_1_short)
        conditions_weak_exit_short.append(weak_exit_cond_2_short)
        
        # 通用退出过滤
        common_filters_exit = []
        common_filters_exit.append(dataframe['volume'] > 0)
        
        # 执行平多仓信号
        common_filters_exit_long = common_filters_exit + [dataframe['rsi'] > self.rsi_oversold]
        
        if conditions_strong_exit_long and common_filters_exit_long:
            strong_exit_long = reduce(lambda x, y: x & y, conditions_strong_exit_long + common_filters_exit_long)
            dataframe.loc[strong_exit_long, ['exit_long', 'exit_tag']] = (1, 'strong_bearish_v3_4')
        
        if conditions_weak_exit_long and common_filters_exit_long:
            weak_exit_long = reduce(lambda x, y: x | y, conditions_weak_exit_long)
            weak_exit_long = weak_exit_long & reduce(lambda x, y: x & y, common_filters_exit_long)
            
            # 避免覆盖强信号
            weak_exit_long = weak_exit_long & (dataframe['exit_long'] != 1)
            
            dataframe.loc[weak_exit_long, ['exit_long', 'exit_tag']] = (1, 'protect_profit_long_v3_4')

        # 执行平空仓信号 - V3.4
        common_filters_exit_short = common_filters_exit + [dataframe['rsi'] < self.rsi_overbought]
        
        if conditions_strong_exit_short and common_filters_exit_short:
            strong_exit_short = reduce(lambda x, y: x & y, conditions_strong_exit_short + common_filters_exit_short)
            dataframe.loc[strong_exit_short, ['exit_short', 'exit_tag']] = (1, 'strong_bullish_v3_4')
        
        if conditions_weak_exit_short and common_filters_exit_short:
            weak_exit_short = reduce(lambda x, y: x | y, conditions_weak_exit_short)
            weak_exit_short = weak_exit_short & reduce(lambda x, y: x & y, common_filters_exit_short)
            
            # 避免覆盖强信号
            weak_exit_short = weak_exit_short & (dataframe['exit_short'] != 1)
            
            dataframe.loc[weak_exit_short, ['exit_short', 'exit_tag']] = (1, 'protect_profit_short_v3_4')

        return dataframe

    def custom_stoploss(self, pair: str, trade: 'Trade', current_time,
                       current_rate: float, current_profit: float, **kwargs) -> float:
        """基于表现的动态止损 - 支持双向交易"""
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        if len(dataframe) < 1:
            return self.stoploss
            
        last_candle = dataframe.iloc[-1]
        pair_weight = self.pair_weights.get(pair, 1.0)
        
        if 'atr' in last_candle:
            atr_value = last_candle['atr']
            
            # 根据币种表现调整止损 - 双向一致
            if pair_weight >= 1.3:      # 优秀币种 - 给更多空间
                atr_multiplier = 2.2
                max_loss = 0.06
            elif pair_weight >= 1.0:    # 标准币种
                atr_multiplier = 2.0
                max_loss = 0.05  
            else:                       # 表现差的币种 - 更紧止损
                atr_multiplier = 1.8
                max_loss = 0.045
            
            atr_stoploss = atr_multiplier * atr_value / current_rate
            
            return max(-max_loss, min(-0.02, -atr_stoploss))
        
        return self.stoploss

    def custom_exit(self, pair: str, trade: 'Trade', current_time, current_rate: float,
                   current_profit: float, **kwargs) -> 'Optional[Union[str, bool]]':
        """基于表现的动态止盈 - 支持双向交易"""
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        if len(dataframe) < 1:
            return None
            
        last_candle = dataframe.iloc[-1]
        signal_strength = last_candle.get('signal_strength', 5)
        pair_weight = self.pair_weights.get(pair, 1.0)
        
        # 基于币种表现调整止盈策略 - 双向一致
        if pair_weight >= 1.3:       # 优秀币种 - 更高目标
            first_target = 0.08
            second_target = 0.15
        elif pair_weight >= 1.0:     # 标准币种
            first_target = 0.06
            second_target = 0.12
        else:                        # 表现差的币种 - 快速止盈
            first_target = 0.04
            second_target = 0.08
        
        # 分批止盈 - 双向交易都适用
        if current_profit > first_target and not hasattr(trade, 'first_exit_done'):
            trade.first_exit_done = True
            direction = 'long' if trade.is_short == False else 'short'
            return f'first_target_{direction}_v3_4'
        
        if current_profit > second_target and not hasattr(trade, 'second_exit_done'):
            trade.second_exit_done = True
            direction = 'long' if trade.is_short == False else 'short'
            return f'second_target_{direction}_v3_4'
        
        # 信号恶化提前出场 - 双向交易都适用
        if signal_strength < 1.5 and current_profit > 0.015:
            direction = 'long' if trade.is_short == False else 'short'
            return f'signal_weak_{direction}_v3_4'
        
        return None

    def position_sizing(self, pair: str, current_time, current_rate: float, 
                       proposed_stake: float, min_stake: float, max_stake: float, 
                       side: str, **kwargs) -> float:
        """基于表现的仓位调整 - 支持双向交易"""
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        pair_weight = self.pair_weights.get(pair, 1.0)
        
        # 做空风险略高，仓位稍微减小
        direction_multiplier = 0.9 if side == 'short' else 1.0
        
        # 基础权重调整
        if len(dataframe) > 0:
            last_candle = dataframe.iloc[-1]
            signal_strength = last_candle.get('signal_strength', 5)
            
            # 信号强度调整
            if signal_strength >= 7:
                strength_multiplier = 1.2
            elif signal_strength >= 5:
                strength_multiplier = 1.0
            else:
                strength_multiplier = 0.8
        else:
            strength_multiplier = 1.0
        
        # 最终倍数
        final_multiplier = pair_weight * strength_multiplier * direction_multiplier
        
        # 限制倍数范围
        final_multiplier = max(0.5, min(final_multiplier, 1.5))
        
        final_stake = proposed_stake * final_multiplier
        return max(min_stake, min(final_stake, max_stake))
        
    def leverage(self, pair: str, current_time, current_rate: float,
                 proposed_leverage: float, max_leverage: float, side: str,
                 **kwargs) -> float:
        """基于表现的杠杆调整 - 支持双向交易"""
        pair_weight = self.pair_weights.get(pair, 1.0)
        
        # 基础杠杆根据币种表现
        if pair_weight >= 1.3:
            base_leverage = 4.0      # 优秀币种适中杠杆
        elif pair_weight >= 1.0:
            base_leverage = 3.0      
        else:
            base_leverage = 2.5      # 表现差的币种低杠杆
        
        # 做空风险略高，杠杆稍微降低
        direction_multiplier = 0.8 if side == 'short' else 1.0
        
        target_leverage = base_leverage * direction_multiplier
        
        return min(target_leverage, max_leverage)