using Moq;
using NUnit.Framework;
using TIProAutoTradeExtension;
using TIProGUI.Tests.Fakes;
using TradeIdeas.MiscSupport;
using TradeIdeas.TIProData.Interfaces;
using TradeIdeas.TIProGUI;

namespace TIProGUI.Tests.Charting.Chart.Robot
{
    [TestFixture]
    public class Robot_SubmitOrderTest
    {
        private IConnectionMaster _fakeConnectionMaster { get; set; }
        private TIProAutoTradeExtension.Robot robot;

        [SetUp]
        public void SetUp()
        {
            SetupTests();
        }


        [Test]
        public void Mkt_Buy_ShareQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "1");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("TotalShares", 1000);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = true;
            model.Shares = 1000;

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }
        
        [Test]
        public void Mkt_Sell_ShareQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "0");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("TotalShares", 1000);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = false;
            model.Shares = 1000;

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }

        [Test]
        public void Mkt_Buy_DollarsQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "1");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("TotalShares", 1);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = true;

            //last 512.405M
            var instrumentLast = 512.405m;
            var quoteQuantity = 1000;
            model.Shares = OrderEntryControl.CalculateSharesFromQuantity(new Instrument("SPY")
            {
                Last = instrumentLast
            }, quoteQuantity);

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }

        [Test]
        public void Mkt_Sell_DollarsQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "0");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("TotalShares", 1);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = false;

            //last 512.405M
            var instrumentLast = 512.405m;
            var quoteQuantity = 1000;
            model.Shares = OrderEntryControl.CalculateSharesFromQuantity(new Instrument("SPY")
            {
                Last = instrumentLast
            }, quoteQuantity);

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }

        [Test]
        public void Lmt_Buy_ShareQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "1");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("EntryLimitPrice", 432);
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("TotalShares", 1000);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = true;
            model.Shares = 1000;
            model.Price = 432;

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }

        [Test]
        public void Lmt_Sell_ShareQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "0");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("EntryLimitPrice", 432);
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("TotalShares", 1000);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = false;
            model.Shares = 1000;
            model.Price = 432;

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }
        
        [Test]
        public void Lmt_Buy_DollarsQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "1");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("EntryLimitPrice", 432);
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("TotalShares", 1);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = true;
            model.Price = 432;

            //last 512.405M
            var instrumentLast = 512.405m;
            var quoteQuantity = 1000;
            model.Shares = OrderEntryControl.CalculateSharesFromQuantity(new Instrument("SPY")
            {
                Last = instrumentLast
            }, quoteQuantity);

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }

        [Test]
        public void Lmt_Sell_DollarsQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "0");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("EntryLimitPrice", 432);
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("TotalShares", 1);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = false;
            model.Price = 432;

            //last 512.405M
            var instrumentLast = 512.405m;
            var quoteQuantity = 1000;
            model.Shares = OrderEntryControl.CalculateSharesFromQuantity(new Instrument("SPY")
            {
                Last = instrumentLast
            }, quoteQuantity);

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }
        
        [Test]
        public void Stp_Buy_ShareQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "1");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("EntryStopPrice", 432);
            expectedRowData.Data.Add("TotalShares", 1000);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = true;
            model.StopPrice = 432;
            model.Shares = 1000;

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }

        [Test]
        public void Stp_Sell_ShareQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "0");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("EntryStopPrice", 432);
            expectedRowData.Data.Add("TotalShares", 1);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = false;
            model.StopPrice = 432;

            //last 512.405M
            var instrumentLast = 512.405m;
            var quoteQuantity = 1000;
            model.Shares = OrderEntryControl.CalculateSharesFromQuantity(new Instrument("SPY")
            {
                Last = instrumentLast
            }, quoteQuantity);

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }
        
        [Test]
        public void Stp_Buy_DollarsQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "1");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("EntryStopPrice", 432);
            expectedRowData.Data.Add("TotalShares", 1);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = true;
            model.StopPrice = 432;

            //last 512.405M
            var instrumentLast = 512.405m;
            var quoteQuantity = 1000;
            model.Shares = OrderEntryControl.CalculateSharesFromQuantity(new Instrument("SPY")
            {
                Last = instrumentLast
            }, quoteQuantity);


            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }

        [Test]
        public void Stp_Sell_DollarsQuantity_OrderEntryModel_Test()
        {
            var expectedRowData = new RowData();

            // Popuplate the expectedRowData from object dump from Robot.BuildOrderEntryTradeSubmitted2RowData
            expectedRowData.Data.Add("SYMBOL", "SPY");
            expectedRowData.Data.Add("TradeDirection", "0");
            expectedRowData.Data.Add("TRADE_SOURCE", "order_entry");
            expectedRowData.Data.Add("MANUALLY_INITIATED", "1");
            expectedRowData.Data.Add("GoodForSeconds", 0);
            expectedRowData.Data.Add("EntryStopPrice", 432);
            expectedRowData.Data.Add("TotalShares", 1000);


            OrderEntryModel model = new OrderEntryModel();
            model.Symbol = "SPY";
            model.Buy = false;
            model.Shares = 1000;
            model.StopPrice = 432;

            var actualRowData = robot.BuildOrderEntryTradeSubmitted2RowData(model);

            // Assert that expectedRowData.Count and actualRowData.Count have same row count
            Assert.That(expectedRowData.Data.Count, Is.EqualTo(actualRowData.Data.Count));

            // Loop over each expectedRowData, assert that it equals the actualRowData 
            foreach (var expetedData in expectedRowData.Data)
            {
                if (actualRowData.Data.TryGetValue(expetedData.Key, out var actualValue))
                {
                    Assert.That(expetedData.Value, Is.EqualTo(actualValue));
                }
                else
                {
                    Assert.Fail();
                }
            }
        }

        private void SetupTests()
        {
            var fakeLoginManager = new Mock<ILoginManager>();
            fakeLoginManager.Setup(x => x.VendorId)
                .Returns("TradIdes");

            var fakeSendManager = new Mock<ISendManager>();
            var symbolDetailsCacheManagerMock = new Mock<ISymbolDetailsCacheManager>();

            _fakeConnectionMaster = new FakeConnectionMaster(fakeLoginManager.Object, fakeSendManager.Object, symbolDetailsCacheManagerMock.Object);
            if (GuiEnvironment.FindConnectionMaster("") == null)
            {
                GuiEnvironment.Add("", _fakeConnectionMaster);
            }

            robot = new TIProAutoTradeExtension.Robot(_fakeConnectionMaster);
        }
    }
}