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

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

        protected DoubleSharkFinFactory() { }
        protected static DoubleSharkFinFactory _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 "ANALYTICALDOUBLESHARKFINOPTIONENGINE":
                        return DefaultEngine(exercise, 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);
                        }
                }

            }
        }

        private IEngine DefaultEngine(
            OptionExercise exercise,
            params object[] additionalParams)
        {
            if (additionalParams.Length > 0 && additionalParams[0] is DoubleSharkFinOption)
            {
                var hasCustomziedObservations = false;
                if (additionalParams.Length > 2)
                {
                    hasCustomziedObservations = (bool)additionalParams[2];
                }
                if (hasCustomziedObservations)
                {
                    var quadratureFastMode = false;
                    if (additionalParams.Length > 3)
                    {
                        quadratureFastMode = (bool)additionalParams[3];
                    }

                    if (quadratureFastMode)
                    {
                        return new QuadDoubleSharkFinOptionEngine(parallelDegree: Environment.ProcessorCount);
                    }
                    else
                    {
                        return new QuadDoubleSharkFinOptionEngine(parallelDegree: PS.Config.ErpElement.QdpParallelDegree);
                    }
                }

                var useFourier = false;
                if (additionalParams.Length > 1)
                {
                    useFourier = (bool)additionalParams[1];
                }
                return new AnalyticalDoubleSharkFinOptionEngine(useFourier);
            }
            else
            {
                throw new Exception("双鲨期权计算引擎构造失败");
            }
        }
    }
}