ICTSmartMoneyStrategy

"""
ICT Smart Money Strategy — Freqtrade Implementation

Rules:
1. MACRO TIME MATTERS — Trade only during high-reactivity windows
2. WAIT FOR STOP-HUNT — Liquidity sweep before entry
3. USE IFVG OR BREAKER ENTRY — IFVG = first, Breaker Block = second
4. TRADE ONLY PREMIUM/DISCOUNT ZONES — Sell premium, Buy discount
5. FOCUS ON 1-2 QUALITY TRADES — Clean 1:2 RR setups
"""

from freqtrade.strategy import IStrategy, IntParameter, DecimalParameter
from pandas import DataFrame
import talib.abstract as ta
import numpy as np


class ICTSmartMoneyStrategy(IStrategy):
    """
    ICT Smart Money Concepts Strategy
    
    Combines:
    - Fair Value Gaps (FVG) detection
    - Breaker Block detection
    - Liquidity sweep / stop-hunt detection
    - Premium/Discount zone filtering
    - Macro time filtering (London/NY killzones)
    """
    
    INTERFACE_VERSION = 3
    timeframe = '15m'
    can_short = True
    
    # 1:2 Risk-Reward minimum
    minimal_roi = {
        "0": 0.06,    # 6% immediate target (1:2 from 3% SL)
        "120": 0.04,  # After 2 hours, accept 4%
        "240": 0.02,  # After 4 hours, accept 2%
        "480": 0.01,  # After 8 hours, accept 1%
    }
    
    stoploss = -0.03  # 3% stop loss (for 1:2 RR with 6% target)
    trailing_stop = True
    trailing_stop_positive = 0.015
    trailing_stop_positive_offset = 0.035
    trailing_only_offset_is_reached = True
    
    process_only_new_candles = True
    startup_candle_count: int = 100
    
    # ── Parameters ──────────────────────────────────────────────────────
    
    # FVG detection
    fvg_lookback = IntParameter(3, 10, default=5, space="buy")
    fvg_min_size_pct = DecimalParameter(0.001, 0.01, default=0.003, decimals=3, space="buy")
    
    # Liquidity sweep detection
    swing_lookback = IntParameter(10, 30, default=20, space="buy")
    
    # Premium/Discount zone
    pd_lookback = IntParameter(30, 100, default=50, space="buy")
    
    # Volume confirmation
    vol_mult = DecimalParameter(1.0, 3.0, default=1.5, decimals=1, space="buy")
    
    # ── Macro Time Windows (UTC) ────────────────────────────────────────
    # London Open Killzone: 07:00-10:00 UTC
    # NY Open Killzone: 12:30-15:00 UTC  
    # London Close: 15:00-16:00 UTC
    
    LONDON_KZ = [7, 8, 9, 10]
    NY_KZ = [12, 13, 14, 15]
    LONDON_CLOSE = [16]
    
    # All allowed hours
    ALLOWED_HOURS = LONDON_KZ + NY_KZ + LONDON_CLOSE
    
    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """Calculate ICT/SMC indicators"""
        
        # ── Basic indicators ────────────────────────────────────────────
        dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
        dataframe['volume_mean'] = dataframe['volume'].rolling(20).mean()
        
        # ── Swing Highs/Lows (for liquidity levels) ────────────────────
        lb = self.swing_lookback.value
        dataframe['swing_high'] = dataframe['high'].rolling(lb*2+1, center=True).max()
        dataframe['swing_low'] = dataframe['low'].rolling(lb*2+1, center=True).min()
        
        # Swing high/low at specific candles (not rolling window)
        dataframe['is_swing_high'] = (
            (dataframe['high'] == dataframe['high'].rolling(lb*2+1, center=True).max()) &
            (dataframe['high'].shift(1) < dataframe['high']) &
            (dataframe['high'].shift(-1) < dataframe['high'])
        )
        dataframe['is_swing_low'] = (
            (dataframe['low'] == dataframe['low'].rolling(lb*2+1, center=True).min()) &
            (dataframe['low'].shift(1) > dataframe['low']) &
            (dataframe['low'].shift(-1) > dataframe['low'])
        )
        
        # Track recent swing levels
        dataframe['last_swing_high'] = np.nan
        dataframe['last_swing_low'] = np.nan
        for i in range(len(dataframe)):
            if dataframe['is_swing_high'].iloc[i]:
                dataframe.loc[dataframe.index[i], 'last_swing_high'] = dataframe['high'].iloc[i]
            if dataframe['is_swing_low'].iloc[i]:
                dataframe.loc[dataframe.index[i], 'last_swing_low'] = dataframe['low'].iloc[i]
        
        dataframe['last_swing_high'] = dataframe['last_swing_high'].ffill()
        dataframe['last_swing_low'] = dataframe['last_swing_low'].ffill()
        
        # ── Fair Value Gap (FVG) Detection ──────────────────────────────
        # Bullish FVG: candle[i-1].high < candle[i+1].low (gap up)
        # Bearish FVG: candle[i-1].low > candle[i+1].high (gap down)
        dataframe['fvg_bullish'] = (
            (dataframe['low'].shift(-1) > dataframe['high'].shift(1)) &
            ((dataframe['low'].shift(-1) - dataframe['high'].shift(1)) / dataframe['close'] > self.fvg_min_size_pct.value)
        )
        dataframe['fvg_bearish'] = (
            (dataframe['high'].shift(-1) < dataframe['low'].shift(1)) &
            ((dataframe['low'].shift(1) - dataframe['high'].shift(-1)) / dataframe['close'] > self.fvg_min_size_pct.value)
        )
        
        # FVG midpoint (inversion level)
        dataframe['fvg_bull_mid'] = np.where(
            dataframe['fvg_bullish'],
            (dataframe['low'].shift(-1) + dataframe['high'].shift(1)) / 2,
            np.nan
        )
        dataframe['fvg_bear_mid'] = np.where(
            dataframe['fvg_bearish'],
            (dataframe['low'].shift(1) + dataframe['high'].shift(-1)) / 2,
            np.nan
        )
        dataframe['fvg_bull_mid'] = dataframe['fvg_bull_mid'].ffill()
        dataframe['fvg_bear_mid'] = dataframe['fvg_bear_mid'].ffill()
        
        # ── Breaker Block Detection ─────────────────────────────────────
        # Breaker = failed FVG that gets reclaimed
        # Bullish breaker: bearish candle that caused break below, then price reclaims
        dataframe['breaker_bull'] = (
            (dataframe['close'] > dataframe['open']) &  # Current bullish
            (dataframe['close'].shift(1) < dataframe['open'].shift(1)) &  # Previous bearish
            (dataframe['low'] < dataframe['low'].shift(1)) &  # Swept previous low
            (dataframe['close'] > dataframe['high'].shift(1)) &  # Closed above previous high
            (dataframe['volume'] > dataframe['volume_mean'] * self.vol_mult.value)  # Volume confirm
        )
        
        dataframe['breaker_bear'] = (
            (dataframe['close'] < dataframe['open']) &  # Current bearish
            (dataframe['close'].shift(1) > dataframe['open'].shift(1)) &  # Previous bullish
            (dataframe['high'] > dataframe['high'].shift(1)) &  # Swept previous high
            (dataframe['close'] < dataframe['low'].shift(1)) &  # Closed below previous low
            (dataframe['volume'] > dataframe['volume_mean'] * self.vol_mult.value)  # Volume confirm
        )
        
        # ── Liquidity Sweep / Stop Hunt Detection ───────────────────────
        # Sweep = price takes out swing high/low then reverses
        dataframe['sweep_high'] = (
            (dataframe['high'] > dataframe['last_swing_high'].shift(1)) &  # Took out swing high
            (dataframe['close'] < dataframe['last_swing_high'].shift(1)) &  # But closed below (rejection)
            (dataframe['close'] < dataframe['open'])  # Bearish candle
        )
        
        dataframe['sweep_low'] = (
            (dataframe['low'] < dataframe['last_swing_low'].shift(1)) &  # Took out swing low
            (dataframe['close'] > dataframe['last_swing_low'].shift(1)) &  # But closed above (rejection)
            (dataframe['close'] > dataframe['open'])  # Bullish candle
        )
        
        # ── Premium/Discount Zone ───────────────────────────────────────
        pd_lb = self.pd_lookback.value
        range_high = dataframe['high'].rolling(pd_lb).max()
        range_low = dataframe['low'].rolling(pd_lb).min()
        range_mid = (range_high + range_low) / 2
        
        dataframe['range_mid'] = range_mid
        dataframe['range_high'] = range_high
        dataframe['range_low'] = range_low
        
        # Premium = above midpoint, Discount = below midpoint
        dataframe['in_premium'] = dataframe['close'] > range_mid
        dataframe['in_discount'] = dataframe['close'] < range_mid
        
        # Equilibrium zone (near midpoint ± 10% of range)
        range_size = range_high - range_low
        dataframe['in_equilibrium'] = (
            (dataframe['close'] > range_mid - range_size * 0.1) &
            (dataframe['close'] < range_mid + range_size * 0.1)
        )
        
        # ── Macro Time Filter ───────────────────────────────────────────
        dataframe['hour'] = dataframe['date'].dt.hour
        dataframe['macro_time'] = dataframe['hour'].isin(self.ALLOWED_HOURS)
        
        # Enhanced: weight by killzone importance
        dataframe['in_london_kz'] = dataframe['hour'].isin(self.LONDON_KZ)
        dataframe['in_ny_kz'] = dataframe['hour'].isin(self.NY_KZ)
        dataframe['in_killzone'] = dataframe['in_london_kz'] | dataframe['in_ny_kz']
        
        return dataframe
    
    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Entry Logic:
        
        LONG (Discount zone):
        1. Stop hunt / sweep low → IFVG entry OR
        2. Breaker block bullish in discount zone
        3. Must be in macro time window
        4. Volume confirmation
        
        SHORT (Premium zone):
        1. Stop hunt / sweep high → IFVG entry OR  
        2. Breaker block bearish in premium zone
        3. Must be in macro time window
        4. Volume confirmation
        """
        
        # ── LONG Entry ──────────────────────────────────────────────────
        # Condition 1: Sweep low + FVG bullish (IFVG entry)
        long_sweep_ifvg = (
            dataframe['sweep_low'] &
            (dataframe['close'] > dataframe['fvg_bull_mid']) &
            (dataframe['close'] < dataframe['range_mid'])  # In discount zone
        )
        
        # Condition 2: Breaker block bullish in discount
        long_breaker = (
            dataframe['breaker_bull'] &
            (dataframe['close'] < dataframe['range_mid'])  # In discount zone
        )
        
        # Condition 3: FVG bullish touch in discount zone
        long_fvg_touch = (
            (dataframe['low'] <= dataframe['fvg_bull_mid'] * 1.005) &  # Price touched FVG
            (dataframe['low'] >= dataframe['fvg_bull_mid'] * 0.995) &
            (dataframe['close'] > dataframe['open']) &  # Bullish candle
            (dataframe['close'] < dataframe['range_mid']) &  # Discount zone
            (dataframe['volume'] > dataframe['volume_mean'] * self.vol_mult.value)
        )
        
        # Combined long conditions
        long_entry = (
            (long_sweep_ifvg | long_breaker | long_fvg_touch) &
            dataframe['macro_time'] &
            (dataframe['volume'] > 0)
        )
        
        dataframe.loc[long_entry, 'enter_long'] = 1
        
        # ── SHORT Entry ─────────────────────────────────────────────────
        # Condition 1: Sweep high + FVG bearish (IFVG entry)
        short_sweep_ifvg = (
            dataframe['sweep_high'] &
            (dataframe['close'] < dataframe['fvg_bear_mid']) &
            (dataframe['close'] > dataframe['range_mid'])  # In premium zone
        )
        
        # Condition 2: Breaker block bearish in premium
        short_breaker = (
            dataframe['breaker_bear'] &
            (dataframe['close'] > dataframe['range_mid'])  # In premium zone
        )
        
        # Condition 3: FVG bearish touch in premium zone
        short_fvg_touch = (
            (dataframe['high'] >= dataframe['fvg_bear_mid'] * 0.995) &  # Price touched FVG
            (dataframe['high'] <= dataframe['fvg_bear_mid'] * 1.005) &
            (dataframe['close'] < dataframe['open']) &  # Bearish candle
            (dataframe['close'] > dataframe['range_mid']) &  # Premium zone
            (dataframe['volume'] > dataframe['volume_mean'] * self.vol_mult.value)
        )
        
        # Combined short conditions
        short_entry = (
            (short_sweep_ifvg | short_breaker | short_fvg_touch) &
            dataframe['macro_time'] &
            (dataframe['volume'] > 0)
        )
        
        dataframe.loc[short_entry, 'enter_short'] = 1
        
        return dataframe
    
    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Exit Logic:
        - Take profit at 1:2 RR (handled by ROI)
        - Exit on opposite zone breach
        - Exit on structure break
        """
        
        # LONG exit: price enters premium zone + bearish signal
        dataframe.loc[
            (
                (dataframe['close'] > dataframe['range_mid']) &  # Now in premium
                (
                    dataframe['sweep_high'] |  # Sweep high rejection
                    dataframe['breaker_bear'] |  # Breaker bearish
                    ((dataframe['rsi'] > 70) & (dataframe['close'] < dataframe['open']))  # RSI overbought + bearish
                )
            ),
            'exit_long'
        ] = 1
        
        # SHORT exit: price enters discount zone + bullish signal
        dataframe.loc[
            (
                (dataframe['close'] < dataframe['range_mid']) &  # Now in discount
                (
                    dataframe['sweep_low'] |  # Sweep low rejection
                    dataframe['breaker_bull'] |  # Breaker bullish
                    ((dataframe['rsi'] < 30) & (dataframe['close'] > dataframe['open']))  # RSI oversold + bullish
                )
            ),
            'exit_short'
        ] = 1
        
        return dataframe