using Qdp.Pricing.Library.Common.Interfaces;

namespace YLErp.BLL.Calculation.Engine
{
    public static class OptionEngineRepository
    {
        public static string VanillaEuropeanDefaultEngine
        {
            get => _vanillaEuropeanDefaultEngine;
            set => _vanillaEuropeanDefaultEngine = ValidateEngine(value);
        }
        private static string _vanillaEuropeanDefaultEngine;

        public static string VanillaAmericanDefaultEngine
        {
            get => _vanillaAmericanDefaultEngine;
            set => _vanillaAmericanDefaultEngine = ValidateEngine(value);
        }
        private static string _vanillaAmericanDefaultEngine;

        public static string BarrierEuropeanDefaultEngine
        {
            get => _barrierEuropeanDefaultEngine;
            set => _barrierEuropeanDefaultEngine = ValidateEngine(value);
        }
        private static string _barrierEuropeanDefaultEngine;

        public static string BarrierAmericanDefaultEngine
        {
            get => _barrierAmericanDefaultEngine;
            set => _barrierAmericanDefaultEngine = ValidateEngine(value);
        }
        private static string _barrierAmericanDefaultEngine;

        public static string BinaryEuropeanDefaultEngine
        {
            get => _binaryEuropeanDefaultEngine;
            set => _binaryEuropeanDefaultEngine = ValidateEngine(value);
        }
        private static string _binaryEuropeanDefaultEngine;

        public static string BinaryAmericanDefaultEngine
        {
            get => _binaryAmericanDefaultEngine;
            set => _binaryAmericanDefaultEngine = ValidateEngine(value);
        }
        private static string _binaryAmericanDefaultEngine;

        public static string AsianEuropeanDefaultEngine
        {
            get => _asianEuropeanDefaultEngine;
            set => _asianEuropeanDefaultEngine = ValidateEngine(value);
        }
        private static string _asianEuropeanDefaultEngine;

        public static string AsianAmericanDefaultEngine
        {
            get => _asianAmericanDefaultEngine;
            set => _asianAmericanDefaultEngine = ValidateEngine(value);
        }
        private static string _asianAmericanDefaultEngine;

        public static string RainbowDefaultEngine
        {
            get => _rainbowDefaultEngine;
            set => _rainbowDefaultEngine = ValidateEngine(value);
        }
        private static string _rainbowDefaultEngine;

        public static string SpreadDefaultEngine
        {
            get => _spreadDefaultEngine;
            set => _spreadDefaultEngine = ValidateEngine(value);
        }
        private static string _spreadDefaultEngine;

        public static string SyntheticNormalSpreadEngine
        {
            get => _syntheticNormalSpreadEngine;
            set => _syntheticNormalSpreadEngine = ValidateEngine(value);
        }
        private static string _syntheticNormalSpreadEngine;

        /// <summary>
        /// 通过反射创建计算引擎
        /// </summary>
        /// <param name="engineName"></param>
        /// <returns></returns>
        public static IEngine CreateEngine(string engineName)
        {
            var type = Type.GetType(engineName);
            return type.Assembly.CreateInstance(engineName) as IEngine;
        }

        /// <summary>
        /// 判断是否为一个合法的计算引擎类型名称
        /// </summary>
        /// <param name="engineName"></param>
        /// <returns></returns>
        public static bool IsValidEngineName(this string engineName)
        {
            var type = Type.GetType(engineName);
            if (type != null)
            {
                if (type.IsSubclassOf(Type.GetType("Qdp.Pricing.Library.Common.Interfaces.Engine<IOption>")))
                {
                    return true;
                }
            }
            return false;
        }

        private static string ValidateEngine(string engineClassName)
        {
            //if (!IsValidEngineName(engineClassName))
            //{
            //    throw new Exception($"{engineClassName}并不是一个正确的计算引擎名称");
            //}
            return engineClassName;
        }
    }
}