using Qdp.Pricing.Base.Enums;
using Qdp.Pricing.Library.Common.Interfaces;
using Qdp.Pricing.Library.Options.MonteCarlo;
using Qdp.Pricing.Library.Options.Products.Barrier.Engines.Numerical.Quad;
using Qdp.Pricing.Library.Options.Products.Binary.Engines.Analytical;

namespace YLErp.BLL.Calculation.Engine
{
    class BinaryEngineFactory : OptionEngineFactoryBase
    {
        public static BinaryEngineFactory Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new BinaryEngineFactory();
                }
                return _instance;
            }
        }

        protected BinaryEngineFactory() { }
        protected static BinaryEngineFactory _instance;

        public override IEngine GetEngine(
            string engineName = null,
            OptionExercise exercise = OptionExercise.European,
            params object[] additionalParams)
        {
            if (string.IsNullOrEmpty(engineName))
            {
                return DefaultEngine(exercise, additionalParams);
            }
            else
            {
                switch (engineName.ToUpper())
                {
                    case "ANALYTICALBINARYEUROPEANOPTIONENGINE":
                        return new AnalyticalBinaryEuropeanOptionEngine();
                    case "ANALYTICALBINARYEUROPEANOPTIONREPLICATIONENGINE":
                        return DefaultEngine(exercise, additionalParams);
                    case "ANALYTICALBINARYAMERICANOPTIONENGINE":
                        return new AnalyticalBinaryAmericanOptionEngine();
                    case "QUADBARRIEROPTIONENGINE":
                        return new QuadBarrierOptionEngine();
                    case "GENERICMONTECARLOENGINE":
                        return CreateGenericMonteCarloEngine(additionalParams);
                    case "GBMMONTECARLOENGINE":
                        return new GbmMonteCarloEngine(100000, 1e-3, 1e-6, 1);
                    default:
                        if (engineName.IsValidEngineName())
                        {
                            return OptionEngineRepository.CreateEngine(engineName);
                        }
                        else
                        {
                            return DefaultEngine(exercise, additionalParams);
                        }
                }
            }
        }

        /// <summary>
        /// /
        /// </summary>
        /// <param name="exercise"></param>
        /// <param name="additionalParams">
        /// param[0] - 二元期权的复制模型的步长（仅对复制模型有效）
        /// param[1] - 二元期权的复制方法（仅对复制模型有效）
        /// param[2] - 是否自定义了观察日（仅对美式二元有效）
        /// param[3] - 是否按年化敲出
        /// </param>
        /// <returns></returns>
        private static IEngine DefaultEngine(
            OptionExercise exercise,
            params object[] additionalParams)
        {
            switch (exercise)
            {
                case OptionExercise.European:
                    if (additionalParams.Length > 1
                        && (BinaryOptionReplicationStrategy)additionalParams[1] != BinaryOptionReplicationStrategy.None)
                    {
                        return new AnalyticalBinaryEuropeanOptionReplicationEngine((double)additionalParams[0], (BinaryOptionReplicationStrategy)additionalParams[1]);
                    }
                    else
                    {
                        return string.IsNullOrWhiteSpace(OptionEngineRepository.BinaryEuropeanDefaultEngine)
                            ? new AnalyticalBinaryEuropeanOptionEngine()
                            : OptionEngineRepository.CreateEngine(OptionEngineRepository.BinaryEuropeanDefaultEngine);
                    }
                case OptionExercise.American:
                    var customizedObservation = false;
                    if (additionalParams.Length > 2)
                    {
                        customizedObservation = (bool)additionalParams[2];
                    }

                    var rebateAnnualized = false;
                    if (additionalParams.Length > 3)
                    {
                        rebateAnnualized = (bool)additionalParams[3];
                    }

                    if (customizedObservation || rebateAnnualized)
                    {
                        return new QuadBarrierOptionEngine();
                    }
                    else
                    {
                        return string.IsNullOrWhiteSpace(OptionEngineRepository.BinaryAmericanDefaultEngine)
                        ? new AnalyticalBinaryAmericanOptionEngine()
                        : OptionEngineRepository.CreateEngine(OptionEngineRepository.BinaryAmericanDefaultEngine);
                    }
                default:
                    throw new Exception($"二元期权不支持的行权方式{exercise}.无法创建计算引擎");
            }
        }
    }
}