import logging
import numpy as np
import datetime
import os
import json
import glob
from functools import reduce
from freqtrade.persistence import Trade
import talib.abstract as ta
from pandas import DataFrame
from typing import Dict
from freqtrade.strategy import (DecimalParameter, IStrategy, IntParameter)

logger = logging.getLogger(__name__)

class FreqaiPrimer(IStrategy):
    """
    基于 FreqAI 的动态阈值交易策略，集成动态加仓和减仓逻辑，兼容最新 Freqtrade 版本
    """

    # --- 🧪 Hyperopt Parameters ---
    ROI_T0 = DecimalParameter(0.01, 0.05, default=0.02, space='roi', optimize=True)
    ROI_T1 = DecimalParameter(0.005, 0.02, default=0.01, space='roi', optimize=True)
    ROI_T2 = DecimalParameter(0.0, 0.01, default=0.0, space='roi', optimize=True)

    TRAILING_STOP_START = DecimalParameter(0.01, 0.05, default=0.03, space='sell', optimize=True)
    TRAILING_STOP_DISTANCE = DecimalParameter(0.005, 0.02, default=0.01, space='sell', optimize=True)

    BUY_THRESHOLD_MIN = DecimalParameter(-0.1, -0.01, default=-0.05, space='buy', optimize=True)
    BUY_THRESHOLD_MAX = DecimalParameter(-0.02, -0.001, default=-0.005, space='buy', optimize=True)
    SELL_THRESHOLD_MIN = DecimalParameter(0.001, 0.02, default=0.005, space='sell', optimize=True)
    SELL_THRESHOLD_MAX = DecimalParameter(0.02, 0.1, default=0.05, space='sell', optimize=True)

    # 新增：加仓和减仓参数
    ADD_POSITION_THRESHOLD = DecimalParameter(-0.05, -0.01, default=-0.02, space='buy', optimize=True)
    EXIT_POSITION_RATIO = DecimalParameter(0.2, 0.7, default=0.5, space='sell', optimize=True)
    COOLDOWN_PERIOD_MINUTES = IntParameter(1, 10, default=5, space='buy', optimize=True)
    MAX_ENTRY_POSITION_ADJUSTMENT = IntParameter(1, 3, default=2, space='buy', optimize=True)

    # --- 🛠️ 固定配置参数 ---
    minimal_roi = {
        "0": ROI_T0.value,
        "30": ROI_T1.value,
        "60": ROI_T2.value
    }

    stoploss = -0.015
    timeframe = "3m"
    use_custom_stoploss = True
    position_adjustment_enable = True  # 启用动态仓位调整

    plot_config = {
        "main_plot": {
            "ema200": {"color": "blue"},
            "bb_upperband": {"color": "gray"},
            "bb_lowerband": {"color": "gray"},
            "bb_middleband": {"color": "gray"}
        },
        "subplots": {
            "Signals": {
                "enter_long": {"color": "green"},
                "exit_long": {"color": "red"}
            },
            "Price-Value Divergence": {
                "&-price_value_divergence": {"color": "purple"}
            },
            "Volume Z-Score": {
                "volume_z_score": {"color": "orange"}
            },
            "RSI": {
                "rsi": {"color": "cyan"}
            }
        }
    }

    freqai_info = {
        "identifier": "test58",
        "model": "LightGBMRegressor",
        "feature_parameters": {
            "include_timeframes": ["3m", "15m", "1h"],
            "label_period_candles": 12,
            "include_shifted_candles": 3,
        },
        "data_split_parameters": {
            "test_size": 0.2,
            "shuffle": False,
        },
        "model_training_parameters": {
            "n_estimators": 200,
            "learning_rate": 0.05,
            "num_leaves": 31,
            "verbose": -1,
        },
        "fit_live_predictions_candles": 100,
        "live_retrain_candles": 100,
    }

    def __init__(self, config: dict, *args, **kwargs):
        super().__init__(config, *args, **kwargs)
        logger.setLevel(logging.DEBUG)
        logger.debug("✅ 策略已初始化，日志级别设置为 DEBUG")
        self.trailing_stop_enabled = False
        self.pair_stats = {}
        self.stats_logged = False
        self.fit_live_predictions_candles = self.freqai_info.get("fit_live_predictions_candles", 100)
        self.last_entry_time = {}  # 记录每个币种的最后入场时间
        self.indicator_cache = {}  # 缓存技术指标用于日志记录

        # 设置交易专用日志
        trade_log_handler = logging.FileHandler("trade_log.jsonl")
        trade_log_handler.setFormatter(logging.Formatter("%(asctime)s - %(message)s"))
        self.trade_logger = logging.getLogger("trade_logger")
        self.trade_logger.setLevel(logging.INFO)
        self.trade_logger.addHandler(trade_log_handler)

    def feature_engineering_expand_all(self, dataframe: DataFrame, period: int, metadata: dict, **kwargs) -> DataFrame:
        dataframe["%-rsi-period"] = ta.RSI(dataframe, timeperiod=period)
        dataframe["%-sma-period"] = ta.SMA(dataframe, timeperiod=period)
        dataframe["%-ema-period"] = ta.EMA(dataframe, timeperiod=period)

        real = ta.TYPPRICE(dataframe)
        upperband, middleband, lowerband = ta.BBANDS(real, timeperiod=period, nbdevup=2.0, nbdevdn=2.0)
        dataframe["bb_lowerband-period"] = lowerband
        dataframe["bb_upperband-period"] = upperband
        dataframe["bb_middleband-period"] = middleband
        dataframe["%-bb_width-period"] = (dataframe["bb_upperband-period"] - dataframe["bb_lowerband-period"]) / dataframe["bb_middleband-period"]

        dataframe["%-mfi-period"] = ta.MFI(dataframe, timeperiod=period)
        dataframe["%-adx-period"] = ta.ADX(dataframe, timeperiod=period)
        dataframe["%-relative_volume-period"] = dataframe["volume"] / dataframe["volume"].rolling(period).mean()

        dataframe["ema200"] = ta.EMA(dataframe, timeperiod=200)
        dataframe["%-price_value_divergence"] = (dataframe["close"] - dataframe["ema200"]) / dataframe["ema200"]

        columns_to_clean = [
            "%-rsi-period", "%-mfi-period", "%-sma-period", "%-ema-period", "%-adx-period",
            "bb_lowerband-period", "bb_middleband-period", "bb_upperband-period",
            "%-bb_width-period", "%-relative_volume-period", "%-price_value_divergence"
        ]
        for col in columns_to_clean:
            dataframe[col] = dataframe[col].replace([np.inf, -np.inf], 0).ffill().fillna(0)

        pair = metadata.get('pair', 'Unknown')
        logger.debug(f"[{pair}] 特征工程完成，列：{list(dataframe.columns)}")
        return dataframe

    def set_freqai_targets(self, dataframe: DataFrame, metadata: dict, **kwargs) -> DataFrame:
        pair = metadata.get('pair', 'Unknown')
        if len(dataframe) < 200:
            logger.warning(f"[{pair}] 数据量不足（{len(dataframe)}根K线），需要至少200根K线进行训练")
            return dataframe

        dataframe["ema200"] = ta.EMA(dataframe, timeperiod=200)
        dataframe["&-price_value_divergence"] = (dataframe["close"] - dataframe["ema200"]) / dataframe["ema200"]

        dataframe["volume_mean_20"] = dataframe["volume"].rolling(20).mean()
        dataframe["volume_std_20"] = dataframe["volume"].rolling(20).std()
        dataframe["volume_z_score"] = (dataframe["volume"] - dataframe["volume_mean_20"]) / dataframe["volume_std_20"]

        dataframe["&-price_value_divergence"] = dataframe["&-price_value_divergence"].replace([np.inf, -np.inf], 0).ffill().fillna(0)
        dataframe["volume_z_score"] = dataframe["volume_z_score"].replace([np.inf, -np.inf], 0).ffill().fillna(0)

        return dataframe

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        pair = metadata.get('pair', 'Unknown')
        logger.info(f"[{pair}] 当前可用列（调用FreqAI前）：{list(dataframe.columns)}")

        # 计算200周期EMA和历史价值背离
        dataframe["ema200"] = ta.EMA(dataframe, timeperiod=200)
        dataframe["price_value_divergence"] = (dataframe["close"] - dataframe["ema200"]) / dataframe["ema200"]

        # 调用FreqAI预测价值背离
        if not hasattr(self, 'freqai') or self.freqai is None:
            logger.error(f"[{pair}] FreqAI 未初始化，请确保回测命令中启用了 --freqai")
            dataframe["&-price_value_divergence"] = dataframe["price_value_divergence"]
        else:
            logger.debug(f"self.freqai 类型：{type(self.freqai)}")
            dataframe = self.freqai.start(dataframe, metadata, self)

            if "&-price_value_divergence" not in dataframe.columns:
                logger.warning(f"[{pair}] 回归模型未生成 &-price_value_divergence，回退到规则计算")
                dataframe["&-price_value_divergence"] = dataframe["price_value_divergence"]

        # 计算其他指标
        upperband, middleband, lowerband = ta.BBANDS(dataframe["close"], timeperiod=20, nbdevup=2.0, nbdevdn=2.0)
        dataframe["bb_upperband"] = upperband
        dataframe["bb_middleband"] = middleband
        dataframe["bb_lowerband"] = lowerband
        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=14)
        dataframe["volume_mean_20"] = dataframe["volume"].rolling(20).mean()
        dataframe["volume_std_20"] = dataframe["volume"].rolling(20).std()
        dataframe["volume_z_score"] = (dataframe["volume"] - dataframe["volume_mean_20"]) / dataframe["volume_std_20"]

        # 数据清理
        for col in ["ema200", "bb_upperband", "bb_middleband", "bb_lowerband", "rsi", "volume_z_score", "&-price_value_divergence", "price_value_divergence"]:
            dataframe[col] = dataframe[col].replace([np.inf, -np.inf], 0).ffill().fillna(0)

        # 添加调试日志
        logger.debug(f"[{pair}] 最新数据 - close：{dataframe['close'].iloc[-1]:.6f}, "
                     f"rsi：{dataframe['rsi'].iloc[-1]:.2f}, "
                     f"&-price_value_divergence：{dataframe['&-price_value_divergence'].iloc[-1]:.6f}, "
                     f"volume_z_score：{dataframe['volume_z_score'].iloc[-1]:.2f}, "
                     f"bb_lowerband：{dataframe['bb_lowerband'].iloc[-1]:.6f}")

        # 获取 labels_mean 和 labels_std
        labels_mean = None
        labels_std = None

        try:
            model_base_dir = os.path.join(self.config["user_data_dir"], "models", self.freqai_info["identifier"])
            pair_base = pair.split('/')[0] if '/' in pair else pair
            sub_dirs = glob.glob(os.path.join(model_base_dir, f"sub-train-{pair_base}_*"))

            if not sub_dirs:
                logger.warning(f"[{pair}] 未找到任何子目录：{model_base_dir}/sub-train-{pair_base}_*")
            else:
                latest_sub_dir = max(sub_dirs, key=lambda x: int(x.split('_')[-1]))
                pair_base_lower = pair_base.lower()
                timestamp = latest_sub_dir.split('_')[-1]
                metadata_file = os.path.join(latest_sub_dir, f"cb_{pair_base_lower}_{timestamp}_metadata.json")

                if os.path.exists(metadata_file):
                    with open(metadata_file, "r") as f:
                        metadata = json.load(f)
                        labels_mean = metadata["labels_mean"]["&-price_value_divergence"]
                        labels_std = metadata["labels_std"]["&-price_value_divergence"]
                        logger.info(f"[{pair}] 从最新子目录 {latest_sub_dir} 读取 labels_mean：{labels_mean}, labels_std：{labels_std}")
                else:
                    logger.warning(f"[{pair}] 最新的 metadata.json 文件 {metadata_file} 不存在")
        except Exception as e:
            logger.warning(f"[{pair}] 无法从子目录读取 labels_mean 和 labels_std：{e}，重新计算")

        if labels_mean is None or labels_std is None:
            logger.warning(f"[{pair}] 无法获取 labels_mean 和 labels_std，重新计算")
            dataframe["&-price_value_divergence_actual"] = (dataframe["close"] - dataframe["ema200"]) / dataframe["ema200"]
            dataframe["&-price_value_divergence_actual"] = dataframe["&-price_value_divergence_actual"].replace([np.inf, -np.inf], 0).ffill().fillna(0)
            recent_data = dataframe["&-price_value_divergence_actual"].tail(self.fit_live_predictions_candles)
            labels_mean = recent_data.mean()
            labels_std = recent_data.std()
            if np.isnan(labels_std) or labels_std == 0:
                labels_std = 0.01
                logger.warning(f"[{pair}] labels_std 计算异常，使用默认值 0.01")

        # 根据市场趋势动态调整买卖阈值
        market_trend = self.get_market_trend()
        k_buy = 1.0
        k_sell = 1.2
        if market_trend == 'bull':
            k_buy = 0.8  # 放宽买入阈值
            k_sell = 1.0  # 收紧卖出阈值
        elif market_trend == 'bear':
            k_buy = 1.2  # 收紧买入阈值
            k_sell = 1.5  # 放宽卖出阈值
        else:
            k_buy = 1.0
            k_sell = 1.2

        if labels_mean > 0.015:
            k_sell += 0.5

        self.buy_threshold = labels_mean - k_buy * labels_std
        self.sell_threshold = labels_mean + k_sell * labels_std

        # 使用 Hyperopt 参数限制阈值
        self.buy_threshold = max(self.buy_threshold, self.BUY_THRESHOLD_MIN.value)
        self.buy_threshold = min(self.buy_threshold, self.BUY_THRESHOLD_MAX.value)
        self.sell_threshold = min(self.sell_threshold, self.SELL_THRESHOLD_MAX.value)
        self.sell_threshold = max(self.sell_threshold, self.SELL_THRESHOLD_MIN.value)

        logger.info(f"[{pair}] 市场趋势：{market_trend}, labels_mean：{labels_mean:.4f}, labels_std：{labels_std:.4f}")
        logger.info(f"[{pair}] k_buy：{k_buy:.2f}, k_sell：{k_sell:.2f}")
        logger.info(f"[{pair}] 动态买入阈值：{self.buy_threshold:.4f}, 卖出阈值：{self.sell_threshold:.4f}")

        if not self.stats_logged:
            logger.info("===== 所有币对的 labels_mean 和 labels_std 汇总 =====")
            for p, stats in self.pair_stats.items():
                logger.info(f"[{p}] labels_mean：{stats['labels_mean']:.4f}, labels_std：{stats['labels_std']:.4f}")
            logger.info("==============================================")
            self.stats_logged = True

        return dataframe

    def generate_roi_table(self, params: Dict) -> Dict[int, float]:
        roi_table = {
            "0": params.get("roi_t0", self.ROI_T0.value),
            "30": params.get("roi_t1", self.ROI_T1.value),
            "60": params.get("roi_t2", self.ROI_T2.value),
        }
        return roi_table

    def roi_space(self):
        return [
            DecimalParameter(0.01, 0.05, name="roi_t0"),
            DecimalParameter(0.005, 0.02, name="roi_t1"),
            DecimalParameter(0.0, 0.01, name="roi_t2")
        ]

    def trailing_space(self):
        return [
            DecimalParameter(0.01, 0.05, name="trailing_stop_start"),
            DecimalParameter(0.005, 0.02, name="trailing_stop_distance")
        ]

    def leverage_space(self):
        return [
            DecimalParameter(-0.05, -0.01, name="add_position_threshold", default=-0.02),
            DecimalParameter(0.2, 0.7, name="exit_position_ratio", default=0.5),
            IntParameter(1, 10, name="cooldown_period_minutes", default=5),
            IntParameter(1, 3, name="max_entry_position_adjustment", default=2)
        ]

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        pair = metadata.get('pair', 'Unknown')
        conditions = []

        if "&-price_value_divergence" in dataframe.columns:
            cond1 = (dataframe["&-price_value_divergence"] < self.buy_threshold)
            cond2 = (dataframe["volume_z_score"] > 1.5)
            cond3 = (dataframe["rsi"] < 40)
            cond4 = (dataframe["close"] <= dataframe["bb_lowerband"])
            buy_condition = cond1 & cond2 & cond3 & cond4
            conditions.append(buy_condition)

            logger.debug(f"[{pair}] 买入条件检查 - "
                         f"&-price_value_divergence < {self.buy_threshold:.6f}: {cond1.iloc[-1]}, "
                         f"volume_z_score > 1.5: {cond2.iloc[-1]}, "
                         f"rsi < 40: {cond3.iloc[-1]}, "
                         f"close <= bb_lowerband: {cond4.iloc[-1]}")
        else:
            logger.warning(f"[{pair}] ⚠️ &-price_value_divergence 列缺失，跳过该条件")

        if len(conditions) > 0:
            combined_condition = reduce(lambda x, y: x & y, conditions)
            if combined_condition.any():
                dataframe.loc[combined_condition, 'enter_long'] = 1
                # 缓存指标用于交易日志
                self.indicator_cache[pair] = {
                    "rsi": dataframe["rsi"].iloc[-1],
                    "volume_z_score": dataframe["volume_z_score"].iloc[-1],
                    "&-price_value_divergence": dataframe["&-price_value_divergence"].iloc[-1],
                    "bb_lowerband": dataframe["bb_lowerband"].iloc[-1]
                }
                logger.debug(f"[{pair}] 入场信号触发，条件满足")
            else:
                logger.debug(f"[{pair}] 买入条件均不满足，未触发入场信号")
        else:
            logger.debug(f"[{pair}] 无有效买入条件")

        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        pair = metadata.get('pair', 'Unknown')
        conditions = []

        if "&-price_value_divergence" in dataframe.columns:
            cond1 = (dataframe["&-price_value_divergence"] > self.sell_threshold)
            cond2 = (dataframe["rsi"] > 75)
            sell_condition = cond1 | cond2
            conditions.append(sell_condition)

            logger.debug(f"[{pair}] 卖出条件检查 - "
                         f"&-price_value_divergence > {self.sell_threshold:.6f}: {cond1.iloc[-1]}, "
                         f"rsi > 75: {cond2.iloc[-1]}")
        else:
            logger.warning(f"[{pair}] ⚠️ &-price_value_divergence 列缺失，跳过该条件")

        if len(conditions) > 0:
            combined_condition = reduce(lambda x, y: x & y, conditions)
            if combined_condition.any():
                dataframe.loc[combined_condition, 'exit_long'] = 1
                # 缓存指标用于交易日志
                self.indicator_cache[pair] = {
                    "rsi": dataframe["rsi"].iloc[-1],
                    "volume_z_score": dataframe["volume_z_score"].iloc[-1],
                    "&-price_value_divergence": dataframe["&-price_value_divergence"].iloc[-1],
                    "bb_upperband": dataframe["bb_upperband"].iloc[-1]
                }
                logger.debug(f"[{pair}] 出场信号触发，条件满足")
            else:
                logger.debug(f"[{pair}] 卖出条件均不满足，未触发出场信号")
        else:
            logger.debug(f"[{pair}] 无有效卖出条件")

        return dataframe

    def buy_space(self):
        return [
            DecimalParameter(-0.1, -0.01, name="buy_threshold_min"),
            DecimalParameter(-0.02, -0.001, name="buy_threshold_max"),
            DecimalParameter(-0.05, -0.01, name="add_position_threshold", default=-0.02),
            IntParameter(1, 10, name="cooldown_period_minutes", default=5),
            IntParameter(1, 3, name="max_entry_position_adjustment", default=2)
        ]

    def sell_space(self):
        return [
            DecimalParameter(0.001, 0.02, name="sell_threshold_min"),
            DecimalParameter(0.02, 0.1, name="sell_threshold_max"),
            DecimalParameter(0.2, 0.7, name="exit_position_ratio", default=0.5)
        ]

    def adjust_trade_position(self, trade: Trade, current_time: datetime,
                            current_rate: float, current_profit: float,
                            min_stake: float | None, max_stake: float,
                            current_entry_rate: float, current_exit_rate: float,
                            current_entry_profit: float, current_exit_profit: float,
                            **kwargs) -> float | None | tuple[float | None, str | None]:
        """
        动态调整仓位：支持加仓和分批减仓
        参数：
            trade: 当前交易对象
            current_time: 当前时间
            current_rate: 当前市场价格
            current_profit: 当前未实现利润百分比
            min_stake: 最小下单金额（可能为 None）
            max_stake: 最大可用下单金额
            current_entry_rate: 当前入场价格
            current_exit_rate: 当前退出价格
            current_entry_profit: 当前入场利润百分比
            current_exit_profit: 当前退出利润百分比
        返回值：
            - 正数（float）：加仓金额（报价货币，例如 USDT）
            - 负数（float）：减仓金额（例如 -30.0 表示卖出 30 USDT）
            - None：不调整仓位
            - tuple[float | None, str | None]：(调整金额, 调整原因)
        """
        pair = trade.pair
        hold_time = (current_time - trade.open_date_utc).total_seconds() / 60
        market_trend = self.get_market_trend()
        profit_ratio = (current_rate - trade.open_rate) / trade.open_rate

        # --- 加仓逻辑 ---
        max_entry_adjustments = self.MAX_ENTRY_POSITION_ADJUSTMENT.value
        if trade.nr_of_successful_entries <= max_entry_adjustments + 1:  # +1 包括初始入场
            add_position_threshold = self.ADD_POSITION_THRESHOLD.value
            if profit_ratio <= add_position_threshold and hold_time > 5:
                if market_trend in ['bear', 'sideways']:  # 熊市或震荡市更倾向加仓
                    add_amount = 0.5 * trade.stake_amount  # 加仓 50% 的初始仓位
                    if min_stake is not None and add_amount < min_stake:
                        logger.warning(f"[{pair}] 加仓金额 {add_amount:.2f} 低于最小下单金额 {min_stake}，取消加仓")
                        return (None, "Add amount below min_stake")
                    if add_amount > max_stake:
                        logger.warning(f"[{pair}] 加仓金额 {add_amount:.2f} 超出最大可用金额 {max_stake}，取消加仓")
                        return (None, "Add amount exceeds max_stake")
                    logger.info(f"[{pair}] 价格下跌 {profit_ratio*100:.2f}%，触发加仓 {add_amount:.2f}")
                    return (add_amount, f"Price dropped {profit_ratio*100:.2f}%")
                else:
                    logger.debug(f"[{pair}] 价格下跌但市场趋势为 {market_trend}，不加仓")
                    return None

        # --- 减仓逻辑 ---
        exit_position_ratio = self.EXIT_POSITION_RATIO.value
        if profit_ratio >= 0.03:  # 利润达到 3%
            if market_trend == 'bull':
                reduce_amount = -exit_position_ratio * 0.6 * trade.stake_amount  # 牛市减仓较少
                logger.info(f"[{pair}] 牛市，利润 {profit_ratio*100:.2f}%，减仓 {abs(reduce_amount):.2f}")
                return (reduce_amount, f"Bull market, profit {profit_ratio*100:.2f}%")
            else:
                reduce_amount = -exit_position_ratio * trade.stake_amount  # 其他市场减仓较多
                logger.info(f"[{pair}] 利润 {profit_ratio*100:.2f}%，减仓 {abs(reduce_amount):.2f}")
                return (reduce_amount, f"Profit {profit_ratio*100:.2f}%")
        elif profit_ratio >= 0.05:  # 利润达到 5%
            reduce_amount = -exit_position_ratio * 1.4 * trade.stake_amount  # 卖出更多
            logger.info(f"[{pair}] 利润 {profit_ratio*100:.2f}%，减仓 {abs(reduce_amount):.2f}")
            return (reduce_amount, f"Profit {profit_ratio*100:.2f}%")

        # --- 追踪止损逻辑 ---
        trailing_stop_start = self.TRAILING_STOP_START.value
        trailing_stop_distance = self.TRAILING_STOP_DISTANCE.value
        if market_trend == 'bull':
            trailing_stop_distance *= 1.5  # 牛市放宽追踪止损
            trailing_stop_start *= 1.2
        elif market_trend == 'bear':
            trailing_stop_distance *= 0.7  # 熊市收紧追踪止损
            trailing_stop_start *= 0.8

        if profit_ratio >= trailing_stop_start and not self.trailing_stop_enabled:
            self.trailing_stop_enabled = True
            trade.adjust_min_max_rates(current_rate, current_rate)  # 初始化最高和最低价格
            logger.info(f"[{pair}] 价格上涨超过 {trailing_stop_start*100:.1f}%，启动 Trailing Stop")
            return None

        if self.trailing_stop_enabled:
            max_rate = trade.max_rate
            trailing_stop_price = max_rate * (1 - trailing_stop_distance)
            if current_rate < trailing_stop_price:
                logger.info(f"[{pair}] 价格回落至 Trailing Stop 点 {trailing_stop_price:.6f}，触发全部卖出")
                return (-trade.stake_amount, f"Trailing stop at {trailing_stop_price:.6f}")
            trade.adjust_min_max_rates(current_rate, trade.min_rate)  # 更新最高价格
            return None

        # --- 最大持仓时间限制 ---
        if hold_time > 30:
            logger.info(f"[{pair}] 持仓时间超过30分钟，强制清仓")
            return (-trade.stake_amount, "Max hold time exceeded")

        return None

    def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float,
                            time_in_force: str, current_time: datetime, **kwargs) -> bool:
        """
        确认交易进入时的逻辑，并记录详细日志
        """
        market_trend = self.get_market_trend()
        cooldown_period_minutes = self.COOLDOWN_PERIOD_MINUTES.value if market_trend == 'bull' else self.COOLDOWN_PERIOD_MINUTES.value // 2

        # 检查冷却期
        if pair in self.last_entry_time:
            last_time = self.last_entry_time[pair]
            if (current_time - last_time).total_seconds() < cooldown_period_minutes * 60:
                logger.info(f"[{pair}] 冷却期内（{cooldown_period_minutes} 分钟），跳过本次入场")
                return False

        # 记录进入交易的详细信息
        entry_log = {
            "pair": pair,
            "order_type": order_type,
            "amount": amount,
            "rate": rate,
            "total_value": amount * rate,
            "time_in_force": time_in_force,
            "timestamp": current_time.isoformat(),
            "market_trend": market_trend,
            "cooldown_period_minutes": cooldown_period_minutes,
            "buy_threshold": self.buy_threshold,
            "indicators": self.indicator_cache.get(pair, {
                "rsi": "N/A",
                "volume_z_score": "N/A",
                "&-price_value_divergence": "N/A",
                "bb_lowerband": "N/A"
            })
        }
        logger.info(f"[{pair}] 交易进入确认: {json.dumps(entry_log, indent=2)}")
        self.trade_logger.info(json.dumps(entry_log))

        # 更新最后入场时间并重置追踪止损
        self.last_entry_time[pair] = current_time
        self.trailing_stop_enabled = False
        return True

    def confirm_trade_exit(self, pair: str, trade: Trade, order_type: str, amount: float,
                        rate: float, time_in_force: str, exit_reason: str,
                        current_time: datetime, **kwargs) -> bool:
        """
        确认交易退出时的逻辑，并记录详细日志
        """
        adjusted_rate = rate * (1 + 0.0025)
        profit_ratio = trade.calc_profit_ratio(rate)
        profit_amount = trade.calc_profit(rate)
        hold_time_minutes = (current_time - trade.open_date_utc).total_seconds() / 60

        # 记录退出交易的详细信息
        exit_log = {
            "pair": pair,
            "order_type": order_type,
            "amount": amount,
            "rate": rate,
            "adjusted_rate": adjusted_rate,
            "total_value": amount * rate,
            "time_in_force": time_in_force,
            "timestamp": current_time.isoformat(),
            "exit_reason": exit_reason,
            "profit_ratio": profit_ratio,
            "profit_amount": profit_amount,
            "hold_time_minutes": hold_time_minutes,
            "market_trend": self.get_market_trend(),
            "sell_threshold": self.sell_threshold,
            "indicators": self.indicator_cache.get(pair, {
                "rsi": "N/A",
                "volume_z_score": "N/A",
                "&-price_value_divergence": "N/A",
                "bb_upperband": "N/A"
            }),
            "trade_details": {
                "open_rate": trade.open_rate,
                "open_date": trade.open_date_utc.isoformat(),
                "stake_amount": trade.stake_amount,
                "nr_of_successful_entries": trade.nr_of_successful_entries
            }
        }
        logger.info(f"[{pair}] 交易退出确认: {json.dumps(exit_log, indent=2)}")
        self.trade_logger.info(json.dumps(exit_log))

        return True

    def custom_entry_price(self, pair: str, trade: Trade | None, current_time: datetime, proposed_rate: float,
                        entry_tag: str | None, side: str, **kwargs) -> float:
        adjusted_rate = proposed_rate * (1 - 0.005)
        logger.debug(f"[{pair}] 自定义买入价：{adjusted_rate:.6f}（原价：{proposed_rate:.6f}）")
        return adjusted_rate

    def custom_exit_price(self, pair: str, trade: Trade,
                        current_time: datetime, proposed_rate: float,
                        current_profit: float, exit_tag: str | None, **kwargs) -> float:
        adjusted_rate = proposed_rate * (1 + 0.0025)
        logger.debug(f"[{pair}] 自定义卖出价：{adjusted_rate:.6f}（原价：{proposed_rate:.6f}）")
        return adjusted_rate

    def get_market_trend(self, dataframe: DataFrame = None, metadata: dict = None) -> str:
        """
        判断市场趋势：bull（牛市）、bear（熊市）、sideways（震荡市）
        基于多时间框架的EMA、K线形态和量价关系
        """
        try:
            timeframes = ["3m", "15m", "1h"]
            weights = {"3m": 0.5, "15m": 0.3, "1h": 0.2}
            trend_scores = {}

            pair = metadata.get('pair', 'Unknown') if metadata else 'Unknown'
            logger.debug(f"[{pair}] 正在计算多时间框架市场趋势")

            for tf in timeframes:
                if tf == "3m" and dataframe is not None:
                    btc_df = dataframe
                else:
                    btc_df = self.dp.get_pair_dataframe("BTC/USDT", tf)

                min_candles = 200 if tf == "3m" else 100 if tf == "15m" else 50
                if len(btc_df) < min_candles:
                    logger.warning(f"[{pair}] BTC 数据不足（{tf}，{len(btc_df)} 根K线），默认震荡市")
                    trend_scores[tf] = 50
                    continue

                # 计算EMA
                btc_df["ema_short"] = ta.EMA(btc_df, timeperiod=50 if tf == "3m" else 20 if tf == "15m" else 12)
                btc_df["ema_long"] = ta.EMA(btc_df, timeperiod=200 if tf == "3m" else 80 if tf == "15m" else 50)
                btc_df["ema_short_slope"] = (btc_df["ema_short"] - btc_df["ema_short"].shift(10)) / btc_df["ema_short"].shift(10)

                # 价格趋势得分
                price_score = 0
                if btc_df["close"].iloc[-1] > btc_df["ema_long"].iloc[-1]:
                    price_score += 20
                if btc_df["ema_short"].iloc[-1] > btc_df["ema_long"].iloc[-1]:
                    price_score += 20
                if btc_df["ema_short_slope"].iloc[-1] > 0.005:
                    price_score += 15
                elif btc_df["ema_short_slope"].iloc[-1] < -0.005:
                    price_score -= 15

                # K线形态得分
                btc_df["bullish_engulfing"] = (
                    (btc_df["close"].shift(1) < btc_df["open"].shift(1)) &
                    (btc_df["close"] > btc_df["open"]) &
                    (btc_df["close"] > btc_df["open"].shift(1)) &
                    (btc_df["open"] < btc_df["close"].shift(1))
                )
                btc_df["bearish_engulfing"] = (
                    (btc_df["close"].shift(1) > btc_df["open"].shift(1)) &
                    (btc_df["close"] < btc_df["open"]) &
                    (btc_df["close"] < btc_df["open"].shift(1)) &
                    (btc_df["open"] > btc_df["close"].shift(1))
                )
                kline_score = 0
                if btc_df["bullish_engulfing"].iloc[-1]:
                    kline_score += 15
                elif btc_df["bearish_engulfing"].iloc[-1]:
                    kline_score -= 15
                volatility = btc_df["close"].pct_change(10).std() * 100
                if volatility > 0.5:
                    kline_score += 10 if price_score > 0 else -10

                # StochRSI得分
                stochrsi = ta.STOCHRSI(btc_df, timeperiod=14, fastk_period=3, fastd_period=3)
                btc_df["stochrsi_k"] = stochrsi["fastk"]
                btc_df["stochrsi_d"] = stochrsi["fastd"]
                stochrsi_score = 0
                if btc_df["stochrsi_k"].iloc[-1] > 80 and btc_df["stochrsi_k"].iloc[-1] < btc_df["stochrsi_d"].iloc[-1]:
                    stochrsi_score -= 15
                elif btc_df["stochrsi_k"].iloc[-1] < 20 and btc_df["stochrsi_k"].iloc[-1] > btc_df["stochrsi_d"].iloc[-1]:
                    stochrsi_score += 15
                elif btc_df["stochrsi_k"].iloc[-1] > 50:
                    stochrsi_score += 5
                elif btc_df["stochrsi_k"].iloc[-1] < 50:
                    stochrsi_score -= 5

                # 量价关系得分
                btc_df["volume_mean_20"] = btc_df["volume"].rolling(20).mean()
                btc_df["volume_std_20"] = btc_df["volume"].rolling(20).std()
                btc_df["volume_z_score"] = (btc_df["volume"] - btc_df["volume_mean_20"]) / btc_df["volume_std_20"]
                btc_df["adx"] = ta.ADX(btc_df, timeperiod=14)
                volume_score = 0
                if btc_df["volume_z_score"].iloc[-1] > 1.5:
                    volume_score += 10 if price_score > 0 else -10
                if btc_df["adx"].iloc[-1] > 25:
                    volume_score += 10 if price_score > 0 else -10

                # 综合得分
                raw_score = price_score + kline_score + stochrsi_score + volume_score
                raw_score = max(min(raw_score, 50), -50)
                if raw_score >= 0:
                    mapped_score = 50 + 50 * (np.log1p(raw_score / 50) / np.log1p(1))
                else:
                    mapped_score = 50 * (np.log1p(-raw_score / 50) / np.log1p(1))
                trend_scores[tf] = max(0, min(100, int(round(mapped_score))))
                logger.debug(f"[{pair}] {tf} 趋势得分：{trend_scores[tf]}, "
                            f"原始得分：{raw_score}, 价格得分：{price_score}, "
                            f"K线得分：{kline_score}, StochRSI得分：{stochrsi_score}, "
                            f"量价得分：{volume_score}")

            # 加权融合
            final_score = sum(trend_scores[tf] * weights[tf] for tf in timeframes)
            final_score = max(0, min(100, int(round(final_score))))
            logger.info(f"[{pair}] 最终趋势得分：{final_score}, "
                        f"3m得分：{trend_scores.get('3m', 50)}, "
                        f"15m得分：{trend_scores.get('15m', 50)}, "
                        f"1h得分：{trend_scores.get('1h', 50)}")

            # 映射到趋势类别
            if final_score >= 70:
                return 'bull'
            elif final_score <= 30:
                return 'bear'
            else:
                return 'sideways'

        except Exception as e:
            logger.error(f"[{pair}] 获取市场趋势失败：{e}", exc_info=True)
            return 'sideways'