# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
# flake8: noqa: F401
# isort: skip_file
# --- Do not remove这些 imports ---
import numpy as np
import pandas as pd
from datetime import datetime, timedelta, timezone
from pandas import DataFrame
from typing import Dict, Optional, Union, Tuple

from freqtrade.strategy import (
    IStrategy,
    Trade,
    Order,
    PairLocks,
    informative,  # @informative decorator
    # Hyperopt Parameters
    BooleanParameter,
    CategoricalParameter,
    DecimalParameter,
    IntParameter,
    RealParameter,
    # timeframe helpers
    timeframe_to_minutes,
    timeframe_to_next_date,
    timeframe_to_prev_date,
    timeframe_to_seconds,
    timeframe_to_msecs,
)

import talib.abstract as ta
import freqtrade.vendor.qtpylib.indicators as qtpylib


class AdvancedMAVolumeStrategy(IStrategy):
    """
    高级均线金叉 + 成交量放大策略
    
    核心优化功能：
    1. 趋势确认指标 - MA斜率、ADX>20，避免震荡区间频繁进场
    2. ATR动态止损 - 波动大给宽止损，波动小收紧止损
    3. 分批止损机制 - 先减仓，再全平
    4. 延迟退出确认 - 二次确认避免假跌破
    5. 加权持仓管理 - 小仓位试探，趋势确认后加仓
    6. 低胜率信号过滤 - 组合条件触发，提高信号质量
    
    策略逻辑：
    买入：强趋势确认 + 成交量放大 + 多重验证
    卖出：智能止损 + 趋势转弱 + 时间管理
    止损：ATR动态 + 分批止损 + 延迟确认
    """
    
    INTERFACE_VERSION = 3

    # 策略时间框架
    timeframe = "15m"

    # 是否可以做空
    can_short: bool = False

    # ROI设置 - 更保守的利润目标
    minimal_roi = {
        "2880": 0.015, # 48小时后1.5%收益
        "1440": 0.02,  # 24小时后2%收益
        "720": 0.025,  # 12小时后2.5%收益
        "480": 0.03,   # 8小时后3%收益
        "360": 0.035,  # 6小时后3.5%收益
        "240": 0.04,   # 4小时后4%收益
        "180": 0.045,  # 3小时后4.5%收益
        "120": 0.05,   # 2小时后5%收益
        "60": 0.06,    # 1小时后6%收益
        "30": 0.07,    # 30分钟后7%收益
        "0": 0.08      # 立即8%收益
    }

    # 基础止损设置 - ATR动态调整
    stoploss = -0.08  # 8%基础止损

    # 追踪止损 - 更保守的设置
    trailing_stop = True
    trailing_stop_positive = 0.015  # 1.5%开始追踪
    trailing_stop_positive_offset = 0.02  # 2%偏移
    trailing_only_offset_is_reached = True

    # 只处理新K线
    process_only_new_candles = True

    # 策略参数 - 禁用低胜率exit_signal
    use_exit_signal = False  # 完全禁用exit_signal，使用自定义退出
    exit_profit_only = False
    ignore_roi_if_entry_signal = False

    # 策略启动所需的K线数量
    startup_candle_count: int = 100

    # 仓位调整参数
    position_adjustment_enable = True
    max_entry_position_adjustment = 3  # 最多加仓3次

    # 订单类型
    order_types = {
        "entry": "limit",
        "exit": "limit",
        "stoploss": "market",
        "stoploss_on_exchange": False
    }

    # 订单时间
    order_time_in_force = {
        "entry": "GTC",
        "exit": "GTC"
    }

    # 策略参数 - 优化后的参数
    # 均线参数
    fast_ma_period = IntParameter(5, 15, default=8, space="buy")
    slow_ma_period = IntParameter(15, 30, default=21, space="buy")
    
    # 成交量参数
    volume_ma_period = IntParameter(10, 20, default=15, space="buy")
    volume_threshold = DecimalParameter(1.2, 2.0, default=1.5, space="buy")
    
    # 趋势确认参数
    adx_threshold = IntParameter(15, 30, default=20, space="buy")
    ma_slope_period = IntParameter(3, 8, default=5, space="buy")
    trend_confirmation_period = IntParameter(2, 5, default=3, space="buy")
    
    # ATR动态止损参数
    atr_period = IntParameter(10, 20, default=14, space="sell")
    atr_multiplier = DecimalParameter(1.5, 3.0, default=2.0, space="sell")
    min_stoploss = DecimalParameter(0.03, 0.06, default=0.04, space="sell")
    max_stoploss = DecimalParameter(0.08, 0.15, default=0.12, space="sell")
    
    # 延迟退出确认参数
    exit_confirmation_candles = IntParameter(1, 3, default=2, space="sell")
    
    # 持仓时间管理参数
    max_hold_hours = IntParameter(24, 72, default=48, space="sell")
    profit_hold_extension = IntParameter(12, 48, default=24, space="sell")

    def informative_pairs(self):
        return []

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        计算技术指标 - 高级版
        """
        # 移动平均线 - 用于金叉死叉判断
        dataframe["ema_fast"] = ta.EMA(dataframe, timeperiod=self.fast_ma_period.value)
        dataframe["ema_slow"] = ta.EMA(dataframe, timeperiod=self.slow_ma_period.value)
        
        # 长期均线 - 用于支撑位判断
        dataframe["sma_support"] = ta.SMA(dataframe, timeperiod=50)
        
        # 成交量指标
        dataframe["volume_ma"] = dataframe["volume"].rolling(window=self.volume_ma_period.value).mean()
        dataframe["volume_ratio"] = dataframe["volume"] / dataframe["volume_ma"]
        
        # 均线金叉死叉信号
        dataframe["ma_golden_cross"] = (
            (dataframe["ema_fast"] > dataframe["ema_slow"]) &
            (dataframe["ema_fast"].shift(1) <= dataframe["ema_slow"].shift(1))
        )
        
        dataframe["ma_death_cross"] = (
            (dataframe["ema_fast"] < dataframe["ema_slow"]) &
            (dataframe["ema_fast"].shift(1) >= dataframe["ema_slow"].shift(1))
        )
        
        # 成交量放大信号
        dataframe["volume_surge"] = dataframe["volume_ratio"] >= self.volume_threshold.value
        
        # 趋势确认指标 - ADX
        dataframe["adx"] = ta.ADX(dataframe, timeperiod=14)
        dataframe["plus_di"] = ta.PLUS_DI(dataframe, timeperiod=14)
        dataframe["minus_di"] = ta.MINUS_DI(dataframe, timeperiod=14)
        
        # MA斜率计算 - 趋势强度
        dataframe["ema_fast_slope"] = (
            (dataframe["ema_fast"] - dataframe["ema_fast"].shift(self.ma_slope_period.value)) /
            dataframe["ema_fast"].shift(self.ma_slope_period.value)
        )
        dataframe["ema_slow_slope"] = (
            (dataframe["ema_slow"] - dataframe["ema_slow"].shift(self.ma_slope_period.value)) /
            dataframe["ema_slow"].shift(self.ma_slope_period.value)
        )
        
        # 趋势确认 - 多重验证
        dataframe["strong_trend"] = (
            (dataframe["adx"] > self.adx_threshold.value) &
            (dataframe["ema_fast_slope"] > 0.001) &  # 快线斜率向上
            (dataframe["ema_slow_slope"] > 0.0005) &  # 慢线斜率向上
            (dataframe["plus_di"] > dataframe["minus_di"])  # 多头趋势
        )
        
        # 震荡区间识别
        dataframe["atr"] = ta.ATR(dataframe, timeperiod=self.atr_period.value)
        dataframe["volatility"] = dataframe["atr"] / dataframe["close"]
        
        # 震荡区间过滤 - 在布林带计算后更新
        dataframe["not_sideways"] = (
            (dataframe["volatility"] > 0.01) &  # 有一定波动
            (dataframe["adx"] > 15)  # 有一定趋势性
        )
        
        # 价格位置指标
        dataframe["price_above_fast_ma"] = dataframe["close"] > dataframe["ema_fast"]
        dataframe["price_above_slow_ma"] = dataframe["close"] > dataframe["ema_slow"]
        dataframe["price_above_support"] = dataframe["close"] > dataframe["sma_support"]
        
        # 趋势强度 - 增强版
        dataframe["trend_strength"] = (
            (dataframe["ema_fast"] > dataframe["ema_slow"]).astype(int) +
            (dataframe["close"] > dataframe["ema_fast"]).astype(int) +
            (dataframe["close"] > dataframe["ema_slow"]).astype(int) +
            (dataframe["ema_fast_slope"] > 0.001).astype(int) +
            (dataframe["ema_slow_slope"] > 0.0005).astype(int) +
            (dataframe["strong_trend"]).astype(int)
        )
        
        # 支撑位强度
        dataframe["support_strength"] = (
            (dataframe["close"] > dataframe["sma_support"]).astype(int) +
            (dataframe["low"] > dataframe["sma_support"]).astype(int) +
            (dataframe["sma_support"] > dataframe["sma_support"].shift(1)).astype(int)
        )
        
        # 延迟退出确认 - 连续K线确认
        dataframe["trend_line_break"] = (
            (dataframe["close"] < dataframe["ema_fast"]) &
            (dataframe["close"].shift(1) < dataframe["ema_fast"].shift(1))
        )
        
        dataframe["support_break"] = (
            (dataframe["close"] < dataframe["sma_support"]) &
            (dataframe["close"].shift(1) < dataframe["sma_support"].shift(1))
        )
        
        # RSI - 辅助判断
        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=14)
        
        # MACD - 趋势确认
        macd = ta.MACD(dataframe)
        dataframe["macd"] = macd["macd"]
        dataframe["macdsignal"] = macd["macdsignal"]
        dataframe["macdhist"] = macd["macdhist"]
        
        # 布林带 - 价格位置
        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
        dataframe["bb_lowerband"] = bollinger["lower"]
        dataframe["bb_middleband"] = bollinger["mid"]
        dataframe["bb_upperband"] = bollinger["upper"]
        dataframe["bb_percent"] = (
            (dataframe["close"] - dataframe["bb_lowerband"]) /
            (dataframe["bb_upperband"] - dataframe["bb_lowerband"])
        )
        
        # 布林带宽度
        dataframe["bb_width"] = (
            (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) / dataframe["bb_middleband"]
        )
        
        # 更新震荡区间过滤条件
        dataframe["not_sideways"] = (
            (dataframe["volatility"] > 0.01) &  # 有一定波动
            (dataframe["bb_width"] > 0.05) &  # 布林带宽度足够
            (dataframe["adx"] > 15)  # 有一定趋势性
        )
        
        # 价格动量
        dataframe["price_momentum"] = (
            (dataframe["close"] - dataframe["close"].shift(5)) / dataframe["close"].shift(5)
        )
        
        # 成交量动量
        dataframe["volume_momentum"] = (
            (dataframe["volume"] - dataframe["volume"].shift(5)) / dataframe["volume"].shift(5)
        )
        
        # 市场强度指标
        dataframe["market_strength"] = (
            (dataframe["price_momentum"] > 0).astype(int) +
            (dataframe["volume_momentum"] > 0).astype(int) +
            (dataframe["macd"] > dataframe["macdsignal"]).astype(int) +
            (dataframe["rsi"] > 50).astype(int) +
            (dataframe["strong_trend"]).astype(int)
        )
        
        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        入场条件：强趋势确认 + 成交量放大 + 多重验证
        """
        # 基础条件
        base_conditions = (
            (dataframe["volume"] > 0) &
            (dataframe["ema_fast"].notna()) &
            (dataframe["ema_slow"].notna()) &
            (dataframe["volume_ma"].notna()) &
            (dataframe["adx"].notna())
        )
        
        # 主要入场条件：均线金叉
        ma_golden_cross = (
            dataframe["ma_golden_cross"] |  # 标准金叉
            (dataframe["ema_fast"] > dataframe["ema_slow"] * 1.001)  # 接近金叉
        )
        
        # 成交量确认
        volume_confirmation = (
            dataframe["volume_surge"] &  # 成交量放大
            (dataframe["volume_ratio"] >= 1.3)  # 成交量放大30%以上
        )
        
        # 强趋势确认 - 核心优化
        trend_confirmation = (
            dataframe["strong_trend"] &  # ADX>20 + MA斜率向上
            dataframe["not_sideways"] &  # 非震荡区间
            (dataframe["trend_strength"] >= 4)  # 趋势强度>=4
        )
        
        # 价格位置确认
        price_position = (
            dataframe["price_above_fast_ma"] &  # 价格在快线之上
            dataframe["price_above_slow_ma"] &  # 价格在慢线之上
            (dataframe["close"] > dataframe["sma_support"] * 1.005)  # 价格明显高于支撑
        )
        
        # 辅助条件
        additional_conditions = (
            (dataframe["rsi"] > 45) &  # RSI不过度超卖
            (dataframe["rsi"] < 75) &  # RSI不过度超买
            (dataframe["bb_percent"] > 0.2) &  # 不在布林带下轨
            (dataframe["bb_percent"] < 0.9) &  # 不在布林带上轨
            (dataframe["market_strength"] >= 3)  # 市场强度>=3
        )
        
        # 综合入场条件 - 严格筛选
        dataframe.loc[
            base_conditions &
            ma_golden_cross &
            volume_confirmation &
            trend_confirmation &
            price_position &
            additional_conditions,
            "enter_long"
        ] = 1

        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        出场条件：完全禁用，使用自定义退出逻辑
        """
        # 完全禁用populate_exit_trend，使用custom_exit
        return dataframe

    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
                       current_rate: float, current_profit: float, **kwargs) -> float:
        """
        ATR动态止损 - 波动大给宽止损，波动小收紧止损
        """
        # 获取当前数据
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        if len(dataframe) == 0:
            return self.stoploss
            
        last_candle = dataframe.iloc[-1].squeeze()
        
        # 获取ATR和关键指标
        atr = last_candle.get("atr", 0)
        current_price = last_candle.get("close", 0)
        volatility = last_candle.get("volatility", 0.02)
        trend_strength = last_candle.get("trend_strength", 0)
        strong_trend = last_candle.get("strong_trend", False)
        
        # 计算持仓时间
        trade_duration = (current_time - trade.open_date_utc).total_seconds() / 3600  # 小时
        
        # 如果有利润，保护利润
        if current_profit > 0.03:  # 有3%以上利润
            return -0.01  # 1%止损（保护大部分利润）
        elif current_profit > 0.02:  # 有2%以上利润
            return -0.015  # 1.5%止损
        elif current_profit > 0.01:  # 有1%以上利润
            return -0.02  # 2%止损
        
        # ATR动态止损计算
        if atr > 0 and current_price > 0:
            atr_stoploss = (atr * self.atr_multiplier.value) / current_price
            atr_stoploss = max(self.min_stoploss.value, min(atr_stoploss, self.max_stoploss.value))
        else:
            atr_stoploss = self.stoploss
        
        # 根据趋势强度调整止损
        if strong_trend and trend_strength >= 5:
            return -atr_stoploss * 0.8  # 强趋势，放宽止损
        elif trend_strength >= 3:
            return -atr_stoploss  # 中等趋势，标准止损
        elif trade_duration > 24:  # 长期持仓
            return -atr_stoploss * 0.7  # 收紧止损
        else:
            return -atr_stoploss

    def custom_exit(self, pair: str, trade: 'Trade', current_time: datetime, current_rate: float,
                   current_profit: float, **kwargs) -> Optional[Union[str, bool]]:
        """
        自定义退出逻辑 - 延迟确认 + 分批止损
        """
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        if len(dataframe) == 0:
            return None
            
        last_candle = dataframe.iloc[-1].squeeze()
        
        # 获取关键指标
        ema_fast = last_candle.get("ema_fast", 0)
        ema_slow = last_candle.get("ema_slow", 0)
        sma_support = last_candle.get("sma_support", 0)
        current_price = last_candle.get("close", 0)
        trend_strength = last_candle.get("trend_strength", 0)
        strong_trend = last_candle.get("strong_trend", False)
        volume_ratio = last_candle.get("volume_ratio", 1.0)
        rsi = last_candle.get("rsi", 50)
        adx = last_candle.get("adx", 0)
        
        # 计算持仓时间
        trade_duration = (current_time - trade.open_date_utc).total_seconds() / 3600  # 小时
        
        # 1. 利润目标退出
        if current_profit >= 0.04:  # 4%利润目标
            return "profit_target_4%"
        elif current_profit >= 0.03:  # 3%利润目标
            return "profit_target_3%"
        elif current_profit >= 0.025:  # 2.5%利润目标
            return "profit_target_2.5%"
        
        # 2. 延迟退出确认 - 避免假跌破
        # 趋势线跌破确认
        if (last_candle.get("trend_line_break", False) and 
            current_profit > 0.005 and 
            trend_strength <= 2 and 
            volume_ratio < 0.8):
            return "trend_line_break_confirmed"
        
        # 支撑位跌破确认
        if (last_candle.get("support_break", False) and 
            current_profit > 0.002 and 
            trend_strength <= 1 and 
            volume_ratio < 0.7):
            return "support_break_confirmed"
        
        # 3. 趋势转弱退出 - 多重确认
        if (not strong_trend and 
            trend_strength <= 2 and 
            current_profit > 0.01 and 
            current_price < ema_fast * 0.98 and 
            volume_ratio < 0.8 and
            rsi < 40 and
            adx < 20):  # 多重确认趋势转弱
            return "trend_weak_confirmed"
        
        # 4. 持仓时间管理
        if trade_duration > self.max_hold_hours.value:  # 超过最大持仓时间
            if current_profit > 0.005:  # 有微利
                return "max_hold_time_profit"
            else:  # 无利润，强制退出
                return "max_hold_time_loss"
        
        # 5. 盈利单延长持仓时间
        if current_profit > 0.02:  # 有2%以上利润
            extended_hold_time = self.max_hold_hours.value + self.profit_hold_extension.value
            if trade_duration > extended_hold_time:  # 超过延长持仓时间
                return "extended_hold_time_exit"
        
        # 6. 连续亏损强制退出
        if (current_profit < -0.03 and 
            trend_strength <= 1 and 
            current_price < ema_slow * 0.95 and 
            trade_duration > 12):  # 12小时
            return "force_exit_loss"
        
        return None

    def custom_stake_amount(self, pair: str, current_time: datetime, current_rate: float,
                           proposed_stake: float, min_stake: Optional[float], max_stake: float,
                           leverage: float, entry_tag: Optional[str], side: str,
                           **kwargs) -> float:
        """
        加权持仓管理 - 小仓位试探，趋势确认后加仓
        """
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        if len(dataframe) == 0:
            return proposed_stake * 0.5  # 默认小仓位试探
            
        last_candle = dataframe.iloc[-1].squeeze()
        
        # 获取信号强度指标
        trend_strength = last_candle.get("trend_strength", 0)
        volume_ratio = last_candle.get("volume_ratio", 1.0)
        strong_trend = last_candle.get("strong_trend", False)
        market_strength = last_candle.get("market_strength", 0)
        adx = last_candle.get("adx", 0)
        
        # 计算信号强度分数
        signal_strength = (
            trend_strength * 0.25 +  # 趋势强度权重25%
            min(volume_ratio, 3.0) * 0.2 +  # 成交量权重20%
            (strong_trend * 3) * 0.25 +  # 强趋势确认权重25%
            market_strength * 0.2 +  # 市场强度权重20%
            (adx / 50) * 0.1  # ADX权重10%
        )
        
        # 根据信号强度调整仓位 - 小仓位试探策略
        if signal_strength >= 4.0:  # 极强信号
            return proposed_stake * 1.0  # 标准仓位
        elif signal_strength >= 3.5:  # 强信号
            return proposed_stake * 0.8  # 80%仓位
        elif signal_strength >= 3.0:  # 中等信号
            return proposed_stake * 0.6  # 60%仓位
        else:  # 弱信号
            return proposed_stake * 0.4  # 40%仓位（小仓位试探）

    def adjust_trade_position(self, trade: Trade, current_time: datetime,
                            current_rate: float, current_profit: float,
                            min_stake: Optional[float], max_stake: float,
                            current_entry_rate: float, current_exit_rate: float,
                            current_entry_profit: float, current_exit_profit: float,
                            **kwargs) -> Optional[float]:
        """
        加仓逻辑 - 趋势确认后加仓
        """
        dataframe, _ = self.dp.get_analyzed_dataframe(trade.pair, self.timeframe)
        if len(dataframe) == 0:
            return None
            
        last_candle = dataframe.iloc[-1].squeeze()
        
        # 获取当前指标
        trend_strength = last_candle.get("trend_strength", 0)
        volume_ratio = last_candle.get("volume_ratio", 1.0)
        ema_fast = last_candle.get("ema_fast", 0)
        ema_slow = last_candle.get("ema_slow", 0)
        current_price = last_candle.get("close", 0)
        strong_trend = last_candle.get("strong_trend", False)
        support_strength = last_candle.get("support_strength", 0)
        market_strength = last_candle.get("market_strength", 0)
        
        # 计算持仓时间
        trade_duration = (current_time - trade.open_date_utc).total_seconds() / 3600  # 小时
        
        # 加仓条件1：有利润且趋势极强 + 多重确认
        if (current_profit > 0.02 and  # 有2%以上利润
            strong_trend and  # 强趋势确认
            trend_strength >= 5 and  # 趋势极强
            current_price > ema_fast * 1.01 and  # 价格明显高于快线
            current_price > ema_slow * 1.02 and  # 价格明显高于慢线
            volume_ratio >= 1.5 and  # 成交量大幅放大
            support_strength >= 2 and  # 支撑强劲
            market_strength >= 4 and  # 市场强度高
            trade_duration < 12):  # 持仓时间不太长
            
            # 计算加仓金额（不超过原仓位的50%）
            stake_amount = trade.stake_amount * 0.5
            return stake_amount
        
        # 加仓条件2：接近利润目标且趋势持续
        elif (current_profit > 0.015 and  # 有1.5%以上利润
              trend_strength >= 4 and  # 趋势持续
              current_price > ema_fast * 1.005 and  # 价格明显高于快线
              volume_ratio >= 1.3 and  # 成交量放大
              support_strength >= 2 and  # 支撑确认
              market_strength >= 3 and  # 市场强度高
              trade_duration < 8):  # 持仓时间较短
              
            # 计算加仓金额（不超过原仓位的30%）
            stake_amount = trade.stake_amount * 0.3
            return stake_amount
        
        return None

    def leverage(self, pair: str, current_time: datetime, current_rate: float,
                 proposed_leverage: float, max_leverage: float, entry_tag: Optional[str], 
                 side: str, **kwargs) -> float:
        """
        杠杆设置 - 基于趋势强度的动态杠杆
        """
        dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
        if len(dataframe) == 0:
            return min(proposed_leverage, 1.5)
            
        last_candle = dataframe.iloc[-1].squeeze()
        
        # 获取信号强度
        trend_strength = last_candle.get("trend_strength", 0)
        strong_trend = last_candle.get("strong_trend", False)
        market_strength = last_candle.get("market_strength", 0)
        adx = last_candle.get("adx", 0)
        
        # 根据信号强度调整杠杆
        if strong_trend and trend_strength >= 5 and market_strength >= 4 and adx > 25:
            return min(proposed_leverage, 2.5)  # 极强信号，2.5倍杠杆
        elif trend_strength >= 4 and market_strength >= 3 and adx > 20:
            return min(proposed_leverage, 2.0)  # 强信号，2倍杠杆
        else:
            return min(proposed_leverage, 1.5)  # 其他情况，1.5倍杠杆