BotTraderStrategy

"""
BotTrader Strategy v4 - Trend Following + Sentiment Filter
Optimized for Coinbase's high fees (1.2% per side worst case).

Features:
- Hyperopt-optimizable entry/exit parameters
- Fear & Greed Index filter (blocks buys during extreme greed)
- News headline sentiment scanner (blocks buys during FUD events)
"""

import logging
from freqtrade.strategy import IStrategy, IntParameter, DecimalParameter
from pandas import DataFrame
import talib.abstract as ta
from sentiment import SentimentEngine, FearGreedIndex

logger = logging.getLogger(__name__)


class BotTraderStrategy(IStrategy):
    """
    Trend-following strategy optimized for Coinbase high fees.
    Uses 2h timeframe with strong trend filters.
    Key parameters are hyperopt-optimizable.
    """

    timeframe = "2h"

    # ROI targets - must clear 2.4% fee round-trip before profit
    minimal_roi = {
        "0": 0.10,
        "24": 0.07,
        "48": 0.05,
        "96": 0.03,
    }

    # Stop-loss
    stoploss = -0.06

    # Trailing stop
    trailing_stop = True
    trailing_stop_positive = 0.025
    trailing_stop_positive_offset = 0.06
    trailing_only_offset_is_reached = True

    # Protections
    @property
    def protections(self):
        return [
            {
                "method": "MaxDrawdown",
                "lookback_period_candles": 48,
                "trade_limit": 20,
                "stop_duration_candles": 12,
                "max_allowed_drawdown": 0.05,
            },
            {
                "method": "StoplossGuard",
                "lookback_period_candles": 24,
                "trade_limit": 3,
                "stop_duration_candles": 12,
                "only_per_pair": False,
            },
        ]

    process_only_new_candles = True
    use_exit_signal = True
    exit_profit_only = True
    ignore_roi_if_entry_signal = True

    startup_candle_count: int = 200

    # ==========================================
    # HYPEROPT PARAMETERS - these get optimized
    # ==========================================

    # Entry filters
    buy_adx = IntParameter(15, 35, default=20, space="buy")
    buy_rsi_low = IntParameter(25, 45, default=40, space="buy")
    buy_rsi_high = IntParameter(55, 75, default=65, space="buy")
    buy_atr_pct = DecimalParameter(0.5, 3.0, default=1.5, decimals=1, space="buy")

    # Exit filters
    sell_rsi = IntParameter(75, 95, default=85, space="sell")

    def confirm_trade_entry(
        self, pair, order_type, amount, rate, time_in_force, current_time,
        entry_tag, side, **kwargs
    ) -> bool:
        """
        Called right before a trade entry. Use sentiment to block bad trades.
        This runs in real-time (not during backtesting).
        """
        # Check sentiment - blocks during extreme greed or bearish news
        if not SentimentEngine.should_enter_trade(
            max_greed=75, min_fear=10, check_news=True
        ):
            report = SentimentEngine.get_full_report()
            logger.info(
                f"TRADE BLOCKED by sentiment for {pair}: "
                f"Fear&Greed={report['fear_greed_value']} ({report['fear_greed_label']}), "
                f"News={report['news_sentiment']}"
            )
            return False

        # Log sentiment on allowed trades
        fng = FearGreedIndex.get_value()
        logger.info(
            f"TRADE ALLOWED for {pair}: "
            f"Fear&Greed={fng['value']} ({fng['label']})"
        )
        return True

    def custom_stake_amount(
        self, current_time, current_rate, proposed_stake, min_stake,
        max_stake, leverage, entry_tag, side, **kwargs
    ) -> float:
        """
        Adjust position size based on Fear & Greed sentiment.
        Fear = bigger positions, Greed = smaller positions.
        """
        multiplier = FearGreedIndex.position_size_multiplier()
        adjusted = proposed_stake * multiplier

        # Respect min/max bounds
        if max_stake is not None:
            adjusted = min(adjusted, max_stake)
        adjusted = max(adjusted, min_stake) if min_stake else adjusted

        if multiplier != 1.0:
            fng = FearGreedIndex.get_value()
            logger.info(
                f"Position size adjusted: {proposed_stake:.2f} -> {adjusted:.2f} "
                f"(x{multiplier}, Fear&Greed={fng['value']})"
            )
        return adjusted

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """Add technical indicators."""

        # EMAs for trend detection
        dataframe["ema_9"] = ta.EMA(dataframe, timeperiod=9)
        dataframe["ema_21"] = ta.EMA(dataframe, timeperiod=21)
        dataframe["ema_50"] = ta.EMA(dataframe, timeperiod=50)
        dataframe["ema_200"] = ta.EMA(dataframe, timeperiod=200)

        # RSI
        dataframe["rsi"] = ta.RSI(dataframe, timeperiod=14)

        # MACD for momentum confirmation
        macd = ta.MACD(dataframe, fastperiod=12, slowperiod=26, signalperiod=9)
        dataframe["macd"] = macd["macd"]
        dataframe["macdsignal"] = macd["macdsignal"]
        dataframe["macdhist"] = macd["macdhist"]

        # ADX - trend strength
        dataframe["adx"] = ta.ADX(dataframe, timeperiod=14)

        # ATR - volatility
        dataframe["atr"] = ta.ATR(dataframe, timeperiod=14)
        dataframe["atr_pct"] = dataframe["atr"] / dataframe["close"] * 100

        # Bollinger Bands - for mean reversion signals
        bollinger = ta.BBANDS(dataframe, timeperiod=20, nbdevup=2.0, nbdevdn=2.0)
        dataframe["bb_upper"] = bollinger["upperband"]
        dataframe["bb_lower"] = bollinger["lowerband"]
        dataframe["bb_mid"] = bollinger["middleband"]
        dataframe["bb_width"] = (dataframe["bb_upper"] - dataframe["bb_lower"]) / dataframe["bb_mid"]

        # Volume
        dataframe["volume_sma"] = ta.SMA(dataframe["volume"], timeperiod=20)

        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """Entry signals - hyperopt-optimizable thresholds."""

        dataframe.loc[
            (
                # TREND ALIGNMENT: Price > EMA50 > EMA200 (strong uptrend)
                (dataframe["close"] > dataframe["ema_50"])
                & (dataframe["ema_50"] > dataframe["ema_200"])

                # ENTRY TRIGGER: EMA 9 crosses above EMA 21
                & (dataframe["ema_9"] > dataframe["ema_21"])
                & (dataframe["ema_9"].shift(1) <= dataframe["ema_21"].shift(1))

                # MOMENTUM: MACD histogram is positive
                & (dataframe["macdhist"] > 0)

                # TREND STRENGTH (hyperopt-optimized)
                & (dataframe["adx"] > self.buy_adx.value)

                # VOLATILITY (hyperopt-optimized)
                & (dataframe["atr_pct"] > self.buy_atr_pct.value)

                # RSI range (hyperopt-optimized)
                & (dataframe["rsi"] > self.buy_rsi_low.value)
                & (dataframe["rsi"] < self.buy_rsi_high.value)

                # VOLUME: Above average
                & (dataframe["volume"] > dataframe["volume_sma"])
                & (dataframe["volume"] > 0)
            ),
            "enter_long",
        ] = 1

        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """Exit signals - hyperopt-optimized RSI threshold."""

        dataframe.loc[
            (
                # EMA 9 crosses below EMA 21 + price below EMA 50
                (dataframe["ema_9"] < dataframe["ema_21"])
                & (dataframe["ema_9"].shift(1) >= dataframe["ema_21"].shift(1))
                & (dataframe["close"] < dataframe["ema_50"])
            )
            | (
                # RSI extremely overbought (hyperopt-optimized)
                (dataframe["rsi"] > self.sell_rsi.value)
            ),
            "exit_long",
        ] = 1

        return dataframe