/// <summary>
 /// Initializes a new instance of the <see cref="SubmitTradeRequest"/> class.
 /// </summary>
 /// <param name="tradepairId">The Cryptopia tradepair identifier.</param>
 /// <param name="type">The type of trade.</param>
 /// <param name="amount">The amount of coins.</param>
 /// <param name="rate">The price of the coins.</param>
 public SubmitTradeRequest(int tradepairId, TradeType type, decimal amount, decimal rate)
 {
     TradePairId = tradepairId;
     Type = type;
     Amount = amount;
     Rate = rate;
 }

        private void ExecuteOrder(long volume, TradeType tradeType)
        {
            var result = ExecuteMarketOrder(tradeType, Symbol, volume, "Alembex", StopLoss, TakeProfit);

            if (result.Error == ErrorCode.NoMoney)
                Stop();
        }

 internal Trade(double price, double amount, DateTime time, TradeType type)
 {
     Price = price;
     Amount = amount;
     Type = type;
     Time = time;
 }

        private void Open(TradeType tradeType)
        {
            var position = Positions.Find("SampleRSI", Symbol, tradeType);

            if (position == null)
                ExecuteMarketOrder(tradeType, Symbol, Volume, "SampleRSI");
        }

 public Order(BtcePair pair, TradeType type, decimal amount, decimal rate, UInt32 timestamp, int status)
 {
     Pair = pair;
     Amount = amount;
     Rate = rate;
     TimestampCreated = timestamp;
     Status = status;
 }

 /// <summary>
 /// Initialize <see cref="Trade"/> class.
 /// </summary>
 /// <param name="clientName">Client name.</param>
 public Trade(string clientName, IDigicoinBroker broker, TradeType type, int order, decimal value)
 {
     ClientName = clientName;
     Broker = broker;
     Type = type;
     Order = order;
     Value = value;
 }

        private void ExecuteOrder(double quantity, TradeType tradeType)
        {
            var volumeInUnits = Symbol.QuantityToVolume(quantity);
            var result = ExecuteMarketOrder(tradeType, Symbol, volumeInUnits, "Martingale", StopLoss, TakeProfit);

            if (result.Error == ErrorCode.NoMoney)
                Stop();
        }

 /// <summary>
 /// Initializes a new instance of the Buy class.
 /// </summary>
 /// <param name="stockPoint">The stock point for the purchase.</param>
 /// <param name="tradeTypes">The type of the buy: short or long.</param>
 /// <param name="shares">The number of shares purchased.</param>
 public Buy(StockPoint stockPoint, TradeType tradeType, int shares)
 {
     this.Date = stockPoint.Date;
     this.Time = stockPoint.PointDateTime.AddMinutes(-5).ToString("HH:mm");
     this.Price = stockPoint.Open;
     this.TradeType = tradeType;
     this.Shares = shares;
 }

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

            if (position == null)
                ExecuteMarketOrder(tradeType, Symbol, volumeInUnits, "SampleRSI");
        }

        public static string ToString(TradeType v)
        {
            if (v == TradeType.Sell)
                return "sell";
            if (v == TradeType.Buy)
                return "buy";

            throw new NotSupportedException();
        }

        private void ExecuteOrder(TradeType tradeType, long volume, string prefixLabel = partialLabel)
        {
            int parties = 6, part1 = 2, part2 = 2;
			long partialVolume = Symbol.NormalizeVolume(volume/parties,RoundingMode.ToNearest);

            var result1 = ExecuteMarketOrder(tradeType, Symbol, partialVolume * part1, prefixLabel + "1");
            var result2 = ExecuteMarketOrder(tradeType, Symbol, partialVolume * part2, prefixLabel + "2");
            var result3 = ExecuteMarketOrder(tradeType, Symbol, volume - (part1 + part2) * partialVolume, prefixLabel + "3");
        }

        private decimal Trade(string clientName, TradeType type, int order)
        {
            Validate(clientName, order);

            var hundreds = (int)(order / 100);
            var result = TradeHundrets(clientName, type, order, hundreds);
            result = TradeTens(clientName, type, order, hundreds, result);

            return result;
        }

 public Trade(BtcePair pair, TradeType type, decimal amount, decimal rate, int orderId, bool isYourOrder, UInt32 timestamp)
 {
     Pair = pair;
     Type = type;
     Amount = amount;
     Rate = rate;
     OrderId = orderId;
     IsYourOrder = isYourOrder;
     Timestamp = timestamp;
 }

        public void TestDisplayName()
        {
            Assert.AreEqual("Trailer (TR)", new TradeType { Code = "TR", Name = "Trailer" }.DisplayName);
            Assert.AreEqual("Buy (B)", new TradeType { Code = "\r B\n\r", Name = "\t  Buy\t\n\r" }.DisplayName);
            Assert.AreEqual("Surrender", new TradeType { Name = "Surrender" }.DisplayName);
            Assert.AreEqual("BUY", new TradeType { Code = "BUY" }.DisplayName);

            var tradeType = new TradeType { Name = "   " };
            Assert.AreEqual("TradeType (Id: '{0}')".Form(tradeType.Id.ToString()), tradeType.DisplayName);
        }

        private void manageOpen(TradeType tradeType, long volume, string prefixLabel = botLabel)
        {
            int nVolumePartition = 10, part1 = 5, part2 = 3;
            long nVol = (long)Math.Floor((double)(volume / (microVolume * nVolumePartition)));
            long partialVolume = nVol * microVolume;

            var result1 = ExecuteMarketOrder(tradeType, Symbol, partialVolume * part1, prefixLabel + tradeType.ToString() + "-1");
            var result2 = ExecuteMarketOrder(tradeType, Symbol, partialVolume * part2, prefixLabel + tradeType.ToString() + "-2");
            var result3 = ExecuteMarketOrder(tradeType, Symbol, volume - (part1 + part2) * partialVolume, prefixLabel + tradeType.ToString() + "-3");
        }

 public TradeCoinRequest(string fromCoin, string toCoin, TradeType tradeType, TradeSide tradeSide, decimal tradePrice, decimal units, TradeLevel tradeLevel)
 {
     this.FromCoinSymbol = fromCoin;
     this.ToCoinSymbol = toCoin;
     this.TradeType = (int)tradeType;
     this.TradeSide = (int)tradeSide;
     this.TradePrice = tradePrice;
     this.Units = units;
     this.TradeLevel = (int)tradeLevel;
 }

        public Trade(bool sim, int _lotDigits, string _logFileName, NQuotes.MqlApi mql4) : base(mql4)
        {
            this.logFileName = _logFileName;
            this.tradeType = TradeType.FLAT;
            this.startingBalance = mql4.AccountBalance();
            this.endingBalance = 0;
            this.lotDigits = _lotDigits;
            this.state = null;
            this.actualEntry = -1;
            this.actualClose = -1;
            this.takeProfit = 0;
            this.cancelPrice = 0;
            this.initialProfitTarget = 0;
            this.plannedEntry = 0;
            this.stopLoss = 0;
            this.originalStopLoss = 0;
            this.positionSize = 0;
            this.logSize = 0;
            this.realizedPL = 0.0;
            this.minUnrealizedPL = 0.0;
            this.maxUnrealizedPL = 0.0;
            this.spreadOrderOpen = -1;
            this.spreadOrderClose = -1;

            this.tradeOpenedDate = mql4.TimeCurrent();
            this.orderPlacedDate = new DateTime();
            this.orderFilledDate = new DateTime();
            this.tradeClosedDate = new DateTime();

            this.finalState = false;



            if (sim)
            {
                this.order = new biiuse.SimOrder(this, mql4);
                this.id = "SIM_" + mql4.Symbol() + (mql4.TimeCurrent() + TimeSpan.FromSeconds(OFFSET)).ToString();
            }
            else
            {
                this.order = new Order(this, mql4);
                this.id = mql4.Symbol() + (mql4.TimeCurrent() + TimeSpan.FromSeconds(OFFSET)).ToString();
            }

            if (!mql4.IsTesting())
            {
                string filename = mql4.Symbol() + "_" + mql4.TimeCurrent().ToString();
                int filehandle = mql4.FileOpen(filename, MqlApi.FILE_WRITE | MqlApi.FILE_READ | MqlApi.FILE_TXT);
                mql4.FileSeek(filehandle, 0, MqlApi.SEEK_END);
                string output = "****Trade: " + this.id + " ****";
                mql4.FileWriteString(filehandle, output, output.Length);
                mql4.FileWriteString(filehandle, "\n", 1);
                mql4.FileClose(filehandle);
            }
        }

 /// <summary>
 ///     Constructor
 /// </summary>
 /// <param name="ticker">The stock ticker symbol</param>
 /// <param name="shares">The number of shares to trade</param>
 /// <param name="tradeTradeType">TradeType.Buy or TradeType.Sell</param>
 /// <param name="tradeStatus">
 ///     A TradeStatus enum that describes the status of the
 ///     Trade
 /// </param>
 /// <param name="tadingSessionId">
 ///     Each trading session is given a unique identifier of type, Guid.
 ///     Either create a TradingSessionId if you are starting a trade. Or pass in the existing
 ///     TradingSessionId if you are part of a trade.
 /// </param>
 /// <param name="message">An arbitrary message</param>
 protected AbstractTrade(string ticker, int shares, TradeType tradeTradeType, TradeStatus tradeStatus,
     Guid tadingSessionId, string message = null)
 {
     Ticker = ticker;
     Shares = shares;
     TradeType = tradeTradeType;
     TadingSessionId = tadingSessionId;
     CreateTime = DateTime.UtcNow;
     TradeStatus = tradeStatus;
     Message = message;
 }

        private void ExecuteOrder(int volume, TradeType tradeType)
        {
            var request = new MarketOrderRequest(tradeType, volume)
            {
                Label = "BerthoRobot",
                StopLossPips = StopLoss,
                TakeProfitPips = TakeProfit
            };
            Trade.Send(request);

        }

 public TradeCoinResponse New(string fromCoin, string toCoin, TradeType tradeType, TradeSide tradeSide, decimal tradePrice, decimal units, TradeLevel tradeLevel)
 {
     return
         this.CallMethod<TradeCoinResponse>(
             new RequestBuilder(RequestType.POST, "order/new")
             .AddUrlSegment(new CoinsPairSegment(fromCoin, toCoin))
             .AddUrlSegment(tradeType)
             .AddUrlSegment(tradeSide)
             .AddUrlSegment(tradePrice)
             .AddUrlSegment(units)
             .AddUrlSegment(tradeLevel));
 }