/*
 * 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.Collections.Generic;
using System.Linq;
using NodaTime;
using NUnit.Framework;
using QuantConnect.Data;
using QuantConnect.Data.Market;
using QuantConnect.Securities;
using QuantConnect.Orders.Fills;
using QuantConnect.Orders.Fees;
using QuantConnect.Orders.Slippage;
using QuantConnect.Securities.Option;
using QuantConnect.Indicators;
using Microsoft.CSharp.RuntimeBinder;
using Python.Runtime;
using QuantConnect.Statistics;

namespace QuantConnect.Tests.Common.Securities
{
    [TestFixture]
    public class SecurityTests
    {
        [Test]
        public void SimplePropertiesTests()
        {
            var exchangeHours = SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork);
            var config = CreateTradeBarConfig();
            var security = new Security(
                exchangeHours,
                config,
                new Cash(Currencies.USD, 0, 1m),
                SymbolProperties.GetDefault(Currencies.USD),
                ErrorCurrencyConverter.Instance,
                RegisteredSecurityDataTypesProvider.Null,
                new SecurityCache()
            );

            Assert.AreEqual(config, security.Subscriptions.Single());
            Assert.AreEqual(config.Symbol, security.Symbol);
            Assert.AreEqual(config.SecurityType, security.Type);
            Assert.AreEqual(config.Resolution, security.Resolution);
            Assert.AreEqual(config.FillDataForward, security.IsFillDataForward);
            Assert.AreEqual(exchangeHours, security.Exchange.Hours);
        }

        [Test]
        public void ConstructorTests()
        {
            var security = GetSecurity();

            Assert.IsNotNull(security.Exchange);
            Assert.IsInstanceOf<SecurityExchange>(security.Exchange);
            Assert.IsNotNull(security.Cache);
            Assert.IsInstanceOf<SecurityCache>(security.Cache);
            Assert.IsNotNull(security.PortfolioModel);
            Assert.IsInstanceOf<SecurityPortfolioModel>(security.PortfolioModel);
            Assert.IsNotNull(security.FillModel);
            Assert.IsInstanceOf<ImmediateFillModel>(security.FillModel);
            Assert.IsNotNull(security.PortfolioModel);
            Assert.IsInstanceOf<InteractiveBrokersFeeModel>(security.FeeModel);
            Assert.IsNotNull(security.SlippageModel);
            Assert.IsInstanceOf<NullSlippageModel>(security.SlippageModel);
            Assert.IsNotNull(security.SettlementModel);
            Assert.IsInstanceOf<ImmediateSettlementModel>(security.SettlementModel);
            Assert.IsNotNull(security.BuyingPowerModel);
            Assert.IsInstanceOf<SecurityMarginModel>(security.BuyingPowerModel);
            Assert.IsNotNull(security.DataFilter);
            Assert.IsInstanceOf<SecurityDataFilter>(security.DataFilter);
        }

        [Test]
        public void HoldingsTests()
        {
            var security = GetSecurity();

            // Long 100 stocks test
            security.Holdings.SetHoldings(100m, 100);

            Assert.AreEqual(100m, security.Holdings.AveragePrice);
            Assert.AreEqual(100, security.Holdings.Quantity);
            Assert.IsTrue(security.HoldStock);
            Assert.IsTrue(security.Invested);
            Assert.IsTrue(security.Holdings.IsLong);
            Assert.IsFalse(security.Holdings.IsShort);

            // Short 100 stocks test
            security.Holdings.SetHoldings(100m, -100);

            Assert.AreEqual(100m, security.Holdings.AveragePrice);
            Assert.AreEqual(-100, security.Holdings.Quantity);
            Assert.IsTrue(security.HoldStock);
            Assert.IsTrue(security.Invested);
            Assert.IsFalse(security.Holdings.IsLong);
            Assert.IsTrue(security.Holdings.IsShort);

            // Flat test
            security.Holdings.SetHoldings(100m, 0);

            Assert.AreEqual(100m, security.Holdings.AveragePrice);
            Assert.AreEqual(0, security.Holdings.Quantity);
            Assert.IsFalse(security.HoldStock);
            Assert.IsFalse(security.Invested);
            Assert.IsFalse(security.Holdings.IsLong);
            Assert.IsFalse(security.Holdings.IsShort);
        }

        [TestCase(1)]
        [TestCase(-1)]
        public void QuantityBelowLotSizeNotInvested(int side)
        {
            var security = GetSecurity();
            var belowMinimumLotSize = security.SymbolProperties.LotSize - 0.001m;
            security.Holdings.SetHoldings(100m, belowMinimumLotSize * side);

            Assert.AreEqual(100m, security.Holdings.AveragePrice);
            Assert.AreEqual(belowMinimumLotSize * side, security.Holdings.Quantity);
            Assert.IsFalse(security.HoldStock);
            Assert.IsFalse(security.Invested);
            Assert.IsFalse(security.Holdings.Invested);
            Assert.IsFalse(security.Holdings.HoldStock);

            security.Holdings.SetHoldings(100m, security.SymbolProperties.LotSize * side);
            Assert.AreEqual(security.SymbolProperties.LotSize * side, security.Holdings.Quantity);
            Assert.IsTrue(security.HoldStock);
            Assert.IsTrue(security.Invested);
            Assert.IsTrue(security.Holdings.HoldStock);
            Assert.IsTrue(security.Holdings.Invested);
        }

        [Test]
        public void UpdatingSecurityPriceTests()
        {
            var security = GetSecurity();

            // Update securuty price with a TradeBar
            security.SetMarketPrice(new TradeBar(DateTime.Now, Symbols.SPY, 101m, 103m, 100m, 102m, 100000));

            Assert.AreEqual(101m, security.Open);
            Assert.AreEqual(103m, security.High);
            Assert.AreEqual(100m, security.Low);
            Assert.AreEqual(102m, security.Close);
            Assert.AreEqual(100000, security.Volume);

            // High/Close property is only modified by IBar instances
            security.SetMarketPrice(new Tick(DateTime.Now, Symbols.SPY, 104m, 104m, 104m));
            Assert.AreEqual(103m, security.High);
            Assert.AreEqual(102m, security.Close);
            Assert.AreEqual(104m, security.Price);

            // Low/Close property is only modified by IBar instances
            security.SetMarketPrice(new Tick(DateTime.Now, Symbols.SPY, 99m, 99m, 99m));
            Assert.AreEqual(100m, security.Low);
            Assert.AreEqual(102m, security.Close);
            Assert.AreEqual(99m, security.Price);
        }

        [Test]
        public void SetLeverageTest()
        {
            var security = GetSecurity();

            security.SetLeverage(4m);
            Assert.AreEqual(4m,security.Leverage);

            security.SetLeverage(5m);
            Assert.AreEqual(5m, security.Leverage);

            Assert.That(() => security.SetLeverage(0.1m),
                Throws.TypeOf<ArgumentException>().With.Message.EqualTo("Leverage must be greater than or equal to 1."));
        }

        [Test]
        public void DefaultDataNormalizationModeForOptionsIsRaw()
        {
            var option = new Option(
                SecurityExchangeHours.AlwaysOpen(DateTimeZone.Utc),
                new SubscriptionDataConfig(
                    typeof(TradeBar),
                    Symbols.SPY_P_192_Feb19_2016,
                    Resolution.Minute,
                    DateTimeZone.Utc,
                    DateTimeZone.Utc,
                    true,
                    false,
                    false
                ),
                new Cash(Currencies.USD, 0, 1m),
                new OptionSymbolProperties(SymbolProperties.GetDefault(Currencies.USD)),
                ErrorCurrencyConverter.Instance,
                RegisteredSecurityDataTypesProvider.Null
            );

            Assert.AreEqual(option.DataNormalizationMode, DataNormalizationMode.Raw);
        }

        [Test]
        public void SetDataNormalizationForOptions()
        {
            var option = new Option(
                SecurityExchangeHours.AlwaysOpen(DateTimeZone.Utc),
                new SubscriptionDataConfig(
                    typeof(TradeBar),
                    Symbols.SPY_P_192_Feb19_2016,
                    Resolution.Minute,
                    DateTimeZone.Utc,
                    DateTimeZone.Utc,
                    true,
                    false,
                    false
                ),
                new Cash(Currencies.USD, 0, 1m),
                new OptionSymbolProperties(SymbolProperties.GetDefault(Currencies.USD)),
                ErrorCurrencyConverter.Instance,
                RegisteredSecurityDataTypesProvider.Null
            );

            Assert.DoesNotThrow(() => { option.SetDataNormalizationMode(DataNormalizationMode.Raw); });

            Assert.Throws(typeof(ArgumentException), () => { option.SetDataNormalizationMode(DataNormalizationMode.Adjusted); });
            Assert.Throws(typeof(ArgumentException), () => { option.SetDataNormalizationMode(DataNormalizationMode.SplitAdjusted); });
            Assert.Throws(typeof(ArgumentException), () => { option.SetDataNormalizationMode(DataNormalizationMode.Adjusted); });
            Assert.Throws(typeof(ArgumentException), () => { option.SetDataNormalizationMode(DataNormalizationMode.TotalReturn); });
        }

        [Test]
        public void SetDataNormalizationForEquities()
        {
            var equity = new QuantConnect.Securities.Equity.Equity(
                SecurityExchangeHours.AlwaysOpen(DateTimeZone.Utc),
                new SubscriptionDataConfig(
                    typeof(TradeBar),
                    Symbols.SPY,
                    Resolution.Minute,
                    DateTimeZone.Utc,
                    DateTimeZone.Utc,
                    true,
                    false,
                    false
                ),
                new Cash(Currencies.USD, 0, 1m),
                SymbolProperties.GetDefault(Currencies.USD),
                ErrorCurrencyConverter.Instance,
                RegisteredSecurityDataTypesProvider.Null
            );

            Assert.DoesNotThrow(() => { equity.SetDataNormalizationMode(DataNormalizationMode.Raw); });
            Assert.DoesNotThrow(() => { equity.SetDataNormalizationMode(DataNormalizationMode.Adjusted); });
            Assert.DoesNotThrow(() => { equity.SetDataNormalizationMode(DataNormalizationMode.SplitAdjusted); });
            Assert.DoesNotThrow(() => { equity.SetDataNormalizationMode(DataNormalizationMode.Adjusted); });
            Assert.DoesNotThrow(() => { equity.SetDataNormalizationMode(DataNormalizationMode.TotalReturn); });
        }

        [Test]
        public void TickQuantityUpdatedInSecurityCache()
        {
            var tick1 = new Tick();
            tick1.Update(1, 1, 1, 10, 1, 1);

            var tick2 = new Tick();
            tick2.Update(1, 1, 1, 20, 1, 1);

            var securityCache = new SecurityCache();

            Assert.AreEqual(0, securityCache.Volume);

            securityCache.AddData(tick1);

            Assert.AreEqual(10, securityCache.Volume);

            securityCache.AddData(tick2);

            Assert.AreEqual(20, securityCache.Volume);
        }

        [Test]
        public void InvokingCacheStoreData_UpdatesSecurityData_ByTypeName()
        {
            var security = GetSecurity();
            var tradeBars = new List<TradeBar>
            {
                new TradeBar(DateTime.UtcNow, security.Symbol, 10m, 20m, 5m, 15m, 10000)
            };

            security.Cache.StoreData(tradeBars, typeof(TradeBar));

            TradeBar fromSecurityData = security.Data.GetAll<TradeBar>()[0];
            Assert.AreEqual(tradeBars[0].Time, fromSecurityData.Time);
            Assert.AreEqual(tradeBars[0].Symbol, fromSecurityData.Symbol);
            Assert.AreEqual(tradeBars[0].Open, fromSecurityData.Open);
            Assert.AreEqual(tradeBars[0].High, fromSecurityData.High);
            Assert.AreEqual(tradeBars[0].Low, fromSecurityData.Low);
            Assert.AreEqual(tradeBars[0].Close, fromSecurityData.Close);
            Assert.AreEqual(tradeBars[0].Volume, fromSecurityData.Volume);

            // using dynamic accessor
            var fromDynamicSecurityData = security.Data.TradeBar[0];
            Assert.AreEqual(tradeBars[0].Time, fromDynamicSecurityData.Time);
            Assert.AreEqual(tradeBars[0].Symbol, fromDynamicSecurityData.Symbol);
            Assert.AreEqual(tradeBars[0].Open, fromDynamicSecurityData.Open);
            Assert.AreEqual(tradeBars[0].High, fromDynamicSecurityData.High);
            Assert.AreEqual(tradeBars[0].Low, fromDynamicSecurityData.Low);
            Assert.AreEqual(tradeBars[0].Close, fromDynamicSecurityData.Close);
            Assert.AreEqual(tradeBars[0].Volume, fromDynamicSecurityData.Volume);
        }

        private static TestCaseData[] IsMarketOpenWithMarketDataTestCases => new[]
        {
            // Without extended market hours
            new TestCaseData(new TimeSpan(3, 59, 59), false, false),
            new TestCaseData(new TimeSpan(4, 0, 0), false, false),
            new TestCaseData(new TimeSpan(9, 29, 59), false, false),
            new TestCaseData(new TimeSpan(9, 30, 0), false, true),
            new TestCaseData(new TimeSpan(15, 59, 59), false, true),
            new TestCaseData(new TimeSpan(16, 0, 0), false, false),
            new TestCaseData(new TimeSpan(19, 59, 59), false, false),
            new TestCaseData(new TimeSpan(20, 0, 0), false, false),
            new TestCaseData(new TimeSpan(21, 0, 0), false, false),
            // With extended market hours
            new TestCaseData(new TimeSpan(3, 59, 59), true, false),
            new TestCaseData(new TimeSpan(4, 0, 0), true, true),
            new TestCaseData(new TimeSpan(9, 29, 59), true, true),
            new TestCaseData(new TimeSpan(9, 30, 0), true, true),
            new TestCaseData(new TimeSpan(15, 59, 59), true, true),
            new TestCaseData(new TimeSpan(16, 0, 0), true, true),
            new TestCaseData(new TimeSpan(19, 59, 59), true, true),
            new TestCaseData(new TimeSpan(20, 0, 0), true, false),
            new TestCaseData(new TimeSpan(21, 0, 0), true, false),
        };

        [TestCaseSource(nameof(IsMarketOpenWithMarketDataTestCases))]
        public void IsMarketOpenIsAccurate(TimeSpan time, bool extendedMarketHours, bool expected)
        {
            var security = GetSecurity(isMarketAlwaysOpen: false);

            var dateTime = new DateTime(2023, 6, 26) + time;
            var timeKeeper = new LocalTimeKeeper(dateTime.ConvertToUtc(security.Exchange.TimeZone), security.Exchange.TimeZone);
            security.SetLocalTimeKeeper(timeKeeper);

            Assert.AreEqual(expected, security.IsMarketOpen(extendedMarketHours));
        }

        #region Custom properties tests

        [Test]
        public void SetsAndGetsDynamicCustomPropertiesUsingCacheInterface()
        {
            var security = GetSecurity();
            security.Cache.Properties.Add("Bool", true);
            security.Cache.Properties.Add("Integer", 1);
            security.Cache.Properties.Add("Double", 2.0);
            security.Cache.Properties.Add("Decimal", 3.0m);
            security.Cache.Properties.Add("String", "4");
            security.Cache.Properties.Add("DateTime", DateTime.UtcNow);
            security.Cache.Properties.Add("EMA", new ExponentialMovingAverage(10));

            Assert.AreEqual(7, security.Cache.Properties.Count);
            Assert.IsTrue(security.Cache.Properties.ContainsKey("Bool"));
            Assert.IsTrue(security.Cache.Properties.ContainsKey("Integer"));
            Assert.IsTrue(security.Cache.Properties.ContainsKey("Double"));
            Assert.IsTrue(security.Cache.Properties.ContainsKey("Decimal"));
            Assert.IsTrue(security.Cache.Properties.ContainsKey("String"));
            Assert.IsTrue(security.Cache.Properties.ContainsKey("DateTime"));
            Assert.IsTrue(security.Cache.Properties.ContainsKey("EMA"));

            Assert.IsFalse(security.Cache.Properties.ContainsKey("NotAProperty"));
        }

        [Test]
        public void SetsAndGetsDynamicCustomPropertiesUsingDynamicInterface()
        {
            var security = GetSecurity();
            dynamic dynamicSecurity = security;
            dynamicSecurity.Bool = true;
            dynamicSecurity.Integer = 1;
            dynamicSecurity.Double = 2.0;
            dynamicSecurity.Decimal = 3.0m;
            dynamicSecurity.String = "string";
            dynamicSecurity.DateTime = new DateTime(2023, 06, 20);
            dynamicSecurity.EMA = new ExponentialMovingAverage(10);

            Assert.AreEqual(true, dynamicSecurity.Bool);
            Assert.AreEqual(1, dynamicSecurity.Integer);
            Assert.AreEqual(2.0, dynamicSecurity.Double);
            Assert.AreEqual(3.0m, dynamicSecurity.Decimal);
            Assert.AreEqual("string", dynamicSecurity.String);
            Assert.AreEqual(new DateTime(2023, 06, 20), dynamicSecurity.DateTime);
            Assert.AreEqual(new ExponentialMovingAverage(10), dynamicSecurity.EMA);

            Assert.Throws<RuntimeBinderException>(() => { var notAProperty = dynamicSecurity.NotAProperty; });
        }

        [Test]
        public void SetCustomProperty()
        {
            var security = GetSecurity();
            security.Set("Bool", true);
            Assert.AreEqual(true, security.TryGet<bool>("Bool", out var boolValue));
            Assert.AreEqual(true, boolValue);
        }

        [Test]
        public void SetsAndGetsDynamicCustomPropertiesUsingGenericInterface()
        {
            var security = GetSecurity();
            security.Add("Bool", true);
            security.Add("Integer", 1);
            security.Add("Double", 2.0);
            security.Add("Decimal", 3.0m);
            security.Add("String", "string");
            security.Add("DateTime", new DateTime(2023, 06, 20));
            security.Add("EMA", new ExponentialMovingAverage(10));

            Assert.AreEqual(true, security.TryGet<bool>("Bool", out var boolValue));
            Assert.AreEqual(true, boolValue);
            Assert.AreEqual(true, security.Get<bool>("Bool"));

            Assert.AreEqual(true, security.TryGet<int>("Integer", out var intValue));
            Assert.AreEqual(1, intValue);
            Assert.AreEqual(1, security.Get<int>("Integer"));

            Assert.AreEqual(true, security.TryGet<double>("Double", out var doubleValue));
            Assert.AreEqual(2.0, doubleValue);
            Assert.AreEqual(2.0, security.Get<double>("Double"));

            Assert.AreEqual(true, security.TryGet<decimal>("Decimal", out var decimalValue));
            Assert.AreEqual(3.0m, decimalValue);
            Assert.AreEqual(3.0m, security.Get<decimal>("Decimal"));

            Assert.AreEqual(true, security.TryGet<string>("String", out var stringValue));
            Assert.AreEqual("string", stringValue);
            Assert.AreEqual("string", security.Get<string>("String"));

            Assert.AreEqual(true, security.TryGet<DateTime>("DateTime", out var dateTimeValue));
            Assert.AreEqual(new DateTime(2023, 06, 20), dateTimeValue);
            Assert.AreEqual(new DateTime(2023, 06, 20), security.Get<DateTime>("DateTime"));

            Assert.AreEqual(true, security.TryGet<ExponentialMovingAverage>("EMA", out var emaValue));
            Assert.AreEqual(new ExponentialMovingAverage(10), emaValue);
            Assert.AreEqual(new ExponentialMovingAverage(10), security.Get<ExponentialMovingAverage>("EMA"));

            Assert.AreEqual(false, security.TryGet<bool>("NotAProperty", out _));
            Assert.Throws<KeyNotFoundException>(() => security.Get<bool>("NotAProperty"));

            Assert.Throws<InvalidCastException>(() => security.TryGet<SimpleMovingAverage>("EMA", out _));
            Assert.Throws<InvalidCastException>(() => security.Get<SimpleMovingAverage>("EMA"));
        }

        [Test]
        public void SetsAndGetsDynamicCustomPropertiesUsingIndexer()
        {
            var security = GetSecurity();
            security["Bool"] = true;
            security["Integer"] = 1;
            security["Double"] = 2.0;
            security["Decimal"] = 3.0m;
            security["String"] = "string";
            security["DateTime"] = new DateTime(2023, 06, 20);
            security["EMA"] = new ExponentialMovingAverage(10);

            Assert.AreEqual(true, security["Bool"]);
            Assert.AreEqual(1, security["Integer"]);
            Assert.AreEqual(2.0, security["Double"]);
            Assert.AreEqual(3.0m, security["Decimal"]);
            Assert.AreEqual("string", security["String"]);
            Assert.AreEqual(new DateTime(2023, 06, 20), security["DateTime"]);
            Assert.AreEqual(new ExponentialMovingAverage(10), security["EMA"]);

            Assert.Throws<KeyNotFoundException>(() => { var notAProperty = security["NotAProperty"]; });
        }

        [Test]
        public void RemovesCustomProperties()
        {
            var security = GetSecurity();
            security.Add("Bool", true);
            security.Add("DateTime", new DateTime(2023, 06, 20));

            Assert.IsTrue(security.Remove("Bool"));
            Assert.IsFalse(security.TryGet<bool>("Bool", out _));
            Assert.IsFalse(security.Remove("Bool"));

            Assert.IsTrue(security.Remove("DateTime", out DateTime dateTime));
            Assert.AreEqual(new DateTime(2023, 06, 20), dateTime);
            Assert.IsFalse(security.TryGet<DateTime>("DateTime", out _));
            Assert.IsFalse(security.Remove<DateTime>("DateTime", out _));
        }

        [Test]
        public void ClearsCustomProperties()
        {
            var security = GetSecurity();
            security.Add("Decimal", 3.0m);
            security.Add("DateTime", new DateTime(2023, 06, 20));

            Assert.AreEqual(2, security.Cache.Properties.Count);

            security.Clear();
            Assert.AreEqual(0, security.Cache.Properties.Count);
            Assert.IsFalse(security.TryGet<decimal>("Decimal", out _));
            Assert.IsFalse(security.TryGet<DateTime>("DateTime", out _));

        }

        [Test]
        public void OverwritesCustomProperties()
        {
            var security = GetSecurity();
            dynamic dynamicSecurity = security;

            dynamicSecurity.DateTime = new DateTime(2023, 06, 20);
            Assert.AreEqual(new DateTime(2023, 06, 20), dynamicSecurity.DateTime);

            dynamicSecurity.DateTime = new DateTime(2024, 06, 20);
            Assert.AreEqual(new DateTime(2024, 06, 20), dynamicSecurity.DateTime);
        }

        [Test]
        public void InvokesCustomPropertyMethod()
        {
            var security = GetSecurity();
            dynamic dynamicSecurity = security;

            dynamicSecurity.MakeEma = new Func<int, decimal, ExponentialMovingAverage>(
                (period, smoothingFactor) => new ExponentialMovingAverage(period, smoothingFactor));

            Assert.AreEqual(new ExponentialMovingAverage(10, 0.5m), dynamicSecurity.MakeEma(10, 0.5m));
        }

        [Test]
        public void KeepsPythonClassDerivedFromCSharpClassObjectReference()
        {
            var expectedCSharpPropertyValue = "C# property";
            var expectedPythonPropertyValue = "Python property";

            using (Py.GIL())
            {
                var testModule = PyModule.FromString("testModule",
                    $@"
from AlgorithmImports import *
from QuantConnect.Tests.Common.Securities import SecurityTests

class PythonTestClass(SecurityTests.CSharpTestClass):
    def __init__(self):
        super().__init__()

def SetSecurityDynamicProperty(security: Security) -> None:
    obj = PythonTestClass()
    obj.CSharpProperty = '{expectedCSharpPropertyValue}'
    obj.PythonProperty = '{expectedPythonPropertyValue}'
    security.PythonClassObject = obj

def AssertPythonClassObjectType(security: Security) -> None:
    if type(security.PythonClassObject) != PythonTestClass:
        raise Exception('PythonClassObject is not of type PythonTestClass')

def AccessCSharpProperty(security: Security) -> str:
    return security.PythonClassObject.CSharpProperty

def AccessPythonProperty(security: Security) -> str:
    return security.PythonClassObject.PythonProperty
        ");

                var security = GetSecurity();
                dynamic dynamicSecurity = security;

                dynamic SetSecurityDynamicProperty = testModule.GetAttr("SetSecurityDynamicProperty");
                SetSecurityDynamicProperty(security);

                dynamic AssertPythonClassObjectType = testModule.GetAttr("AssertPythonClassObjectType");
                Assert.DoesNotThrow(() => AssertPythonClassObjectType(security));

                // Access the C# class property
                dynamic AccessCSharpProperty = testModule.GetAttr("AccessCSharpProperty");
                Assert.AreEqual(expectedCSharpPropertyValue, AccessCSharpProperty(security).As<string>());
                Assert.AreEqual(expectedCSharpPropertyValue, dynamicSecurity.PythonClassObject.CSharpProperty.As<string>());

                // Access the Python class property
                dynamic AccessPythonProperty = testModule.GetAttr("AccessPythonProperty");
                Assert.AreEqual(expectedPythonPropertyValue, AccessPythonProperty(security).As<string>());
                Assert.AreEqual(expectedPythonPropertyValue, dynamicSecurity.PythonClassObject.PythonProperty.As<string>());
            }
        }

        [Test]
        public void RunSecurityDynamicPropertyPythonObjectReferenceRegressionAlgorithm()
        {
            var parameter = new RegressionTests.AlgorithmStatisticsTestParameters("SecurityDynamicPropertyPythonClassAlgorithm",
                new Dictionary<string, string> {
                    {PerformanceMetrics.TotalOrders, "0"},
                    {"Average Win", "0%"},
                    {"Average Loss", "0%"},
                    {"Compounding Annual Return", "0%"},
                    {"Drawdown", "0%"},
                    {"Expectancy", "0"},
                    {"Net Profit", "0%"},
                    {"Sharpe Ratio", "0"},
                    {"Probabilistic Sharpe Ratio", "0%"},
                    {"Loss Rate", "0%"},
                    {"Win Rate", "0%"},
                    {"Profit-Loss Ratio", "0"},
                    {"Alpha", "0"},
                    {"Beta", "0"},
                    {"Annual Standard Deviation", "0"},
                    {"Annual Variance", "0"},
                    {"Information Ratio", "0"},
                    {"Tracking Error", "0"},
                    {"Treynor Ratio", "0"},
                    {"Total Fees", "$0.00"},
                    {"OrderListHash", "d41d8cd98f00b204e9800998ecf8427e"}
                },
                Language.Python,
                AlgorithmStatus.Completed);

            AlgorithmRunner.RunLocalBacktest(parameter.Algorithm,
                parameter.Statistics,
                parameter.Language,
                parameter.ExpectedFinalStatus);
        }

        #endregion

        internal static Security GetSecurity(bool isMarketAlwaysOpen = true)
        {
            SecurityExchangeHours securityExchangeHours;
            if (isMarketAlwaysOpen)
            {
                securityExchangeHours = SecurityExchangeHours.AlwaysOpen(TimeZones.NewYork);
            }
            else
            {
                var marketHourDbEntry = MarketHoursDatabase.FromDataFolder().GetEntry(Market.USA, "SPY", SecurityType.Equity);
                securityExchangeHours = marketHourDbEntry.ExchangeHours;
            }

            RegisteredSecurityDataTypesProvider.Null.RegisterType(typeof(TradeBar));

            return new Security(
                securityExchangeHours,
                CreateTradeBarConfig(),
                new Cash(Currencies.USD, 0, 1m),
                SymbolProperties.GetDefault(Currencies.USD),
                ErrorCurrencyConverter.Instance,
                RegisteredSecurityDataTypesProvider.Null,
                new SecurityCache()
            );
        }

        internal static SubscriptionDataConfig CreateTradeBarConfig(Resolution resolution = Resolution.Minute)
        {
            return new SubscriptionDataConfig(typeof(TradeBar), Symbols.SPY, resolution, TimeZones.NewYork, TimeZones.NewYork, true, true, false);
        }

        public class CSharpTestClass
        {
            public string CSharpProperty { get; set; }
        }
    }
}