RSI Combine with Three White Soldiers Three Black Crows

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class CombinedTradingBot : Robot
    {
        [Parameter("Source")]
        public DataSeries Source { get; set; }

        [Parameter("Periods", DefaultValue = 14)]
        public int Periods { get; set; }

        [Parameter("Quantity (Lots)", DefaultValue = 1, MinValue = 0.01, Step = 0.01)]
        public double Quantity { get; set; }

        [Parameter("Stop Loss (pips)", DefaultValue = 10)]
        public int StopLossInPips { get; set; }

        [Parameter("Take Profit (pips)", DefaultValue = 20)]
        public int TakeProfitInPips { get; set; }

        [Parameter(DefaultValue = 100000)]
        public double Volume { get; set; }

        [Parameter(DefaultValue = 20)]
        public double Stoploss { get; set; }

        [Parameter(DefaultValue = 10)]
        public double Takeprofit { get; set; }

        private RelativeStrengthIndex rsi;
        private double lastHighPrice;
        private double lastLowPrice;
        private double lastRsiHigh;
        private double lastRsiLow;

        protected override void OnStart()
        {
            rsi = Indicators.RelativeStrengthIndex(Source, Periods);
            lastHighPrice = Bars.HighPrices.Last(1);
            lastLowPrice = Bars.LowPrices.Last(1);
            lastRsiHigh = rsi.Result.LastValue;
            lastRsiLow = rsi.Result.LastValue;
        }

        protected override void OnTick()
        {
            var currentRsi = rsi.Result.LastValue;
            var currentHighPrice = Bars.HighPrices.Last(1);
            var currentLowPrice = Bars.LowPrices.Last(1);

            bool bullishDivergence = currentLowPrice < lastLowPrice && currentRsi > lastRsiLow;
            bool bearishDivergence = currentHighPrice > lastHighPrice && currentRsi < lastRsiHigh;

            bool isOrderBlock = DetectOrderBlock();

            if (bullishDivergence && isOrderBlock && currentRsi < 25)
            {
                Close(TradeType.Sell);
                Open(TradeType.Buy);
            }
            else if (bearishDivergence && isOrderBlock && currentRsi > 80)
            {
                Close(TradeType.Buy);
                Open(TradeType.Sell);
            }

            lastHighPrice = currentHighPrice;
            lastLowPrice = currentLowPrice;
            lastRsiHigh = currentRsi > lastRsiHigh ? currentRsi : lastRsiHigh;
            lastRsiLow = currentRsi < lastRsiLow ? currentRsi : lastRsiLow;
        }

        protected override void OnBarClosed()
        {
            if (Bars.Last(0).Close > Bars.Last(0).Open && Bars.Last(1).Close < Bars.Last(1).Open &&
            Bars.Last(0).Close > Bars.Last(1).Open)
            {
                ExecuteMarketOrder(TradeType.Sell, SymbolName, Volume, InstanceId, Stoploss, Takeprofit);
            }

            if (Bars.Last(0).Close < Bars.Last(0).Open && Bars.Last(1).Close > Bars.Last(1).Open &&
            Bars.Last(0).Close < Bars.Last(1).Open)
            {
                ExecuteMarketOrder(TradeType.Buy, SymbolName, Volume, InstanceId, Stoploss, Takeprofit);
            }
        }

        protected override void OnBar()
        {
            //Three White Soldiers
            if (Bars.ClosePrices.Last(1) > Bars.OpenPrices.Last(1)
                && Bars.ClosePrices.Last(2) > Bars.OpenPrices.Last(2)
                && Bars.ClosePrices.Last(3) > Bars.OpenPrices.Last(3))
            {
                ExecuteMarketOrder(TradeType.Buy, SymbolName, Volume, "",Stoploss,Takeprofit);
            }

            //Three Black Crows
            if (Bars.ClosePrices.Last(1) > Bars.OpenPrices.Last(1)
                && Bars.ClosePrices.Last(2) > Bars.OpenPrices.Last(2)
                && Bars.ClosePrices.Last(3) > Bars.OpenPrices.Last(3))
            {
                ExecuteMarketOrder(TradeType.Sell, SymbolName, Volume, "",Stoploss,Takeprofit);
            }
        }

        private bool DetectOrderBlock()
        {
            var recentHigh = Bars.HighPrices.Take(5).Max();
            var recentLow = Bars.LowPrices.Take(5).Min();

            return Bars.ClosePrices.Last(1) > recentHigh || Bars.ClosePrices.Last(1) < recentLow;
        }

        private void Close(TradeType tradeType)
        {
            foreach (var position in Positions.FindAll("RSI", SymbolName, tradeType))
                ClosePosition(position);
        }

        private void Open(TradeType tradeType)
        {
            var position = Positions.Find("RSI", SymbolName, tradeType);
            var volumeInUnits = Symbol.QuantityToVolumeInUnits(Quantity);

            if (position == null)
            {
                var stopLossInPrice = StopLossInPips * Symbol.PipSize;
                var takeProfitInPrice = TakeProfitInPips * Symbol.PipSize;
                ExecuteMarketOrder(tradeType, SymbolName, volumeInUnits, "RSI", stopLossInPrice, takeProfitInPrice);
            }
        }
    }
}