using Qdp.Pricing.Base.Enums;
using Qdp.Pricing.Library.Common.Interfaces;
using Qdp.Pricing.Library.Options.Products.Rainbow.Engines.Analytical;

namespace YLErp.BLL.Calculation.Engine
{
    class RainbowEngineFactory : OptionEngineFactoryBase
    {
        public static RainbowEngineFactory Instace => _instance ?? (_instance = new RainbowEngineFactory());

        protected RainbowEngineFactory() { }
        protected static RainbowEngineFactory _instance;

        public override IEngine GetEngine(string engineName = null, OptionExercise exercise = OptionExercise.European, params object[] additionalParams)
        {
            if (string.IsNullOrWhiteSpace(engineName))
            {
                return DefaultEngine(exercise, additionalParams);
            }
            else
            {
                switch (engineName.ToUpper())
                {
                    case "ANALYTICALRAINBOWOPTIONENGINE":
                        return new AnalyticalRainbowOptionEngine();
                    case "GENERICMONTECARLOENGINE":
                        return CreateGenericMonteCarloEngine(additionalParams);
                    default:
                        if (engineName.IsValidEngineName())
                        {
                            return OptionEngineRepository.CreateEngine(engineName);
                        }
                        else
                        {
                            return DefaultEngine(exercise);
                        }
                }

            }
        }

        private static IEngine DefaultEngine(OptionExercise exercise, params object[] additionalParams)
        {
            return string.IsNullOrWhiteSpace(OptionEngineRepository.RainbowDefaultEngine)
                ? new AnalyticalRainbowOptionEngine()
                : OptionEngineRepository.CreateEngine(OptionEngineRepository.RainbowDefaultEngine);
        }
    }
}