MAfast&slow crossing with Hedging (Beta)

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

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

        [Parameter("MAType")]
        public MovingAverageType MAType { get; set; }

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

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

        [Parameter("Max open Positions", DefaultValue = 6)]
        public int maxPos { get; set; }

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

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

        [Parameter("Use hedging", DefaultValue = true)]
        public bool ifHedeging { get; set; }

        [Parameter("Close on hedeging breake even", DefaultValue = false)]
        public bool brakeEven { get; set; }

        [Parameter("Hedge on SL", DefaultValue = true)]
        public bool slHedeging { get; set; }

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

        [Parameter()]
        public DataSeries SourceSeries { get; set; }

        private double headvolume;
        private double headQuantity;
        private bool inHedeging = false;
        private MovingAverage slowMa;
        private MovingAverage fastMa;
        private bool lastPositionBuy;
        private int sellPos;
        private int buyPos;
        private bool inBuy;
        private double tempSL;

        protected override void OnStart()
        {
            fastMa = Indicators.MovingAverage(SourceSeries, FastPeriods, MAType);
            slowMa = Indicators.MovingAverage(SourceSeries, SlowPeriods, MAType);
            headvolume = Quantity;
            tempSL = SL;
        }

        protected override void OnTick()
        {

            if ((Account.Equity > (Account.Balance + TP)) || (!slHedeging && (Account.Equity < (Account.Balance - SL))))
            {
                Close();
            }
            if (Account.Equity > (Account.Balance) && inHedeging && brakeEven)
            {
                Close();
            }
        }

        protected override void OnBar()
        {
            if ((Account.Balance - Account.Equity) > tempSL && slHedeging && ifHedeging)
            {
                Head();
            }

            var currentSlowMa = slowMa.Result.Last(0);
            var currentFastMa = fastMa.Result.Last(0);
            var previousSlowMa = slowMa.Result.Last(1);
            var previousFastMa = fastMa.Result.Last(1);

            if (previousSlowMa > previousFastMa && currentSlowMa <= currentFastMa)
            {
                Open(TradeType.Buy);
                inBuy = true;
                buyPos = +1;
                lastPositionBuy = true;

            }
            //SELL
            else if (previousSlowMa < previousFastMa && currentSlowMa >= currentFastMa)
            {
                Open(TradeType.Sell);
                inBuy = false;
                sellPos = +1;

            }
        }

        private void Close()
        {
            //Closeing all
            foreach (var position in Positions)
            {
                ClosePosition(position);
            }
            maxPos = 0;
            inHedeging = false;
            buyPos = 0;
            sellPos = 0;
            inBuy = false;

        }

        private void Open(TradeType tradeType)
        {
            double volumeInUnits = Symbol.QuantityToVolumeInUnits(Quantity);
            // lyckades öppna sell och open
            if (Positions.Count <= 0 && !inHedeging)
            {
                ExecuteMarketOrder(tradeType, Symbol, volumeInUnits, "RSI");
                headvolume = Quantity + 0.01;
            }
            else if (Positions.Count > 0 && Account.Equity < Account.Balance)
            {
                Head();
            }

        }
        private void Head()
        {
            headvolume = headvolume * 2;
            headQuantity = Symbol.QuantityToVolumeInUnits(headvolume);
            inHedeging = true;

            if (ifHedeging && buyPos <= sellPos && !lastPositionBuy)
            {
                ExecuteMarketOrder(TradeType.Buy, Symbol, headQuantity, "Hedging buy");
                lastPositionBuy = true;
                tempSL = Account.Balance - Account.Equity + SL;
                buyPos = +1;
            }
            else if (ifHedeging && buyPos >= sellPos && lastPositionBuy)
            {
                ExecuteMarketOrder(TradeType.Sell, Symbol, headQuantity, "Hedging Sell");
                lastPositionBuy = false;
                tempSL = Account.Balance - Account.Equity + SL;
                sellPos = +1;
            }
        }
    }
}