BotTraderStrategyV5

"""
BotTrader Strategy v5 - Kraken-tuned rebuild.

Changes from v4 (in response to external analyst review, 2026-05-26):

1. LOOKBACK TRIGGER (was: strict cross)
   v4 required EMA9 to cross EMA21 *on the current candle* while 7 other state
   filters all aligned. That's a unicorn hunt — 4 trades / 26 months in backtest.
   v5 requires EMA9 > EMA21 now AND a cross-up within the last N bars
   (N is hyperopt-tunable 1-5).

2. exit_profit_only = False (was: True)
   With Kraken's ~0.50-0.65% round-trip vs Coinbase's 1.0-1.2%, we can afford
   to cut on trend invalidation rather than wait for green. v4 would stubbornly
   ride a decaying trade to the -6% stop because the signal exit was gated on
   profit. v5 lets the signal exit fire at a loss.

3. SENTIMENT SOFT-SCALE (was: hard block at F&G > 75)
   v4's hard block sat out weeks of bull runs (F&G stays >75 for long stretches
   in macro uptrends). v5 keeps the news/event hard block but converts the F&G
   gate into aggressive position-size scaling via custom_stake_amount
   (multiplier already exists in sentiment.py and is now used in lieu of the
   block).

4. KRAKEN FEES + 1H TIMEFRAME
   Kraken's OHLCV API does not support 2h candles (only 1m/5m/15m/30m/1h/4h/1d).
   v5 moves to 1h to (a) match what Kraken serves natively, (b) give the
   lookback trigger more chances to fire, and (c) take advantage of Kraken's
   halved fees, which let smaller per-bar moves clear costs.

   Indicator periods are unchanged (EMA9/21/50/200, RSI14, etc.) so on 1h:
     EMA200 ≈ 8 days, EMA50 ≈ 2 days — still real trend filters.

     freqtrade backtesting --strategy BotTraderStrategyV5 --fee 0.0040
     freqtrade hyperopt    --strategy BotTraderStrategyV5 --fee 0.0040 \\
                           --hyperopt-loss TradeCountHyperOptLoss

KILL GATE: Do not deploy live capital unless backtest shows >=1.5%/mo net of
Kraken fees over 24+ months on the same 10-pair USD universe.
"""

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 BotTraderStrategyV5(IStrategy):
    timeframe = "1h"

    minimal_roi = {
        "0": 0.08,
        "24": 0.05,
        "48": 0.03,
        "96": 0.02,
    }

    stoploss = -0.06

    trailing_stop = True
    trailing_stop_positive = 0.02
    trailing_stop_positive_offset = 0.05
    trailing_only_offset_is_reached = True

    @property
    def protections(self):
        # Candle counts doubled vs v4 to preserve the same wall-clock
        # windows now that we're on 1h candles instead of 2h.
        return [
            {
                "method": "MaxDrawdown",
                "lookback_period_candles": 96,
                "trade_limit": 20,
                "stop_duration_candles": 24,
                "max_allowed_drawdown": 0.05,
            },
            {
                "method": "StoplossGuard",
                "lookback_period_candles": 48,
                "trade_limit": 3,
                "stop_duration_candles": 24,
                "only_per_pair": False,
            },
        ]

    process_only_new_candles = True
    use_exit_signal = True
    exit_profit_only = False  # v5: cut on trend invalidation, not only in green
    ignore_roi_if_entry_signal = True

    startup_candle_count: int = 400

    # Hyperopt-tunable parameters
    buy_cross_lookback = IntParameter(1, 5, default=3, space="buy")
    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.0, decimals=1, space="buy")
    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:
        """
        v5: F&G is no longer a hard gate — only the news/event scanner can block.
        F&G modulates position size via custom_stake_amount instead.
        """
        from sentiment import NewsScanner
        if not NewsScanner.is_safe_to_trade():
            logger.info(f"TRADE BLOCKED for {pair} by news scanner (event risk)")
            return False

        fng = FearGreedIndex.get_value()
        logger.info(
            f"TRADE ALLOWED for {pair}: F&G={fng['value']} ({fng['label']}) — "
            f"size will be scaled by custom_stake_amount"
        )
        return True

    def custom_stake_amount(
        self, current_time, current_rate, proposed_stake, min_stake,
        max_stake, leverage, entry_tag, side, **kwargs
    ) -> float:
        """
        v5: F&G multiplier is now the primary sentiment lever (not a hard block).
        sentiment.FearGreedIndex.position_size_multiplier() returns 0.5-1.5.
        """
        multiplier = FearGreedIndex.position_size_multiplier()
        adjusted = proposed_stake * multiplier

        if max_stake is not None:
            adjusted = min(adjusted, max_stake)
        if min_stake:
            adjusted = max(adjusted, min_stake)

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

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        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)

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

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

        dataframe["adx"] = ta.ADX(dataframe, timeperiod=14)

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

        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"]

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

        # v5: EMA9/21 cross-up event + lookback window for "still fresh"
        dataframe["ema_cross_up"] = (
            (dataframe["ema_9"] > dataframe["ema_21"])
            & (dataframe["ema_9"].shift(1) <= dataframe["ema_21"].shift(1))
        ).astype(int)

        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # Cross within last N bars (hyperopt-tunable)
        lookback = self.buy_cross_lookback.value
        recent_cross = dataframe["ema_cross_up"].rolling(window=lookback, min_periods=1).max()

        dataframe.loc[
            (
                (dataframe["close"] > dataframe["ema_50"])
                & (dataframe["ema_50"] > dataframe["ema_200"])

                & (dataframe["ema_9"] > dataframe["ema_21"])
                & (recent_cross > 0)

                & (dataframe["macdhist"] > 0)

                & (dataframe["adx"] > self.buy_adx.value)
                & (dataframe["atr_pct"] > self.buy_atr_pct.value)

                & (dataframe["rsi"] > self.buy_rsi_low.value)
                & (dataframe["rsi"] < self.buy_rsi_high.value)

                & (dataframe["volume"] > dataframe["volume_sma"])
                & (dataframe["volume"] > 0)
            ),
            "enter_long",
        ] = 1

        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                (dataframe["ema_9"] < dataframe["ema_21"])
                & (dataframe["ema_9"].shift(1) >= dataframe["ema_21"].shift(1))
                & (dataframe["close"] < dataframe["ema_50"])
            )
            | (
                (dataframe["rsi"] > self.sell_rsi.value)
            ),
            "exit_long",
        ] = 1

        return dataframe