/*
 * 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 NUnit.Framework;
using Python.Runtime;
using QuantConnect.Orders.Fees;
using QuantConnect.Python;
using System;
using System.Collections.Generic;
using System.Linq;

namespace QuantConnect.Tests.Python
{
    [TestFixture]
    public class BasePythonWrapperTests
    {
        [Test]
        public void EqualsReturnsTrueForWrapperAndUnderlyingModel()
        {
            using var _ = Py.GIL();

            var module = PyModule.FromString("EqualsReturnsTrueForWrapperAndUnderlyingModel", @"
from clr import AddReference
AddReference('QuantConnect.Tests')

from QuantConnect.Tests.Python import BasePythonWrapperTests

class PythonDerivedTestModel(BasePythonWrapperTests.TestModel):
    pass

class PythonTestModel:
    pass
");
            var pyDerivedModel = module.GetAttr("PythonDerivedTestModel").Invoke();
            var wrapper = new BasePythonWrapper<ITestModel>(pyDerivedModel);
            var pyModel = module.GetAttr("PythonTestModel").Invoke();

            Assert.IsTrue(wrapper.Equals(pyDerivedModel));
            Assert.IsTrue(wrapper.Equals(new BasePythonWrapper<ITestModel>(pyDerivedModel)));
            Assert.IsFalse(wrapper.Equals(pyModel));
        }

        [TestFixture]
        public class RuntimeChecks
        {
            [TestFixture]
            public class InvokingMethod
            {
                public interface ITestInvokeMethodModel
                {
                    int IntReturnTypeMethod();
                }

                [Test]
                public void ThrowsWhenWhenWrongReturnType([Values] bool withValidReturnType)
                {
                    using var _ = Py.GIL();
                    using var module = PyModule.FromString(nameof(ThrowsWhenWhenWrongReturnType), @"
class PythonTestInvokeMethodModel():
    def __init__(self):
        self._return_valid_type = True

    def set_return_valid_type(self, value):
        self._return_valid_type = value

    def int_return_type_method(self):
        if self._return_valid_type:
            return 1

        # Should return a integer to properly match the interface
        return ""string""
");

                    using var pyInstance = module.GetAttr("PythonTestInvokeMethodModel").Invoke();
                    using var pyWithValidReturnType = withValidReturnType.ToPython();
                    pyInstance.GetAttr("set_return_valid_type").Invoke(pyWithValidReturnType);

                    var wrapper = new BasePythonWrapper<ITestInvokeMethodModel>(pyInstance);

                    if (withValidReturnType)
                    {
                        var result = -1;
                        Assert.DoesNotThrow(() => result = wrapper.InvokeMethod<int>("IntReturnTypeMethod"));
                        Assert.AreEqual(1, result);
                    }
                    else
                    {
                        Assert.Throws<InvalidCastException>(() => wrapper.InvokeMethod<int>("IntReturnTypeMethod"));
                    }
                }

                [TestFixture]
                public class WithOutParameters
                {
                    public interface ITestInvokeMethodWithOutParamsModel
                    {
                        DateTime MethodWithOutParams(out int intOutParam, out string stringOutParam);
                    }

                    [Test]
                    public void ThrowsWhenWrongOutParamType([Values] bool withValidOutParamsTypes)
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenWrongOutParamType), @"
from datetime import datetime

class PythonTestInvokeMethodWithOutParamsModel():
    def __init__(self):
        self._return_valid_out_param_type = True

    def set_return_valid_out_param_type(self, value):
        self._return_valid_out_param_type = value

    def method_with_out_params(self, int_out_param, string_out_param):
        if self._return_valid_out_param_type:
            int_out_param = 1
            string_out_param = 'string'
        else:
            int_out_param = 'string'    # Invalid type
            string_out_param = 'string'

        return datetime(2024, 6, 21), int_out_param, string_out_param
");

                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodWithOutParamsModel").Invoke();
                        using var pyWithValidOutParamsTypes = withValidOutParamsTypes.ToPython();
                        pyInstance.GetAttr("set_return_valid_out_param_type").Invoke(pyWithValidOutParamsTypes);

                        var wrapper = new BasePythonWrapper<ITestInvokeMethodWithOutParamsModel>(pyInstance);

                        AssertInvoke(wrapper, withValidOutParamsTypes);
                    }

                    [Test]
                    public void ThrowsWhenWrongOutParamCount([Values] bool withValidOutParamCount)
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenWrongOutParamCount), @"
from datetime import datetime

class PythonTestInvokeMethodWithOutParamsModel():
    def __init__(self):
        self._return_valid_out_params_count = True

    def set_return_valid_out_params_count(self, value):
        self._return_valid_out_params_count = value

    def method_with_out_params(self, int_out_param, string_out_param):
        int_out_param = 1
        string_out_param = 'string'
        if self._return_valid_out_params_count:
            return datetime(2024, 6, 21), int_out_param, string_out_param
        else:
            return datetime(2024, 6, 21), int_out_param
");
                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodWithOutParamsModel").Invoke();
                        using var pyWithValidOutParamCount = withValidOutParamCount.ToPython();
                        pyInstance.GetAttr("set_return_valid_out_params_count").Invoke(pyWithValidOutParamCount);

                        var wrapper = new BasePythonWrapper<ITestInvokeMethodWithOutParamsModel>(pyInstance);

                        AssertInvoke<ArgumentException>(wrapper, withValidOutParamCount);
                    }

                    [Test]
                    public void ThrowsWhenReturnedTypeIsNotATuple([Values] bool withValidReturnType)
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenWrongReturnType), @"
from datetime import datetime

class PythonTestInvokeMethodWithOutParamsModel():
    def __init__(self):
        self._use_valid_return_type = True

    def set_use_valid_return_type(self, value):
        self._use_valid_return_type = value

    def method_with_out_params(self, int_out_param, string_out_param):
        int_out_param = 1
        string_out_param = 'string'
        if self._use_valid_return_type:
            return datetime(2024, 6, 21), int_out_param, string_out_param
        else:
            return 1   # Invalid return type, not a tuple
");
                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodWithOutParamsModel").Invoke();
                        using var pyWithValidOutParamCount = withValidReturnType.ToPython();
                        pyInstance.GetAttr("set_use_valid_return_type").Invoke(pyWithValidOutParamCount);

                        var wrapper = new BasePythonWrapper<ITestInvokeMethodWithOutParamsModel>(pyInstance);

                        AssertInvoke<ArgumentException>(wrapper, withValidReturnType);
                    }

                    [Test]
                    public void ThrowsWhenWrongReturnType([Values] bool withValidReturnType)
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenWrongReturnType), @"
from datetime import datetime

class PythonTestInvokeMethodWithOutParamsModel():
    def __init__(self):
        self._use_valid_return_type = True

    def set_use_valid_return_type(self, value):
        self._use_valid_return_type = value

    def method_with_out_params(self, int_out_param, string_out_param):
        int_out_param = 1
        string_out_param = 'string'
        if self._use_valid_return_type:
            return datetime(2024, 6, 21), int_out_param, string_out_param
        else:
            return 1, int_out_param, string_out_param
");
                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodWithOutParamsModel").Invoke();
                        using var pyWithValidOutParamCount = withValidReturnType.ToPython();
                        pyInstance.GetAttr("set_use_valid_return_type").Invoke(pyWithValidOutParamCount);

                        var wrapper = new BasePythonWrapper<ITestInvokeMethodWithOutParamsModel>(pyInstance);

                        AssertInvoke(wrapper, withValidReturnType);
                    }

                    private static void AssertInvoke<TException>(BasePythonWrapper<ITestInvokeMethodWithOutParamsModel> wrapper, bool validCase)
                        where TException : Exception
                    {
                        var outParametersTypes = new Type[] { typeof(int), typeof(string) };
                        var intOutParameter = -1;
                        var stringOutParameter = string.Empty;

                        if (validCase)
                        {
                            var result = wrapper.InvokeMethodWithOutParameters<DateTime>("MethodWithOutParams", outParametersTypes,
                                out var outParameters, intOutParameter, stringOutParameter);
                            Assert.AreEqual(new DateTime(2024, 6, 21), result);
                            Assert.AreEqual(1, outParameters[0]);
                            Assert.AreEqual("string", outParameters[1]);
                        }
                        else
                        {
                            Assert.Throws<TException>(() => wrapper.InvokeMethodWithOutParameters<DateTime>("MethodWithOutParams",
                                outParametersTypes, out var _, intOutParameter, stringOutParameter));
                        }
                    }

                    private static void AssertInvoke(BasePythonWrapper<ITestInvokeMethodWithOutParamsModel> wrapper, bool validCase)
                    {
                        AssertInvoke<InvalidCastException>(wrapper, validCase);
                    }
                }

                [TestFixture]
                public class WithEnumerableReturnType
                {
                    public interface ITestInvokeMethodReturningIterable
                    {
                        IEnumerable<int> Range(int min, int max);
                    }

                    [Test]
                    public void ThrowsWhenReturnTypeIsNotIterable([Values] bool withValidReturnType)
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenReturnTypeIsNotIterable), @"
class PythonTestInvokeMethodReturningIterable():
    def __init__(self):
        self._use_valid_return_type = True

    def set_use_valid_return_type(self, value):
        self._use_valid_return_type = value

    def range(self, min, max):
        if self._use_valid_return_type:
            return range(min, max)
");

                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodReturningIterable").Invoke();
                        using var pyWithValidReturnType = withValidReturnType.ToPython();
                        pyInstance.GetAttr("set_use_valid_return_type").Invoke(pyWithValidReturnType);

                        var wrapper = new BasePythonWrapper<ITestInvokeMethodReturningIterable>(pyInstance);

                        if (withValidReturnType)
                        {
                            var result = wrapper.InvokeMethodAndEnumerate<int>("Range", 5, 10).ToList();
                            CollectionAssert.AreEqual(new[] { 5, 6, 7, 8, 9 }, result);
                        }
                        else
                        {
                            Assert.Throws<InvalidCastException>(() => wrapper.InvokeMethodAndEnumerate<int>("Range", 5, 10).ToList());
                        }
                    }

                    [Test]
                    public void ThrowsWhenIteratorItemIsOfWrongType()
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenIteratorItemIsOfWrongType), @"
class PythonTestInvokeMethodReturningIterable():
    def range(self, min, max):
        for i in range(min, max):
            yield i
        yield 'string'
");

                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodReturningIterable").Invoke();
                        var wrapper = new BasePythonWrapper<ITestInvokeMethodReturningIterable>(pyInstance);

                        Assert.Throws<InvalidCastException>(() => wrapper.InvokeMethodAndEnumerate<int>("Range", 5, 10).ToList());
                    }
                }

                [TestFixture]
                public class WithDictionaryReturnType
                {
                    public interface ITestInvokeMethodReturningDictionary
                    {
                        Dictionary<Symbol, List<double>> GetDictionary();
                    }

                    [TestCase(true, false)]
                    [TestCase(true, true)]
                    [TestCase(false)]
                    public void ThrowsWhenReturnTypeIsNotDictionary(bool withValidReturnType, bool returnNone = false)
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenReturnTypeIsNotDictionary), @"
from QuantConnect.Tests import Symbols

class PythonTestInvokeMethodReturningDictionary():
    def __init__(self):
        self._use_valid_return_type = True
        self._return_none = False

    def set_use_valid_return_type(self, value):
        self._use_valid_return_type = value

    def set_return_none(self, value):
        self._return_none = value

    def get_dictionary(self):
        if self._use_valid_return_type:
            if not self._return_none:
                return {
                    Symbols.SPY: [1.1, 2.2],
                    Symbols.USDJPY: [3.3, 4.4, 5.5],
                    Symbols.SPY_C_192_Feb19_2016: [6.6],
                }
            else:
                # None is a valid value for a Dictionary
                return None
        else:
            return [1, 2, 3]
");

                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodReturningDictionary").Invoke();
                        using var pyWithValidReturnType = withValidReturnType.ToPython();
                        pyInstance.GetAttr("set_use_valid_return_type").Invoke(pyWithValidReturnType);
                        using var pyReturnNone = returnNone.ToPython();
                        pyInstance.GetAttr("set_return_none").Invoke(pyReturnNone);

                        var wrapper = new BasePythonWrapper<ITestInvokeMethodReturningDictionary>(pyInstance);

                        if (withValidReturnType)
                        {
                            var result = wrapper.InvokeMethodAndGetDictionary<Symbol, List<double>>("GetDictionary");

                            if (returnNone)
                            {
                                Assert.IsNull(result);
                            }
                            else
                            {
                                var expectedDictionary = new Dictionary<Symbol, List<double>>()
                                {
                                    { Symbols.SPY, new() { 1.1, 2.2 } },
                                    { Symbols.USDJPY, new() { 3.3, 4.4, 5.5 } },
                                    { Symbols.SPY_C_192_Feb19_2016, new() { 6.6 } },
                                };

                                Assert.IsNotNull(result);
                                Assert.AreEqual(expectedDictionary.Count, result.Count);

                                foreach (var kvp in expectedDictionary)
                                {
                                    Assert.IsTrue(result.TryGetValue(kvp.Key, out var resultValue));
                                    CollectionAssert.AreEqual(kvp.Value, resultValue);
                                }
                            }
                        }
                        else
                        {
                            Assert.Throws<InvalidCastException>(() => wrapper.InvokeMethodAndGetDictionary<Symbol, List<double>>("GetDictionary"));
                        }
                    }

                    [Test]
                    public void ThrowsWhenDictionaryKeyIsOfWrongType()
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenDictionaryKeyIsOfWrongType), @"
from datetime import datetime
from QuantConnect.Tests import Symbols

class PythonTestInvokeMethodReturningDictionary():
    def get_dictionary(self):
        date = datetime(2024, 8, 14)
        return {
            Symbols.SPY: [1.1, 2.2],
            Symbols.USDJPY: [3.3, 4.4, 5.5],
            date: [6.6],
        }
");

                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodReturningDictionary").Invoke();
                        var wrapper = new BasePythonWrapper<ITestInvokeMethodReturningDictionary>(pyInstance);

                        Assert.Throws<InvalidCastException>(() => wrapper.InvokeMethodAndGetDictionary<Symbol, List<double>>("GetDictionary"));
                    }

                    [Test]
                    public void ThrowsWhenDictionaryValueIsOfWrongType()
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(ThrowsWhenDictionaryValueIsOfWrongType), @"
from QuantConnect.Tests import Symbols

class PythonTestInvokeMethodReturningDictionary():
    def get_dictionary(self):
        return {
            Symbols.SPY: [1.1, 2.2],
            Symbols.USDJPY: [3.3, 4.4, 5.5],
            Symbols.SPY_C_192_Feb19_2016: 6.6,
        }
");

                        using var pyInstance = module.GetAttr("PythonTestInvokeMethodReturningDictionary").Invoke();
                        var wrapper = new BasePythonWrapper<ITestInvokeMethodReturningDictionary>(pyInstance);

                        Assert.Throws<InvalidCastException>(() => wrapper.InvokeMethodAndGetDictionary<Symbol, List<double>>("GetDictionary"));
                    }
                }

                [TestFixture]
                public class WrappingResult
                {
                    public interface ITestModel
                    {
                        IFeeModel GetFeeModel();
                    }

                    public class TestModel : ITestModel
                    {
                        public IFeeModel GetFeeModel()
                        {
                            return new FeeModel();
                        }
                    }

                    public class TestModelPythonWrapper : BasePythonWrapper<ITestModel>
                    {
                        public TestModelPythonWrapper(PyObject pyInstance) : base(pyInstance)
                        {
                        }
                    }

                    [Test]
                    public void WrapsResult([Values] bool withWrappedResult)
                    {
                        using var _ = Py.GIL();
                        using var module = PyModule.FromString(nameof(WrapsResult), @"
from AlgorithmImports import *
from clr import AddReference
AddReference('QuantConnect.Tests')

from QuantConnect.Tests.Python import BasePythonWrapperTests

class PythonFeeModel(FeeModel):
    pass

class PythonTestModel(BasePythonWrapperTests.RuntimeChecks.InvokingMethod.WrappingResult.TestModel):
    def __init__(self):
        self._use_wrapped_result = True

    def set_use_wrapped_result(self, value):
        self._use_wrapped_result = value

    def get_fee_model(self):
        if self._use_wrapped_result:
            return PythonFeeModel()

        return FeeModel()
");

                        using var pyInstance = module.GetAttr("PythonTestModel").Invoke();
                        using var pyWithWrappedResult = withWrappedResult.ToPython();
                        pyInstance.GetAttr("set_use_wrapped_result").Invoke(pyWithWrappedResult);

                        var wrapper = new TestModelPythonWrapper(pyInstance);
                        var wrappingFunctionCalled = false;
                        var feeModel = wrapper.InvokeMethodAndWrapResult<IFeeModel>("GetFeeModel", (pyInstance) =>
                        {
                            wrappingFunctionCalled = true;
                            return new FeeModelPythonWrapper(pyInstance);
                        });

                        if (withWrappedResult)
                        {
                            Assert.IsTrue(wrappingFunctionCalled);
                            Assert.IsInstanceOf<FeeModelPythonWrapper>(feeModel);
                        }
                        else
                        {
                            Assert.IsFalse(wrappingFunctionCalled);
                            Assert.IsInstanceOf<FeeModel>(feeModel);
                            Assert.IsNotInstanceOf<FeeModelPythonWrapper>(feeModel);
                        }
                    }
                }
            }

            [TestFixture]
            public class WorkingWithProperties
            {
                public interface ITestProperties
                {
                    List<double> Numbers { get; set; }
                }

                [Test]
                public void ThrowsWhenSettingPropertyValueOfInvalidType([Values] bool withValidType)
                {
                    using var _ = Py.GIL();
                    using var module = PyModule.FromString(nameof(ThrowsWhenSettingPropertyValueOfInvalidType), @"
class PythonTestSetProperty():
    def __init__(self):
        self._numbers = None
        self._use_valid_type = True

    def set_use_valid_type(self, value):
        self._use_valid_type = value

    @property
    def numbers(self):
        return self._numbers

    @numbers.setter
    def numbers(self, value):
        self._numbers = value

    def set_valid_numbers(self):
        self.numbers = [1.1, 2.2, 3.3]

    def set_invalid_numbers(self):
        self.numbers = 1
");

                    using var pyInstance = module.GetAttr("PythonTestSetProperty").Invoke();
                    using var pyWithValidReturnType = withValidType.ToPython();
                    pyInstance.GetAttr("set_use_valid_type").Invoke(pyWithValidReturnType);

                    var wrapper = new BasePythonWrapper<ITestProperties>(pyInstance);

                    if (withValidType)
                    {
                        var result = wrapper.GetProperty<List<double>>("Numbers");
                        // The default value is null
                        Assert.IsNull(result);

                        // set the property
                        pyInstance.InvokeMethod("set_valid_numbers");
                        result = wrapper.GetProperty<List<double>>("Numbers");
                        var expectedNumbers = new List<double> { 1.1, 2.2, 3.3 };
                        CollectionAssert.AreEqual(expectedNumbers, result);
                    }
                    else
                    {
                        pyInstance.InvokeMethod("set_invalid_numbers");
                        Assert.Throws<InvalidCastException>(() => wrapper.GetProperty<List<double>>("Numbers"));
                    }
                }
            }
        }

        public interface ITestModel
        {
        }

        public class TestModel : ITestModel
        {
        }
    }
}