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

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

        /// <summary>
        /// 获取计算引擎
        /// </summary>
        /// <param name="engineName">计算引擎名称</param>
        /// <param name="exercise">行权方式</param>
        /// <param name="additionalParams"></param>
        /// <returns></returns>
        public override IEngine GetEngine(
            string engineName = null,
            OptionExercise exercise = OptionExercise.European,
            params object[] additionalParams)
        {
            if (string.IsNullOrWhiteSpace(engineName))
            {
                return DefaultEngine(exercise, additionalParams);
            }
            else
            {
                if (exercise == OptionExercise.American)
                {
                    switch (engineName.ToUpper())
                    {
                        case "BINOMIALTREEAMERICANENGINE":
                            return new BinomialTreeAmericanEngine();
                        case "ANALYTICALVANILLAAMERICANOPTIONBAWENGINE":
                            return new AnalyticalVanillaAmericanOptionBAWEngine();
                        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);
                            }
                    }
                }
                else
                {
                    switch (engineName.ToUpper())
                    {
                        case "ANALYTICALVANILLAEUROPEANOPTIONENGINE":
                            return new AnalyticalVanillaEuropeanOptionEngine(derivativeGreeks: true);
                        case "GBMMONTECARLOENGINE":
                            return new GbmMonteCarloEngine(100000, 1e-3, 1e-6, 1);
                        default:
                            if (engineName.IsValidEngineName())
                            {
                                return OptionEngineRepository.CreateEngine(engineName);
                            }
                            else
                            {
                                return DefaultEngine(exercise);
                            }
                    }
                }
            }
        }

        private static IEngine DefaultEngine(OptionExercise exercise, params object[] additionalParams)
        {
            switch (exercise)
            {
                case OptionExercise.European:
                    return string.IsNullOrWhiteSpace(OptionEngineRepository.VanillaEuropeanDefaultEngine)
                        ? new AnalyticalVanillaEuropeanOptionEngine(derivativeGreeks: true)
                        : OptionEngineRepository.CreateEngine(OptionEngineRepository.VanillaEuropeanDefaultEngine);
                case OptionExercise.American:
                    if (OptionEngineRepository.VanillaAmericanDefaultEngine == "BinomialTreeAmericanEngine")
                    {
                        return new BinomialTreeAmericanEngine(steps: 100, useControlVariate: false, fastDelta: true);
                    }
                    else
                    {
                        return new AnalyticalVanillaAmericanOptionBAWEngine();
                    }

                default:
                    throw new Exception($"香草期权不支持的行权方式{exercise}.无法创建计算引擎");
            }
        }
    }
}