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

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

        protected SyntheticNormalSpreadFactory() { }
        protected static SyntheticNormalSpreadFactory _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 "ANALYTICALSYNTHETICNORMALSPREADOPTIONENGINE":
                        return new AnalyticalSyntheticNormalSpreadOptionEngine();
                    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.SyntheticNormalSpreadEngine)
                ? new AnalyticalSyntheticNormalSpreadOptionEngine()
                : OptionEngineRepository.CreateEngine(OptionEngineRepository.SyntheticNormalSpreadEngine);
        }
    }
}