Profit Hunter HSI with Fibonacci Strategy

using System;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Profit Hunter strategy with Fibonacci retracement levels.
/// Uses EMA trend filter and enters on pullbacks to Fibonacci levels.
/// </summary>
public class ProfitHunterHsiWithFibonacciStrategy : Strategy
{
	private readonly StrategyParam<int> _emaPeriod;
	private readonly StrategyParam<int> _lookbackPeriod;
	private readonly StrategyParam<DataType> _candleType;

	private int _barCount;

	public ProfitHunterHsiWithFibonacciStrategy()
	{
		_emaPeriod = Param(nameof(EmaPeriod), 20)
			.SetDisplay("EMA Period", "Period for trend filter EMA.", "Indicators");

		_lookbackPeriod = Param(nameof(LookbackPeriod), 50)
			.SetDisplay("Lookback Period", "Bars to look back for range high/low.", "Fibonacci");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(2).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe for analysis.", "General");
	}

	public int EmaPeriod
	{
		get => _emaPeriod.Value;
		set => _emaPeriod.Value = value;
	}

	public int LookbackPeriod
	{
		get => _lookbackPeriod.Value;
		set => _lookbackPeriod.Value = value;
	}

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <inheritdoc />
	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_barCount = 0;
	}

		protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_barCount = 0;

		var ema = new ExponentialMovingAverage { Length = EmaPeriod };
		var highest = new Highest { Length = LookbackPeriod };
		var lowest = new Lowest { Length = LookbackPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(ema, highest, lowest, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, ema);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal emaValue, decimal highestValue, decimal lowestValue)
	{
		if (candle.State != CandleStates.Finished)
			return;

		_barCount++;

		if (_barCount < LookbackPeriod)
			return;

		var range = highestValue - lowestValue;
		if (range <= 0)
			return;

		// Fibonacci levels
		var fib382 = highestValue - range * 0.382m;
		var fib618 = highestValue - range * 0.618m;
		var close = candle.ClosePrice;

		// Manage position
		if (Position > 0)
		{
			// Exit long at 0 fib (range high) or if price drops below 61.8%
			if (close >= highestValue || close < fib618)
			{
				SellMarket();
			}
		}
		else if (Position < 0)
		{
			// Exit short at 100% fib (range low) or if price rises above 38.2%
			if (close <= lowestValue || close > fib382)
			{
				BuyMarket();
			}
		}

		// Entry logic
		if (Position == 0)
		{
			if (close > emaValue && close <= fib382 && close > fib618)
			{
				// Uptrend + pullback to Fib zone -> buy
				BuyMarket();
			}
			else if (close < emaValue && close >= fib618 && close < fib382)
			{
				// Downtrend + pullback to Fib zone -> sell
				SellMarket();
			}
		}
	}
}

import clr

clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")

from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Strategies import Strategy
from StockSharp.Algo.Indicators import ExponentialMovingAverage, Highest, Lowest

class profit_hunter_hsi_with_fibonacci_strategy(Strategy):
    def __init__(self):
        super(profit_hunter_hsi_with_fibonacci_strategy, self).__init__()

        self._ema_period = self.Param("EmaPeriod", 20) \
            .SetDisplay("EMA Period", "Period for trend filter EMA", "Indicators")
        self._lookback_period = self.Param("LookbackPeriod", 50) \
            .SetDisplay("Lookback Period", "Bars to look back for range high/low", "Fibonacci")
        self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromHours(2))) \
            .SetDisplay("Candle Type", "Timeframe for analysis", "General")

        self._bar_count = 0

    @property
    def EmaPeriod(self):
        return self._ema_period.Value

    @property
    def LookbackPeriod(self):
        return self._lookback_period.Value

    @property
    def CandleType(self):
        return self._candle_type.Value

    def OnStarted2(self, time):
        super(profit_hunter_hsi_with_fibonacci_strategy, self).OnStarted2(time)

        self._bar_count = 0

        self._ema = ExponentialMovingAverage()
        self._ema.Length = self.EmaPeriod
        self._highest = Highest()
        self._highest.Length = self.LookbackPeriod
        self._lowest = Lowest()
        self._lowest.Length = self.LookbackPeriod

        subscription = self.SubscribeCandles(self.CandleType)
        subscription.Bind(self._ema, self._highest, self._lowest, self.ProcessCandle).Start()

    def ProcessCandle(self, candle, ema_value, highest_value, lowest_value):
        if candle.State != CandleStates.Finished:
            return

        self._bar_count += 1

        if self._bar_count < self.LookbackPeriod:
            return

        ema_val = float(ema_value)
        high_val = float(highest_value)
        low_val = float(lowest_value)
        rng = high_val - low_val
        if rng <= 0:
            return

        fib382 = high_val - rng * 0.382
        fib618 = high_val - rng * 0.618
        close = float(candle.ClosePrice)

        # Manage position
        if self.Position > 0:
            if close >= high_val or close < fib618:
                self.SellMarket()
        elif self.Position < 0:
            if close <= low_val or close > fib382:
                self.BuyMarket()

        # Entry logic
        if self.Position == 0:
            if close > ema_val and close <= fib382 and close > fib618:
                self.BuyMarket()
            elif close < ema_val and close >= fib618 and close < fib382:
                self.SellMarket()

    def OnReseted(self):
        super(profit_hunter_hsi_with_fibonacci_strategy, self).OnReseted()
        self._bar_count = 0

    def CreateClone(self):
        return profit_hunter_hsi_with_fibonacci_strategy()