Martingale UpDowns Close ( Example )

using System;
using System.Threading.Tasks;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class OpenCloseMartingaleStrategy : Robot
    {
        [Parameter("Lot Size", DefaultValue = 0.01, MinValue = 0.01)]
        public double InitialVolume { get; set; }

        [Parameter("Martingale", DefaultValue = 2.0)]
        public double MartingaleMultiplier { get; set; }

        private double _currentVolume;
        private int _consecutiveLosses = 0;
        private double _initialCapital;
        private double _currentCapital;
        private double _lastProfitIncreaseCapital;
        private TradeType _lastTradeType;
        private double _lastTradeProfit;
        private bool _isFirstRun = true;
        private Random _random;

        protected override void OnStart()
        {
            Print("OpenCloseMartingaleStrategy started.");
            _currentVolume = InitialVolume;

            // Initialize capital values
            _initialCapital = Account.Balance;
            _currentCapital = _initialCapital;
            _lastProfitIncreaseCapital = _initialCapital;

            // Initialize random
            _random = new Random();
        }

        protected override void OnBar()
        {
            Print("OnBar called.");

            // Update current capital
            _currentCapital = Account.Balance;
            Print($"Current capital: {_currentCapital}");

            // Close all positions and open new one asynchronously
            foreach (var position in Positions)
            {
                Print($"Processing position: {position.TradeType} at {position.EntryPrice}");
                CloseAndOpenNewPositionAsync(position);
            }

            // If no positions and first run, open a new position with random direction
            if (Positions.Count == 0 && _isFirstRun)
            {
                if (_random.Next(2) == 0)
                {
                    Print("No open positions, opening new Buy position (random).");
                    OpenBuyPosition();
                }
                else
                {
                    Print("No open positions, opening new Sell position (random).");
                    OpenSellPosition();
                }

                _isFirstRun = false;
                return;
            }

            // If no positions and not first run, open a new position with random direction
            if (Positions.Count == 0)
            {
                if (_random.Next(2) == 0)
                {
                    Print("No open positions, opening new Buy position (random).");
                    OpenBuyPosition();
                }
                else
                {
                    Print("No open positions, opening new Sell position (random).");
                    OpenSellPosition();
                }
            }
        }

        private async void CloseAndOpenNewPositionAsync(Position position)
        {
            Print($"Attempting to close position: {position.TradeType} at {position.EntryPrice} with profit: {position.GrossProfit}");
            var closeResult = await ClosePositionAsync(position);

            if (closeResult.IsSuccessful)
            {
                Print($"Position closed successfully: {position.TradeType} at {position.EntryPrice}");

                // Check if the last trade was profitable or not
                if (position.GrossProfit > 0)
                {
                    _lastTradeType = position.TradeType;
                    _lastTradeProfit = position.GrossProfit;
                    _consecutiveLosses = 0; // Reset consecutive losses count
                    _currentVolume = InitialVolume;
                    Print("Profit occurred. Resetting volume and consecutive losses.");
                }
                else
                {
                    _lastTradeType = position.TradeType;
                    _lastTradeProfit = position.GrossProfit;
                    _consecutiveLosses++;

                    if (_consecutiveLosses >= 1) // Fixed value since StartMartingaleAfterLosses is removed
                    {
                        // Apply Martingale
                        _currentVolume = Math.Round(_currentVolume * MartingaleMultiplier, 2);
                        Print($"Applying Martingale. New Volume: {_currentVolume}");
                    }
                }

                // Open new position based on the last trade's result
                if (_lastTradeProfit > 0)
                {
                    // Continue in the same direction if the last trade was profitable
                    if (_lastTradeType == TradeType.Buy)
                    {
                        OpenBuyPosition();
                    }
                    else
                    {
                        OpenSellPosition();
                    }
                }
                else
                {
                    // Reverse direction if the last trade was not profitable
                    if (_lastTradeType == TradeType.Buy)
                    {
                        OpenSellPosition();
                    }
                    else
                    {
                        OpenBuyPosition();
                    }
                }
            }
            else
            {
                Print($"Failed to close position: {position.TradeType} at {position.EntryPrice}");
            }
        }

        private async Task<TradeResult> ClosePositionAsync(Position position)
        {
            var closeResult = ClosePosition(position);
            while (!closeResult.IsSuccessful)
            {
                await Task.Delay(10); // Wait for 10ms before retrying
                closeResult = ClosePosition(position);
            }
            return closeResult;
        }

        private void OpenSellPosition()
        {
            Print($"Opening Sell position with volume {_currentVolume}.");
            var result = ExecuteMarketOrder(TradeType.Sell, SymbolName, _currentVolume, "OpenCloseMartingaleStrategy");
            if (!result.IsSuccessful)
            {
                Print($"Error opening Sell position: {result.Error}");
            }
            else
            {
                Print("Sell position opened successfully.");
            }
        }

        private void OpenBuyPosition()
        {
            Print($"Opening Buy position with volume {_currentVolume}.");
            var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, _currentVolume, "OpenCloseMartingaleStrategy");
            if (!result.IsSuccessful)
            {
                Print($"Error opening Buy position: {result.Error}");
            }
            else
            {
                Print("Buy position opened successfully.");
            }
        }

        protected override void OnStop()
        {
            Print("OpenCloseMartingaleStrategy stopped.");
        }
    }
}