/*
 * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
 * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/

using System;
using System.IO;
using System.Linq;
using NUnit.Framework;
using QuantConnect.Api;
using System.Threading;
using QuantConnect.Orders;
using QuantConnect.Brokerages;
using QuantConnect.Configuration;
using System.Collections.Generic;
using Python.Runtime;
using QuantConnect.Interfaces;

namespace QuantConnect.Tests.API
{
    /// <summary>
    /// API Live endpoint tests
    /// </summary>
    [TestFixture, Explicit("Requires configured api access, a live node to run on, and brokerage configurations.")]
    public class LiveTradingTests : ApiTestBase
    {
        private const bool StopLiveAlgos = true;
        private readonly Dictionary<string, object> _defaultSettings = new()
        {
            { "id", "QuantConnectBrokerage" },
            { "environment", "paper" },
            { "user", "" },
            { "password", "" },
            { "account", "" }
        };
        private readonly ProjectFile _defaultFile = new ProjectFile
        {
            Name = "Main.cs",
            Code = File.ReadAllText("../../../Algorithm.CSharp/BasicTemplateAlgorithm.cs")
        };

        /// <summary>
        /// Live paper trading via Interactive Brokers
        /// </summary>
        [Test]
        public void LiveIBTest()
        {
            var user = Config.Get("ib-user-name");
            var password = Config.Get("ib-password");
            var account = Config.Get("ib-account");
            var environment = account.Substring(0, 2) == "DU" ? "paper" : "live";
            var ib_weekly_restart_utc_time = Config.Get("ib-weekly-restart-utc-time");

            // Create default algorithm settings
            var settings = new Dictionary<string, object>() {
                { "id", "InteractiveBrokersBrokerage" },
                { "ib-trading-mode", environment },
                { "ib-user-name", user },
                { "ib-password", password },
                { "ib-account", account },
                { "ib-weekly-restart-utc-time", ib_weekly_restart_utc_time},
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                },
            };

            var quantConnectDataProvider = new Dictionary<string, object>
            {
                { "id", "QuantConnectBrokerage" },
            };

            var dataProviders = new Dictionary<string, object>
            {
                { "QuantConnectBrokerage", quantConnectDataProvider },
                { "InteractiveBrokersBrokerage", settings }
            };

            RunLiveAlgorithm(settings, _defaultFile, StopLiveAlgos, dataProviders);
        }

        [Test]
        public void PolygonTest()
        {
            var apiKey = Config.Get("polygon-api-key");
            var polygonDataProvider = new Dictionary<string, object>()
            {
                { "id", "Polygon" },
                { "polygon-api-key", apiKey },
            };

            var dataProviders = new Dictionary<string, object>
            {
                { "Polygon", polygonDataProvider },
            };

            RunLiveAlgorithm(_defaultSettings, _defaultFile, StopLiveAlgos, dataProviders);
        }

        [Test]
        public void BinanceTest()
        {
            var apiSecret = Config.Get("binance-api-secret");
            var apiKey = Config.Get("binance-api-key");
            var apiUrl = Config.Get("binance-api-url");
            var websocketUrl = Config.Get("binance-websocket-url");
            var binanceSettings = new Dictionary<string, object>()
            {
                { "id", "BinanceBrokerage" },
                { "binance-use-testnet", "paper" },
                { "binance-exchange-name", "Binance" },
                { "binance-api-secret", apiSecret },
                { "binance-api-key", apiKey },
                { "binance-api-url", apiUrl },
                { "binance-websocket-url", websocketUrl },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                },
            };

            var dataProviders = new Dictionary<string, object>
            {
                { "BinanceBrokerage", binanceSettings },
            };

            RunLiveAlgorithm(binanceSettings, _defaultFile, StopLiveAlgos, dataProviders);
        }

        [Test]
        public void BinanceUSTest()
        {
            var apiSecret = Config.Get("binanceus-api-secret");
            var apiKey = Config.Get("binanceus-api-key");
            var apiUrl = Config.Get("binanceus-api-url");
            var websocketUrl = Config.Get("binanceus-websocket-url");
            var binanceUSSettings = new Dictionary<string, object>()
            {
                { "id", "BinanceBrokerage" },
                { "binance-exchange-name", "BinanceUS" },
                { "binanceus-api-secret", apiSecret },
                { "binanceus-api-key", apiKey },
                { "binanceus-api-url", apiUrl },
                { "binanceus-websocket-url", websocketUrl },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                },
            };

            var dataProviders = new Dictionary<string, object>
            {
                { "BinanceBrokerage", binanceUSSettings },
            };

            RunLiveAlgorithm(binanceUSSettings, _defaultFile, StopLiveAlgos, dataProviders);
        }

        [Test]
        public void BinanceFuturesUSDMTest()
        {
            var apiSecret = Config.Get("binance-api-secret");
            var apiKey = Config.Get("binance-api-key");
            var apiUrl = Config.Get("binance-fapi-url");
            var websocketUrl = Config.Get("binance-fwebsocket-url");
            var binanceSettings = new Dictionary<string, object>()
            {
                { "id", "BinanceBrokerage" },
                { "binance-exchange-name", "Binance-USDM-Futures" },
                { "binance-api-secret", apiSecret },
                { "binance-api-key", apiKey },
                { "binance-fapi-url", apiUrl },
                { "binance-fwebsocket-url", websocketUrl },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                },
            };

            var dataProviders = new Dictionary<string, object>
            {
                { "BinanceBrokerage", binanceSettings },
            };

            RunLiveAlgorithm(binanceSettings, _defaultFile, StopLiveAlgos, dataProviders);
        }

        [Test]
        public void BinanceFuturesCOINTest()
        {
            var apiSecret = Config.Get("binance-api-secret");
            var apiKey = Config.Get("binance-api-key");
            var apiUrl = Config.Get("binance-dapi-url");
            var websocketUrl = Config.Get("binance-dwebsocket-url");
            var binanceSettings = new Dictionary<string, object>()
            {
                { "id", "BinanceBrokerage" },
                { "binance-exchange-name", "Binance-COIN-Futures" },
                { "binance-api-secret", apiSecret },
                { "binance-api-key", apiKey },
                { "binance-dapi-url", apiUrl },
                { "binance-dwebsocket-url", websocketUrl },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                },
            };

            var dataProviders = new Dictionary<string, object>
            {
                { "BinanceBrokerage", binanceSettings },
            };

            RunLiveAlgorithm(binanceSettings, _defaultFile, StopLiveAlgos, dataProviders);
        }

        /// <summary>
        /// Live paper trading via FXCM
        /// </summary>
        [Test]
        public void LiveFXCMTest()
        {
            var user = Config.Get("fxcm-user-name");
            var password = Config.Get("fxcm-password");
            var account = Config.Get("fxcm-account-id");

            // Create default algorithm settings
            var settings = new Dictionary<string, object>() {
                { "id", "FxcmBrokerage" },
                { "environment", "paper" },
                { "user", user },
                { "password", password },
                { "account", account }
            };

            var file = new ProjectFile
            {
                Name = "Main.cs",
                Code = File.ReadAllText("../../../Algorithm.CSharp/BasicTemplateForexAlgorithm.cs")
            };

            RunLiveAlgorithm(settings, file, StopLiveAlgos);
        }

        /// <summary>
        /// Live paper trading via Oanda
        /// </summary>
        [Test]
        public void LiveOandaTest()
        {
            var token = Config.Get("oanda-access-token");
            var account = Config.Get("oanda-account-id");
            var environment = Config.Get("oanda-environment");

            // Create default algorithm settings
            var oandaSettings = new Dictionary<string, object>()
            {
                { "id", "OandaBrokerage" },
                { "oanda-access-token", token },
                { "oanda-account-id", account },
                { "oanda-environment", environment }
            };

            var dataProvider = new Dictionary<string, object>
            {
                { "OandaBrokerage", oandaSettings }
            };

            RunLiveAlgorithm(_defaultSettings, _defaultFile, StopLiveAlgos, dataProvider);
        }

        /// <summary>
        /// Live paper trading via Tradier
        /// </summary>
        [Test]
        public void LiveTradierTest()
        {
            var refreshToken = Config.Get("tradier-refresh-token");
            var account = Config.Get("tradier-account-id");
            var accessToken = Config.Get("tradier-access-token");
            var dateIssued = Config.Get("tradier-issued-at");

            // Create default algorithm settings
            var tradierSettings = new Dictionary<string, object>()
            {
                { "id", "TradierBrokerage" },
                { "tradier-account-id", account },
                { "tradier-access-token", accessToken },
                { "tradier-environment", "paper" },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                }
            };

            var dataProvider = new Dictionary<string, object>()
            {
                { "TradierBrokerage",  tradierSettings}
            };

            RunLiveAlgorithm(tradierSettings, _defaultFile, StopLiveAlgos, dataProvider);
        }

        /// <summary>
        /// Live trading via Bitfinex
        /// </summary>
        [Test]
        public void LiveBitfinexTest()
        {
            var key = Config.Get("bitfinex-api-key");
            var secretKey = Config.Get("bitfinex-api-secret");

            // Create default algorithm settings
            var bitfinexSettings = new Dictionary<string, object>()
            {
                { "id", "BitfinexBrokerage" },
                { "bitfinex-api-secret", secretKey },
                { "bitfinex-api-key", key },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                },
            };

            var dataProvider = new Dictionary<string, object>()
            {
                { "BitfinexBrokerage", bitfinexSettings }
            };

            RunLiveAlgorithm(bitfinexSettings, _defaultFile, StopLiveAlgos, dataProvider);
        }

        /// <summary>
        /// Live trading via Coinbase
        /// </summary>
        [Test]
        public void LiveCoinbaseTest()
        {
            var key = Config.Get("coinbase-api-key");
            var secretKey = Config.Get("coinbase-api-secret");
            var apiUrl = Config.Get("coinbase-rest-api");
            var wsUrl = Config.Get("coinbase-url");

            // Create default algorithm settings
            var coinbaseSettings = new Dictionary<string, object>()
            {
                { "id", "CoinbaseBrokerage" },
                { "coinbase-api-key", key },
                { "coinbase-api-secret", secretKey },
                { "coinbase-rest-api", apiUrl },
                { "coinbase-url", wsUrl },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                }
            };

            var dataProvider = new Dictionary<string, object>
            {
                { "CoinbaseBrokerage", coinbaseSettings }
            };

            RunLiveAlgorithm(coinbaseSettings, _defaultFile, StopLiveAlgos, dataProvider);
        }

        [Test]
        public void KrakenTest()
        {
            var krakenSettings = new Dictionary<string, object>()
            {
                { "id", "KrakenBrokerage" },
                { "kraken-api-key", Config.Get("kraken-api-key") },
                { "kraken-api-secret", Config.Get("kraken-api-secret") },
                { "kraken-verification-tier", Config.Get("kraken-verification-tier") },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                }
            };

            var dataProvider = new Dictionary<string, object>
            {
                { "KrakenBrokerage", krakenSettings }
            };

            RunLiveAlgorithm(krakenSettings, _defaultFile, StopLiveAlgos, dataProvider);
        }

        [Test]
        public void BybitTest()
        {
            var bybitSettings = new Dictionary<string, object>()
            {
                { "id", "BybitBrokerage" },
                { "bybit-api-key", Config.Get("bybit-api-key") },
                { "bybit-api-secret", Config.Get("bybit-api-secret") },
                { "bybit-api-url", Config.Get("bybit-api-url") },
                { "bybit-websocket-url", Config.Get("bybit-websocket-url") },
                { "bybit-use-testnet", "paper" },
                { "bybit-vip-level", "VIP0" },
                { "holdings", new List<Holding>() },
                { "cash", new List<Dictionary<object, object>>()
                    {
                    {new Dictionary<object, object>
                        {
                            { "currency" , "USD"},
                            { "amount", 100000}
                        }
                    }
                    }
                }
            };

            var dataProvider = new Dictionary<string, object>
            {
                { "BybitBrokerage", bybitSettings }
            };

            RunLiveAlgorithm(bybitSettings, _defaultFile, StopLiveAlgos, dataProvider);
        }

        /// <summary>
        /// Test creating the settings object that provide the necessary parameters for each broker
        /// </summary>
        [Test]
        public void LiveAlgorithmSettings_CanBeCreated_Successfully()
        {
            var user = "";
            var password = "";
            var environment = "paper";
            var account = "";
            var key = "";
            var secretKey = "";

            // Oanda Custom Variables
            var accessToken = "";

            // Tradier Custom Variables
            var dateIssued = "";
            var refreshToken = "";

            // Create and test settings for each brokerage
            foreach (BrokerageName brokerageName in Enum.GetValues(typeof(BrokerageName)))
            {
                Dictionary<string, string> settings = null;

                switch (brokerageName)
                {
                    case BrokerageName.Default:
                        user = Config.Get("default-username");
                        password = Config.Get("default-password");
                        settings = new Dictionary<string, string>()
                        {
                            { "id", BrokerageName.Default.ToString() },
                            { "environment", environment },
                            { "user", user },
                            { "password", password },
                            { "account", account }
                        };

                        Assert.IsTrue(settings["id"] == BrokerageName.Default.ToString());
                        break;
                    case BrokerageName.FxcmBrokerage:
                        user = Config.Get("fxcm-user-name");
                        password = Config.Get("fxcm-password");
                        settings = new Dictionary<string, string>()
                        {
                            { "id", BrokerageName.FxcmBrokerage.ToString() },
                            { "environment", environment },
                            { "user", user },
                            { "password", password },
                            { "account", account }
                        };

                        Assert.IsTrue(settings["id"] == BrokerageName.FxcmBrokerage.ToString());
                        break;
                    case BrokerageName.InteractiveBrokersBrokerage:
                        user = Config.Get("ib-user-name");
                        password = Config.Get("ib-password");
                        account = Config.Get("ib-account");
                        settings = new Dictionary<string, string>()
                        {
                            { "id", BrokerageName.InteractiveBrokersBrokerage.ToString() },
                            { "environment", account.Substring(0, 2) == "DU" ? "paper" : "live" },
                            { "user", user },
                            { "password", password },
                            { "acount", account }
                        };

                        Assert.IsTrue(settings["id"] == BrokerageName.InteractiveBrokersBrokerage.ToString());
                        break;
                    case BrokerageName.OandaBrokerage:
                        accessToken = Config.Get("oanda-access-token");
                        account = Config.Get("oanda-account-id");

                        settings = new Dictionary<string, string>()
                        {
                            { "id", BrokerageName.OandaBrokerage.ToStringInvariant() },
                            { "user", "" },
                            { "password", "" },
                            { "environment", environment },
                            { "account", account },
                            { "accessToken", accessToken },
                            { "dateIssued", "1" }
                        };
                        Assert.IsTrue(settings["id"] == BrokerageName.OandaBrokerage.ToString());
                        break;
                    case BrokerageName.TradierBrokerage:
                        dateIssued = Config.Get("tradier-issued-at");
                        refreshToken = Config.Get("tradier-refresh-token");
                        account = Config.Get("tradier-account-id");

                        settings = new Dictionary<string, string>()
                        {
                            { "id", BrokerageName.TradierBrokerage.ToString() },
                            { "user", "" },
                            { "password", "" },
                            { "environment", "live" },
                            { "accessToken", accessToken },
                            { "dateIssued", dateIssued },
                            { "refreshToken", refreshToken },
                            { "lifetime", "86399" },
                            { "account", account }
                        };
                        break;
                    case BrokerageName.Bitfinex:
                        key = Config.Get("bitfinex-api-key");
                        secretKey = Config.Get("bitfinex-api-secret");

                        settings = new Dictionary<string, string>()
                        {
                            { "id", "BitfinexBrokerage" },
                            { "user", "" },
                            { "password", "" },
                            { "environment", "live" },
                            { "key", key },
                            { "secret", secretKey },
                        };
                        break;
                    case BrokerageName.GDAX:
                    case BrokerageName.Coinbase:
                        key = Config.Get("coinbase-api-key");
                        secretKey = Config.Get("coinbase-api-secret");
                        var apiUrl = Config.Get("coinbase-rest-api");
                        var wsUrl = Config.Get("coinbase-url");

                        settings = new Dictionary<string, string>()
                        {
                            { "id",  "CoinbaseBrokerage"},
                            { "user", "" },
                            { "password", "" },
                            { "environment", "live" },
                            { "key", key },
                            { "secret", secretKey },
                            { "apiUrl", (new Uri(apiUrl)).AbsoluteUri },
                            { "wsUrl", (new Uri(wsUrl)).AbsoluteUri }
                        };
                        break;
                    case BrokerageName.AlphaStreams:
                        // No live algorithm settings
                        settings = new Dictionary<string, string>()
                        {
                            { "id", "" },
                            { "user", "" },
                            { "password", "" },
                            { "account", "" }
                        };
                        break;
                    case BrokerageName.Binance:
                        // No live algorithm settings
                        settings = new Dictionary<string, string>()
                        {
                            { "id", "" },
                            { "user", "" },
                            { "password", "" },
                            { "account", "" }
                        };
                        break;
                    default:
                        throw new Exception($"Settings have not been implemented for this brokerage: {brokerageName}");
                }

                // Tests common to all brokerage configuration classes
                Assert.IsTrue(settings != null);
                Assert.IsTrue(settings["password"] == password);
                Assert.IsTrue(settings["user"] == user);

                // Oanda specific settings
                if (brokerageName == BrokerageName.OandaBrokerage)
                {
                    var oandaSetting = settings;
                    Assert.IsTrue(oandaSetting["accessToken"] == accessToken);
                }

                // Tradier specific settings
                if (brokerageName == BrokerageName.TradierBrokerage)
                {
                    var tradierLiveAlogrithmSettings = settings;

                    Assert.IsTrue(tradierLiveAlogrithmSettings["dateIssued"] == dateIssued);
                    Assert.IsTrue(tradierLiveAlogrithmSettings["refreshToken"] == refreshToken);
                    Assert.IsTrue(settings["environment"] == "life");
                }

                // reset variables
                user = "";
                password = "";
                environment = "paper";
                account = "";
            }
        }

        /// <summary>
        /// Reading live algorithm tests
        ///   - Get a list of live algorithms
        ///   - Get logs for the first algorithm returned
        /// Will there always be a live algorithm for the test user?
        /// </summary>
        [Test]
        public void LiveAlgorithmsAndLiveLogs_CanBeRead_Successfully()
        {
            // Read all currently running algorithms
            var liveAlgorithms = ApiClient.ListLiveAlgorithms(AlgorithmStatus.Running);
            var stringRepresentation = liveAlgorithms.ToString();
            Assert.IsTrue(ApiTestBase.IsValidJson(stringRepresentation));

            Assert.IsTrue(liveAlgorithms.Success);
            // There has to be at least one running algorithm
            Assert.IsTrue(liveAlgorithms.Algorithms.Any());

            // Read the logs of the first live algorithm
            var firstLiveAlgo = liveAlgorithms.Algorithms[0];
            var liveLogs = ApiClient.ReadLiveLogs(firstLiveAlgo.ProjectId, firstLiveAlgo.DeployId, 0, 20);
            stringRepresentation = liveLogs.ToString();
            Assert.IsTrue(ApiTestBase.IsValidJson(stringRepresentation));

            Assert.IsTrue(liveLogs.Success);
            Assert.IsTrue(liveLogs.Logs.Any());
            Assert.IsTrue(liveLogs.Length >= 0);
            Assert.IsTrue(liveLogs.DeploymentOffset >= 0);

            Assert.Throws<ArgumentException>(() => ApiClient.ReadLiveLogs(firstLiveAlgo.ProjectId, firstLiveAlgo.DeployId, 0, 251));
        }

        /// <summary>
        /// Runs the algorithm with the given settings and file
        /// </summary>
        /// <param name="settings">Settings for Lean</param>
        /// <param name="file">File to run</param>
        /// <param name="stopLiveAlgos">If true the algorithm will be stopped at the end of the method.
        /// Otherwise, it will keep running</param>
        /// <param name="dataProviders">Dictionary with the data providers and their corresponding credentials</param>
        /// <returns>The id of the project created with the algorithm in</returns>
        private int RunLiveAlgorithm(Dictionary<string, object> settings, ProjectFile file, bool stopLiveAlgos, Dictionary<string, object> dataProviders = null)
        {
            return RunLiveAlgorithm(ApiClient, settings, file, stopLiveAlgos, dataProviders);
        }

        internal static int RunLiveAlgorithm(Api.Api apiClient, Dictionary<string, object> settings, ProjectFile file, bool stopLiveAlgos,
            Dictionary<string, object> dataProviders = null, Language language = Language.CSharp)
        {
            // Create a new project
            var project = apiClient.CreateProject($"Test project - {DateTime.Now.ToStringInvariant()}", language, Globals.OrganizationID);
            var projectId = project.Projects.First().ProjectId;

            // Update Project Files
            var updateProjectFileContent = apiClient.UpdateProjectFileContent(projectId, language == Language.CSharp ? "Main.cs" : "main.py", file.Code);
            Assert.IsTrue(updateProjectFileContent.Success);

            // Create compile
            var compile = apiClient.CreateCompile(projectId);
            Assert.IsTrue(compile.Success);

            // Wait at max 30 seconds for project to compile
            var compileCheck = WaitForCompilerResponse(apiClient, projectId, compile.CompileId, 30);
            Assert.IsTrue(compileCheck.Success);
            Assert.IsTrue(compileCheck.State == CompileState.BuildSuccess);

            // Get a live node to launch the algorithm on
            var nodesResponse = apiClient.ReadProjectNodes(projectId);
            Assert.IsTrue(nodesResponse.Success);
            var freeNode = nodesResponse.Nodes.LiveNodes.Where(x => x.Busy == false);
            Assert.IsNotEmpty(freeNode, "No free Live Nodes found");

            // Create live default algorithm
            var createLiveAlgorithm = apiClient.CreateLiveAlgorithm(projectId, compile.CompileId, freeNode.FirstOrDefault().Id, settings, dataProviders: dataProviders);
            Assert.IsTrue(createLiveAlgorithm.Success);

            if (stopLiveAlgos)
            {
                // Liquidate live algorithm; will also stop algorithm
                var liquidateLive = apiClient.LiquidateLiveAlgorithm(projectId);
                Assert.IsTrue(liquidateLive.Success);

                // Delete the project
                var deleteProject = apiClient.DeleteProject(projectId);
                Assert.IsTrue(deleteProject.Success);
            }

            return projectId;
        }

        [Test]
        public void ReadLiveOrders()
        {
            // Create default algorithm settings
            var settings = new Dictionary<string, object>()
            {
                { "id", "QuantConnectBrokerage" },
                { "environment", "paper" },
                { "user", "" },
                { "password", "" },
                { "account", "" }
            };

            var file = new ProjectFile
            {
                Name = "Main.cs",
                Code = File.ReadAllText("../../../Algorithm.CSharp/BasicTemplateAlgorithm.cs")
            };

            // Run the live algorithm
            var projectId = RunLiveAlgorithm(settings, file, false);

            // Wait to receive the orders
            var readLiveOrders = WaitForReadLiveOrdersResponse(projectId, 60 * 5);
            Assert.IsTrue(readLiveOrders.Any());
            Assert.AreEqual(Symbols.SPY, readLiveOrders.First().Symbol);

            // Liquidate live algorithm; will also stop algorithm
            var liquidateLive = ApiClient.LiquidateLiveAlgorithm(projectId);
            Assert.IsTrue(liquidateLive.Success);

            // Delete the project
            var deleteProject = ApiClient.DeleteProject(projectId);
            Assert.IsTrue(deleteProject.Success);
        }

        [Test]
        public void RunLiveAlgorithmsFromPython()
        {
            var file = new ProjectFile
            {
                Name = "Main.cs",
                Code = File.ReadAllText("../../../Algorithm.CSharp/BasicTemplateAlgorithm.cs")
            };
            // Create a new project
            var project = ApiClient.CreateProject($"Test project - {DateTime.Now.ToStringInvariant()}", Language.CSharp, TestOrganization);
            var projectId = project.Projects.First().ProjectId;

            // Update Project Files
            var updateProjectFileContent = ApiClient.UpdateProjectFileContent(projectId, "Main.cs", file.Code);
            Assert.IsTrue(updateProjectFileContent.Success);

            // Create compile
            var compile = ApiClient.CreateCompile(projectId);
            Assert.IsTrue(compile.Success);

            // Wait at max 30 seconds for project to compile
            var compileCheck = WaitForCompilerResponse(ApiClient, projectId, compile.CompileId, 30);
            Assert.IsTrue(compileCheck.Success);
            Assert.IsTrue(compileCheck.State == CompileState.BuildSuccess);

            // Get a live node to launch the algorithm on
            var nodesResponse = ApiClient.ReadProjectNodes(projectId);
            Assert.IsTrue(nodesResponse.Success);
            var freeNode = nodesResponse.Nodes.LiveNodes.Where(x => x.Busy == false);
            Assert.IsNotEmpty(freeNode, "No free Live Nodes found");

            using (Py.GIL())
            {

                dynamic pythonCall = PyModule.FromString("testModule",
                    @"
from AlgorithmImports import *

def CreateLiveAlgorithmFromPython(apiClient, projectId, compileId, nodeId):
    user = Config.Get('ib-user-name')
    password = Config.Get('ib-password')
    account = Config.Get('ib-account')
    environment = 'paper'
    if account[:2] == 'DU':
        environment = 'live'
    ib_weekly_restart_utc_time = '22:00:00'
    settings = {'id':'InteractiveBrokersBrokerage', 'environment': environment, 'ib-user-name': user, 'ib-password': password, 'ib-account': account, 'ib-weekly-restart-utc-time': ib_weekly_restart_utc_time, 'holdings':[], 'cash': [{'currency' : 'USD', 'amount' : 100000}]}
    dataProviders = {'QuantConnectBrokerage':{'id':'QuantConnectBrokerage'}}
    apiClient.CreateLiveAlgorithm(projectId, compileId, nodeId, settings, dataProviders = dataProviders)
");
                var createLiveAlgorithmModule = pythonCall.GetAttr("CreateLiveAlgorithmFromPython");
                var createLiveAlgorithm = createLiveAlgorithmModule(ApiClient, projectId, compile.CompileId, freeNode.FirstOrDefault().Id);
                Assert.IsTrue(createLiveAlgorithm.Success);

                // Liquidate live algorithm; will also stop algorithm
                var liquidateLive = ApiClient.LiquidateLiveAlgorithm(projectId);
                Assert.IsTrue(liquidateLive.Success);

                // Delete the project
                var deleteProject = ApiClient.DeleteProject(projectId);
                Assert.IsTrue(deleteProject.Success);
            }
        }

        /// <summary>
        /// Wait to receive at least one order
        /// </summary>
        /// <param name="projectId">Id of the project</param>
        /// <param name="seconds">Seconds to allow for receive an order</param>
        /// <returns></returns>
        private List<ApiOrderResponse> WaitForReadLiveOrdersResponse(int projectId, int seconds)
        {
            var readLiveOrders = new List<ApiOrderResponse>();
            var finish = DateTime.UtcNow.AddSeconds(seconds);
            while (DateTime.UtcNow < finish && !readLiveOrders.Any())
            {
                Thread.Sleep(10000);
                readLiveOrders = ApiClient.ReadLiveOrders(projectId);
            }
            return readLiveOrders;
        }
    }
}