Block Order Candle

using System;
using System.Collections.Generic;
using cAlgo.API;
using cAlgo.API.Indicators;

namespace cAlgo
{
    [Indicator(IsOverlay = false, AccessRights = AccessRights.None)]
    public class BlockOrder30 : Indicator
    {
        [Parameter("LookBack Show Block Start", DefaultValue = 5, MinValue = 0, Group = "Blocks")]
        public int LookBackShowBlockStart { get; set; }

        [Parameter("Nbrs Bloc Show", DefaultValue = 10, MinValue = 0, Group = "Blocks")]
        public int NbrsBloc { get; set; }

        [Parameter("True Range Type", DefaultValue = EnumTrType.Fractal_On_Body, Group = "Methode Type")]
        public EnumTrType TrType { get; set; }

        [Parameter("Period Fractal", DefaultValue = 34, MinValue = 1, Group = "Factal")]
        public int Period { get; set; }

        [Parameter("Nbrs Pips True Range", DefaultValue = 34, MinValue = 1, Group = "True Range")]
        public int PipsMaxFunction { get; set; }

        [Parameter("Lookback block Max Size", DefaultValue = 3, MinValue = 0, Group = "Lookback Setting")]
        public int LookbackMaxFunction { get; set; }

        [Parameter("Lookback block Max Size", DefaultValue = "#39FFFF01", MinValue = 0, Group = "Lookback Setting")]
        public Color ColorBlock { get; set; }

        [Output("Result True range", PlotType = PlotType.Line, LineColor = "white")]
        public IndicatorDataSeries ResultTr { get; set; }

        [Output("Result Fractal", PlotType = PlotType.Line, LineColor = "Red")]
        public IndicatorDataSeries ResultFractal { get; set; }

        private IndicatorDataSeries Top, Bottom, Middle, candle, BlockTop, BlockBottom, ResultDcnUp;
        private List<List<double>> block;
        private int barsTot;
        private int prevIndex;

        public enum EnumTrType
        {
            Fractal_On_Body,
            Fractal_On_Body_And_Max,
            Pips_True_Range_Body,
            Pips_True_Range_Body_And_Max,
            Fractal_On_Candle,
            Fractal_On_Candle_And_Max,
            Pips_True_Range_Candle,
            Pips_True_Range_Candle_And_Max,
        }

        protected override void Initialize()
        {
            block = new List<List<double>>();
            candle = CreateDataSeries();
            Top = CreateDataSeries();
            Bottom = CreateDataSeries();
            Middle = CreateDataSeries();
            barsTot = Bars.Count;
            BlockTop = CreateDataSeries();
            BlockBottom = CreateDataSeries();
            ResultDcnUp = CreateDataSeries();
            prevIndex = 0;
        }

        public override void Calculate(int index)
        {
            // Calculate candle values

            if (prevIndex != index)
            {
                if (TrType == EnumTrType.Fractal_On_Body || TrType == EnumTrType.Fractal_On_Body_And_Max || TrType == EnumTrType.Pips_True_Range_Body || TrType == EnumTrType.Pips_True_Range_Body_And_Max)
                    candle[index] = Math.Abs(Bars.ClosePrices.Last(1) - Bars.OpenPrices.Last(1)) / Symbol.PipSize;
                else if (TrType == EnumTrType.Fractal_On_Candle || TrType == EnumTrType.Fractal_On_Candle_And_Max || TrType == EnumTrType.Pips_True_Range_Candle || TrType == EnumTrType.Pips_True_Range_Candle_And_Max)
                    candle[index] = (Bars.HighPrices.Last(1) - Bars.LowPrices.Last(1)) / Symbol.PipSize;

                // Calculate upper and lower levels
                Top[index] = candle.Maximum(Period);
                Bottom[index] = candle.Minimum(Period);
                Middle[index] = (Top[index] - Bottom[index]) / 2 + Bottom[index];

                ResultTr[index - 1] = candle[index];
                ResultDcnUp[index - 1] = Top[index - 1];

                // Determine fractal values
                if (TrType == EnumTrType.Fractal_On_Body || TrType == EnumTrType.Fractal_On_Body_And_Max || TrType == EnumTrType.Fractal_On_Candle || TrType == EnumTrType.Fractal_On_Candle_And_Max)
                {
                    ResultFractal[index - 1] = Top[index - 1];
                    if (candle.Last(1) > ResultDcnUp.Last(1) && candle.Last(2) < ResultDcnUp.Last(2))
                    {
                        AddBlock(index, TrType);
                    }
                }
                else if (TrType == EnumTrType.Pips_True_Range_Body || TrType == EnumTrType.Pips_True_Range_Body_And_Max || TrType == EnumTrType.Pips_True_Range_Candle || TrType == EnumTrType.Pips_True_Range_Candle_And_Max)
                {
                    ResultFractal[index - 1] = PipsMaxFunction;
                    if (candle.Last(1) > PipsMaxFunction && candle.Last(2) < PipsMaxFunction)
                    {
                        AddBlock(index, TrType);
                    }
                }

                // Display blocks based on parameters
                DisplayBlocks(index);

                prevIndex = index;
            }
        }

        private void AddBlock(int index, EnumTrType trType)
        {
            var max = Bars.HighPrices.Last(3);
            var min = Bars.LowPrices.Last(3);

            // Adjust levels if the type includes "And_Max"
            if (trType == EnumTrType.Fractal_On_Body_And_Max || trType == EnumTrType.Pips_True_Range_Body_And_Max ||
                trType == EnumTrType.Fractal_On_Candle_And_Max || trType == EnumTrType.Pips_True_Range_Candle_And_Max)
            {
                for (int i = 0; i < LookbackMaxFunction; i++)
                {
                    max = Math.Max(max, Bars.HighPrices.Last(3 + i));
                    min = Math.Min(min, Bars.LowPrices.Last(3 + i));
                }
            }

            BlockTop[index - 3] = max;
            BlockBottom[index - 3] = min;
            block.Add(new List<double> { max, min, index - 3 });
        }

        private void DisplayBlocks(int index)
        {
            if (block.Count > LookBackShowBlockStart)
            {
                int start = block.Count - LookBackShowBlockStart - NbrsBloc;
                start = Math.Max(0, start);

                int end = block.Count - LookBackShowBlockStart;

                for (int i = start; i < end; i++)
                {
                    var blocStartIndex = (int)block[i][2];
                    var highPrice = block[i][0];
                    var lowPrice = block[i][1];
                    Chart.DrawRectangle("Bloc " + i, blocStartIndex, highPrice, index, lowPrice, ColorBlock).IsFilled = true;
                }

                for (int j = 0; j < start; j++)
                {
                    Chart.RemoveObject("Bloc " + j);
                }

            }
        }
    }
}