using System.Collections.Concurrent;
using System.ComponentModel;
using System.Globalization;
using FluentAssertions;
using FluentMigrator;
using FluentMigrator.Runner;
using FluentMigrator.Runner.Conventions;
using FluentMigrator.Runner.Generators;
using FluentMigrator.Runner.Initialization;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.Infrastructure;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.AspNetCore.Mvc.Routing;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Microsoft.Net.Http.Headers;
using Moq;
using Nop.Core;
using Nop.Core.Caching;
using Nop.Core.ComponentModel;
using Nop.Core.Configuration;
using Nop.Core.Domain.Catalog;
using Nop.Core.Domain.Customers;
using Nop.Core.Domain.Media;
using Nop.Core.Events;
using Nop.Core.Infrastructure;
using Nop.Data;
using Nop.Data.Configuration;
using Nop.Data.Migrations;
using Nop.Services.Affiliates;
using Nop.Services.ArtificialIntelligence;
using Nop.Services.Attributes;
using Nop.Services.Authentication.External;
using Nop.Services.Authentication.MultiFactor;
using Nop.Services.Blogs;
using Nop.Services.Caching;
using Nop.Services.Catalog;
using Nop.Services.Cms;
using Nop.Services.Common;
using Nop.Services.Configuration;
using Nop.Services.Customers;
using Nop.Services.Directory;
using Nop.Services.Discounts;
using Nop.Services.Events;
using Nop.Services.ExportImport;
using Nop.Services.FilterLevels;
using Nop.Services.Forums;
using Nop.Services.Gdpr;
using Nop.Services.Helpers;
using Nop.Services.Html;
using Nop.Services.Installation;
using Nop.Services.Localization;
using Nop.Services.Logging;
using Nop.Services.Media;
using Nop.Services.Menus;
using Nop.Services.Messages;
using Nop.Services.News;
using Nop.Services.Orders;
using Nop.Services.Payments;
using Nop.Services.Plugins;
using Nop.Services.Polls;
using Nop.Services.ScheduleTasks;
using Nop.Services.Security;
using Nop.Services.Seo;
using Nop.Services.Shipping;
using Nop.Services.Shipping.Date;
using Nop.Services.Shipping.Pickup;
using Nop.Services.Stores;
using Nop.Services.Tax;
using Nop.Services.Themes;
using Nop.Services.Topics;
using Nop.Services.Vendors;
using Nop.Tests.Nop.Services.Tests.ScheduleTasks;
using Nop.Tests.Nop.Web.Tests.Public.Factories;
using Nop.Web.Areas.Admin.Factories;
using Nop.Web.Framework;
using Nop.Web.Framework.Factories;
using Nop.Web.Framework.Mvc.Routing;
using Nop.Web.Framework.Themes;
using Nop.Web.Framework.UI;
using Nop.Web.Framework.WebOptimizer;
using Nop.Web.Infrastructure.Installation;
using SkiaSharp;
using IAuthenticationService = Nop.Services.Authentication.IAuthenticationService;
using Task = System.Threading.Tasks.Task;

namespace Nop.Tests;

public partial class BaseNopTest
{
    private static readonly ServiceProvider _serviceProvider;

    protected BaseNopTest()
    {
        SetDataProviderType(DataProviderType.Unknown);
    }

    public ServiceProvider ServiceProvider => _serviceProvider;

    private static void Init()
    {
        var dataProvider = _serviceProvider.GetService<IDataProviderManager>().DataProvider;

        dataProvider.CreateDatabase();
        dataProvider.InitializeDatabase();

        var installationService = _serviceProvider.GetService<IInstallationService>();

        installationService.InstallAsync(
            new InstallationSettings
            {
                AdminEmail = NopTestsDefaults.AdminEmail,
                AdminPassword = NopTestsDefaults.AdminPassword,
                LanguagePackDownloadLink = string.Empty,
                LanguagePackProgress = 0,
                RegionInfo = new RegionInfo(NopCommonDefaults.DefaultLanguageCulture),
                CultureInfo = new CultureInfo(NopCommonDefaults.DefaultLanguageCulture),
                InstallSampleData = true
            }).Wait();

        var permissionService = EngineContext.Current.Resolve<IPermissionService>();
        permissionService.InsertPermissionsAsync().Wait();
    }

    protected static void PropertiesShouldEqual<T1, T2>(T1 obj1, T2 obj2, params string[] filter)
    {
        var object1Properties = typeof(T1).GetProperties();
        var object2Properties = typeof(T2).GetProperties();

        foreach (var object1Property in object1Properties)
        {
            var name = object1Property.Name;

            if (filter.Contains(name))
                continue;

            var object2Property = Array.Find(object2Properties, p => p.Name == name);

            if (object2Property == null)
                continue;

            var object1PropertyValue = object1Property.GetValue(obj1);
            var object2PropertyValue = object2Property.GetValue(obj2);

            object1PropertyValue.Should().Be(object2PropertyValue, $"The property \"{typeof(T1).Name}.{object1Property.Name}\" of these objects is not equal");
        }
    }

    static BaseNopTest()
    {
        SetDataProviderType(DataProviderType.Unknown);

        TypeDescriptor.AddAttributes(typeof(List<int>),
            new TypeConverterAttribute(typeof(GenericListTypeConverter<int>)));
        TypeDescriptor.AddAttributes(typeof(List<string>),
            new TypeConverterAttribute(typeof(GenericListTypeConverter<string>)));

        var services = new ServiceCollection();

        var rootPath =
            new DirectoryInfo(
                    $"{Directory.GetCurrentDirectory().Split("bin")[0]}{Path.Combine([.. @"\..\..\Presentation\Nop.Web".Split('\\', '/')])}")
                .FullName;

        //Presentation\Nop.Web\wwwroot
        var webHostEnvironment = new Mock<IWebHostEnvironment>();
        webHostEnvironment.Setup(p => p.WebRootPath).Returns(Path.Combine(rootPath, "wwwroot"));
        webHostEnvironment.Setup(p => p.ContentRootPath).Returns(rootPath);
        webHostEnvironment.Setup(p => p.EnvironmentName).Returns("test");
        webHostEnvironment.Setup(p => p.ApplicationName).Returns("nopCommerce");
        services.AddSingleton(webHostEnvironment.Object);

        var htmlHelper = new Mock<IHtmlHelper>();
        services.AddSingleton(htmlHelper.Object);

        //file provider
        services.AddTransient<INopFileProvider, NopFileProvider>();
        CommonHelper.DefaultFileProvider = new NopFileProvider(webHostEnvironment.Object);

        services.AddHttpClient();

        var memoryCache = new MemoryCache(new MemoryCacheOptions());
        var typeFinder = new WebAppTypeFinder();
        Singleton<ITypeFinder>.Instance = typeFinder;

        var mAssemblies = typeFinder.FindClassesOfType<ForwardOnlyMigration>()
            .Select(t => t.Assembly)
            .Distinct()
            .ToArray();

        //create app settings
        var configurations = typeFinder
            .FindClassesOfType<IConfig>()
            .Select(configType => (IConfig)Activator.CreateInstance(configType))
            .ToList();

        var appSettings = new AppSettings(configurations);
        appSettings.Update(new List<IConfig> { Singleton<DataConfig>.Instance });
        Singleton<AppSettings>.Instance = appSettings;
        services.AddSingleton(appSettings);

        var hostApplicationLifetime = new Mock<IHostApplicationLifetime>();
        services.AddSingleton(hostApplicationLifetime.Object);

        services.AddWebEncoders();

        var httpContext = new DefaultHttpContext();
        httpContext.Request.Headers.Append(HeaderNames.Host, NopTestsDefaults.HostIpAddress);
        httpContext.Session = new TestSeesion();

        var httpContextAccessor = new Mock<IHttpContextAccessor>();
        httpContextAccessor.Setup(p => p.HttpContext).Returns(httpContext);

        services.AddSingleton(httpContextAccessor.Object);

        var actionContextAccessor = new Mock<IActionContextAccessor>();
        actionContextAccessor.Setup(x => x.ActionContext)
            .Returns(new ActionContext(httpContext, httpContext.GetRouteData(), new ActionDescriptor()));

        services.AddSingleton(actionContextAccessor.Object);

        var urlHelperFactory = new Mock<IUrlHelperFactory>();
        var urlHelper = new NopTestUrlHelper(actionContextAccessor.Object.ActionContext);

        urlHelperFactory.Setup(x => x.GetUrlHelper(It.IsAny<ActionContext>()))
            .Returns(urlHelper);

        services.AddTransient(_ => actionContextAccessor.Object);

        services.AddSingleton(urlHelperFactory.Object);

        var tempDataDictionaryFactory = new Mock<ITempDataDictionaryFactory>();
        var dataDictionary = new TempDataDictionary(httpContextAccessor.Object.HttpContext,
            new Mock<ITempDataProvider>().Object);
        tempDataDictionaryFactory.Setup(f => f.GetTempData(It.IsAny<HttpContext>())).Returns(dataDictionary);
        services.AddSingleton(tempDataDictionaryFactory.Object);

        services.AddSingleton<ITypeFinder>(typeFinder);
        Singleton<ITypeFinder>.Instance = typeFinder;

        //web helper
        services.AddTransient<IWebHelper, WebHelper>();

        //user agent helper
        services.AddTransient<IUserAgentHelper, UserAgentHelper>();

        //data layer
        services.AddSingleton<IDataProviderManager, TestDataProviderManager>();
        services.AddSingleton(serviceProvider =>
            serviceProvider.GetRequiredService<IDataProviderManager>().DataProvider);

        //repositories
        services.AddTransient(typeof(IRepository<>), typeof(EntityRepository<>));

        //plugins
        services.AddTransient<IPluginService, PluginService>();

        services.AddScoped<IShortTermCacheManager, PerRequestCacheManager>();

        services.AddSingleton<ICacheKeyManager, CacheKeyManager>();
        services.AddSingleton<IMemoryCache>(memoryCache);
        services.AddSingleton<IStaticCacheManager, MemoryCacheManager>();
        services.AddSingleton<ILocker, MemoryCacheLocker>();
        services.AddSingleton<MemoryCacheLocker>();

        services.AddTransient(typeof(IConcurrentCollection<>), typeof(ConcurrentTrie<>));

        var memoryDistributedCache = new MemoryDistributedCache(new TestMemoryDistributedCacheOptions());
        services.AddSingleton<IDistributedCache>(memoryDistributedCache);
        services.AddScoped<MemoryDistributedCacheManager>();
        services.AddSingleton(new DistributedCacheLocker(memoryDistributedCache));

        //services
        services.AddTransient<IBackInStockSubscriptionService, BackInStockSubscriptionService>();
        services.AddTransient<ICategoryService, CategoryService>();
        services.AddTransient<IFilterLevelValueService, FilterLevelValueService>();
        services.AddTransient<ICompareProductsService, CompareProductsService>();
        services.AddTransient<IRecentlyViewedProductsService, RecentlyViewedProductsService>();
        services.AddTransient<IManufacturerService, ManufacturerService>();
        services.AddTransient<IPriceFormatter, PriceFormatter>();
        services.AddTransient<IProductAttributeFormatter, ProductAttributeFormatter>();
        services.AddTransient<IProductAttributeParser, ProductAttributeParser>();
        services.AddTransient<IProductAttributeService, ProductAttributeService>();
        services.AddTransient<IProductService, ProductService>();
        services.AddTransient<IProductReviewService, ProductReviewService>();
        services.AddTransient<ICopyProductService, CopyProductService>();
        services.AddTransient<ISpecificationAttributeService, SpecificationAttributeService>();
        services.AddTransient<IProductTemplateService, ProductTemplateService>();
        services.AddTransient<ICategoryTemplateService, CategoryTemplateService>();
        services.AddTransient<IManufacturerTemplateService, ManufacturerTemplateService>();
        services.AddTransient<ITopicTemplateService, TopicTemplateService>();
        services.AddTransient<IProductTagService, ProductTagService>();
        services.AddTransient<IAddressService, AddressService>();
        services.AddTransient<IAffiliateService, AffiliateService>();
        services.AddTransient<IArtificialIntelligenceService, ArtificialIntelligenceService>();
        services.AddTransient<IVendorService, VendorService>();

        //attribute services
        services.AddScoped(typeof(IAttributeService<,>), typeof(AttributeService<,>));

        //attribute parsers
        services.AddScoped(typeof(IAttributeParser<,>), typeof(AttributeParser<,>));

        //attribute formatter
        services.AddScoped(typeof(IAttributeFormatter<,>), typeof(AttributeFormatter<,>));

        services.AddTransient<ISearchTermService, SearchTermService>();
        services.AddTransient<IGenericAttributeService, GenericAttributeService>();
        services.AddTransient<IMaintenanceService, MaintenanceService>();
        services.AddTransient<ICustomerService, CustomerService>();
        services.AddTransient<ICustomerRegistrationService, CustomerRegistrationService>();
        services.AddTransient<ICustomerReportService, CustomerReportService>();
        services.AddTransient<IPermissionService, PermissionService>();
        services.AddTransient<IAclService, AclService>();
        services.AddTransient<IPriceCalculationService, PriceCalculationService>();
        services.AddTransient<IGeoLookupService, GeoLookupService>();
        services.AddTransient<ICountryService, CountryService>();
        services.AddTransient<ICurrencyService, CurrencyService>();
        services.AddTransient<IMeasureService, MeasureService>();
        services.AddTransient<IStateProvinceService, StateProvinceService>();
        services.AddTransient<IStoreService, StoreService>();
        services.AddTransient<IStoreMappingService, StoreMappingService>();
        services.AddTransient<IDiscountService, DiscountService>();
        services.AddTransient<ILocalizationService, LocalizationService>();
        services.AddTransient<ILocalizedEntityService, LocalizedEntityService>();
        services.AddTransient(typeof(Lazy<ILocalizationService>));
        services.AddTransient<ITranslationModelFactory, TranslationModelFactory>();
        services.AddTransient<IInstallationLocalizationService, InstallationLocalizationService>();
        services.AddTransient<ILanguageService, LanguageService>();
        services.AddTransient<IDownloadService, DownloadService>();
        services.AddTransient<IMessageTemplateService, MessageTemplateService>();
        services.AddScoped<IMenuService, MenuService>();
        services.AddTransient<IQueuedEmailService, QueuedEmailService>();
        services.AddTransient<INewsLetterSubscriptionService, NewsLetterSubscriptionService>();
        services.AddTransient<INewsLetterSubscriptionTypeService, NewsLetterSubscriptionTypeService>();
        services.AddTransient<INotificationService, NotificationService>();
        services.AddTransient<ICampaignService, CampaignService>();
        services.AddTransient<IEmailAccountService, EmailAccountService>();
        services.AddTransient<IWorkflowMessageService, WorkflowMessageService>();
        services.AddTransient<IMessageTokenProvider, MessageTokenProvider>();
        services.AddTransient<ITokenizer, Tokenizer>();
        services.AddTransient<ISmtpBuilder, TestSmtpBuilder>();
        services.AddTransient<IEmailSender, EmailSender>();
        services.AddTransient<ICheckoutAttributeFormatter, CheckoutAttributeFormatter>();
        services.AddTransient<IGiftCardService, GiftCardService>();
        services.AddTransient<IOrderService, OrderService>();
        services.AddTransient<IOrderReportService, OrderReportService>();
        services.AddTransient<IOrderProcessingService, OrderProcessingService>();
        services.AddTransient<IOrderTotalCalculationService, OrderTotalCalculationService>();
        services.AddTransient<IReturnRequestService, ReturnRequestService>();
        services.AddTransient<IRewardPointService, RewardPointService>();
        services.AddTransient<IShoppingCartService, ShoppingCartService>();
        services.AddTransient<ICustomWishlistService, CustomWishlistService>();
        services.AddTransient<ICustomNumberFormatter, CustomNumberFormatter>();
        services.AddTransient<IPaymentService, PaymentService>();
        services.AddTransient<IEncryptionService, EncryptionService>();
        services.AddTransient<IAuthenticationService, TestAuthenticationService>();
        services.AddTransient<IUrlRecordService, UrlRecordService>();
        services.AddTransient<IShipmentService, ShipmentService>();
        services.AddTransient<IShippingService, ShippingService>();
        services.AddTransient<IWarehouseService, WarehouseService>();
        services.AddTransient<IShippingMethodsService, ShippingMethodsService>();
        services.AddTransient<IDateRangeService, DateRangeService>();
        services.AddTransient<ITaxCategoryService, TaxCategoryService>();
        services.AddTransient<ICheckVatService, CheckVatService>();
        services.AddTransient<ITaxService, TaxService>();
        services.AddTransient<ILogger, DefaultLogger>();
        services.AddTransient<ICustomerActivityService, CustomerActivityService>();
        services.AddTransient<IForumService, ForumService>();
        services.AddTransient<IGdprService, GdprService>();
        services.AddTransient<IPollService, PollService>();
        services.AddTransient<IBlogService, BlogService>();
        services.AddTransient<ITopicService, TopicService>();
        services.AddTransient<INewsService, NewsService>();
        services.AddTransient<IDateTimeHelper, DateTimeHelper>();
        services.AddTransient<IScheduleTaskService, ScheduleTaskService>();
        services.AddTransient<IExportManager, ExportManager>();
        services.AddTransient<IImportManager, ImportManager>();
        services.AddTransient<IPdfService, PdfService>();
        services.AddTransient<IUploadService, UploadService>();
        services.AddTransient<IThemeProvider, ThemeProvider>();
        services.AddTransient<IExternalAuthenticationService, ExternalAuthenticationService>();
        services.AddScoped<IBBCodeHelper, BBCodeHelper>();
        services.AddScoped<IHtmlFormatter, HtmlFormatter>();

        services.AddScoped<INopAssetHelper, NopAssetHelper>();

        //slug route transformer
        services.AddSingleton<IReviewTypeService, ReviewTypeService>();
        services.AddSingleton<IEventPublisher, EventPublisher>();
        services.AddTransient<ISettingService, SettingService>();

        //plugin managers
        services.AddTransient(typeof(IPluginManager<>), typeof(PluginManager<>));
        services.AddTransient<IAuthenticationPluginManager, AuthenticationPluginManager>();
        services.AddTransient<IMultiFactorAuthenticationPluginManager, MultiFactorAuthenticationPluginManager>();
        services.AddTransient<IWidgetPluginManager, WidgetPluginManager>();
        services.AddTransient<IExchangeRatePluginManager, ExchangeRatePluginManager>();
        services.AddTransient<IDiscountPluginManager, DiscountPluginManager>();
        services.AddTransient<IPaymentPluginManager, PaymentPluginManager>();
        services.AddTransient<IPickupPluginManager, PickupPluginManager>();
        services.AddTransient<IShippingPluginManager, ShippingPluginManager>();
        services.AddTransient<ITaxPluginManager, TaxPluginManager>();
        services.AddScoped<ISearchPluginManager, SearchPluginManager>();

        //picture thumb service
        services.AddScoped<IThumbService, ThumbService>();

        services.AddTransient<IPictureService, TestPictureService>();
        services.AddScoped<IVideoService, VideoService>();
        services.AddScoped<INopUrlHelper, NopUrlHelper>();

        //register all settings
        var settings = typeFinder.FindClassesOfType(typeof(ISettings), false).ToList();
        foreach (var setting in settings)
        {
            services.AddTransient(setting,
                context => context.GetRequiredService<ISettingService>().LoadSettingAsync(setting).Result);


        }

        //event consumers
        foreach (var consumer in typeFinder.FindClassesOfType(typeof(IConsumer<>)).ToList())
        {
            var interfaces = consumer.FindInterfaces((type, criteria) => type.IsGenericType && ((Type)criteria).IsAssignableFrom(type.GetGenericTypeDefinition()), typeof(IConsumer<>));
            foreach (var findInterface in interfaces)
            {
                services.AddTransient(findInterface, consumer);
            }
        }

        services.AddSingleton<IInstallationService, InstallationService>();
        services.AddTransient(p => new Lazy<IVersionLoader>(p.GetRequiredService<IVersionLoader>()));

        services
            // add common FluentMigrator services
            .AddFluentMigratorCore()
            // set accessor for the connection string
            .AddScoped<IConnectionStringAccessor>(_ => DataSettingsManager.LoadSettings())
            .AddScoped<IMigrationManager, MigrationManager>()
            .AddScoped<Lazy<IMigrationManager>>()
            .AddSingleton<IConventionSet, NopTestConventionSet>()
            .ConfigureRunner(rb =>
                rb.WithVersionTable(new MigrationVersionInfo()).AddSQLite()
                    // define the assembly containing the migrations
                    .ScanIn(mAssemblies).For.Migrations());

        services.AddOptions<GeneratorOptions>().Configure(go => go.CompatibilityMode = CompatibilityMode.LOOSE);

        services.AddScoped<IStoreContext, WebStoreContext>();
        services.AddTransient<Lazy<IStoreContext>>();
        services.AddScoped<IWorkContext, WebWorkContext>();
        services.AddTransient<Lazy<IWorkContext>>();
        services.AddTransient<IThemeContext, ThemeContext>();
        services.AddTransient<Lazy<ILocalizationService>>();
        services.AddTransient<INopHtmlHelper, NopHtmlHelper>();

        //schedule tasks
        services.AddSingleton<ITaskScheduler, TestTaskScheduler>();
        services.AddTransient<IScheduleTaskRunner, ScheduleTaskRunner>();

        //WebOptimizer
        services.AddWebOptimizer();

        //common factories
        services.AddTransient<IDiscountSupportedModelFactory, DiscountSupportedModelFactory>();
        services.AddTransient<ILocalizedModelFactory, LocalizedModelFactory>();
        services.AddTransient<IStoreMappingSupportedModelFactory, StoreMappingSupportedModelFactory>();

        //admin factories
        services.AddTransient<IAclSupportedModelFactory, AclSupportedModelFactory>();
        services.AddTransient<IBaseAdminModelFactory, BaseAdminModelFactory>();
        services.AddTransient<IActivityLogModelFactory, ActivityLogModelFactory>();
        services.AddTransient<IAddressAttributeModelFactory, AddressAttributeModelFactory>();
        services.AddTransient<IAffiliateModelFactory, AffiliateModelFactory>();
        services.AddTransient<IBlogModelFactory, BlogModelFactory>();
        services.AddTransient<ICampaignModelFactory, CampaignModelFactory>();
        services.AddTransient<ICategoryModelFactory, CategoryModelFactory>();
        services.AddTransient<ICheckoutAttributeModelFactory, CheckoutAttributeModelFactory>();
        services.AddTransient<ICommonModelFactory, CommonModelFactory>();
        services.AddTransient<ICountryModelFactory, CountryModelFactory>();
        services.AddTransient<ICurrencyModelFactory, CurrencyModelFactory>();
        services.AddTransient<ICustomerAttributeModelFactory, CustomerAttributeModelFactory>();
        services.AddTransient<ICustomerModelFactory, CustomerModelFactory>();
        services.AddTransient<ICustomerRoleModelFactory, CustomerRoleModelFactory>();
        services.AddTransient<IDiscountModelFactory, DiscountModelFactory>();
        services.AddTransient<IEmailAccountModelFactory, EmailAccountModelFactory>();
        services
            .AddTransient<IExternalAuthenticationMethodModelFactory, ExternalAuthenticationMethodModelFactory>();
        services.AddTransient<IForumModelFactory, ForumModelFactory>();
        services.AddTransient<IGiftCardModelFactory, GiftCardModelFactory>();
        services.AddTransient<IHomeModelFactory, HomeModelFactory>();
        services.AddTransient<ILanguageModelFactory, LanguageModelFactory>();
        services.AddTransient<ILogModelFactory, LogModelFactory>();
        services.AddTransient<IManufacturerModelFactory, ManufacturerModelFactory>();
        services.AddTransient<IMeasureModelFactory, MeasureModelFactory>();
        services.AddTransient<IMessageTemplateModelFactory, MessageTemplateModelFactory>();
        services.AddTransient<INewsLetterSubscriptionModelFactory, NewsLetterSubscriptionModelFactory>();
        services.AddTransient<INewsModelFactory, NewsModelFactory>();
        services.AddTransient<IOrderModelFactory, OrderModelFactory>();
        services.AddTransient<IPaymentModelFactory, PaymentModelFactory>();
        services.AddTransient<IPluginModelFactory, PluginModelFactory>();
        services.AddTransient<IPollModelFactory, PollModelFactory>();
        services.AddTransient<IProductModelFactory, ProductModelFactory>();
        services.AddTransient<ProductModelFactoryTests.ProductModelFactoryForTest>();
        services.AddTransient<IProductAttributeModelFactory, ProductAttributeModelFactory>();
        services.AddTransient<IProductReviewModelFactory, ProductReviewModelFactory>();
        services.AddTransient<IReportModelFactory, ReportModelFactory>();
        services.AddTransient<IQueuedEmailModelFactory, QueuedEmailModelFactory>();
        services.AddTransient<IRecurringPaymentModelFactory, RecurringPaymentModelFactory>();
        services.AddTransient<IReturnRequestModelFactory, ReturnRequestModelFactory>();
        services.AddTransient<IReviewTypeModelFactory, ReviewTypeModelFactory>();
        services.AddTransient<IScheduleTaskModelFactory, ScheduleTaskModelFactory>();
        services.AddTransient<ISecurityModelFactory, SecurityModelFactory>();
        services.AddTransient<ISettingModelFactory, SettingModelFactory>();
        services.AddTransient<IShippingModelFactory, ShippingModelFactory>();
        services.AddTransient<IShoppingCartModelFactory, ShoppingCartModelFactory>();
        services.AddTransient<ISpecificationAttributeModelFactory, SpecificationAttributeModelFactory>();
        services.AddTransient<IStoreModelFactory, StoreModelFactory>();
        services.AddTransient<ITaxModelFactory, TaxModelFactory>();
        services.AddTransient<ITemplateModelFactory, TemplateModelFactory>();
        services.AddTransient<ITopicModelFactory, TopicModelFactory>();
        services.AddTransient<IVendorAttributeModelFactory, VendorAttributeModelFactory>();
        services.AddTransient<IVendorModelFactory, VendorModelFactory>();
        services.AddTransient<Web.Framework.Factories.IWidgetModelFactory, Web.Framework.Factories.WidgetModelFactory>();

        //factories
        services.AddTransient<Web.Factories.IAddressModelFactory, Web.Factories.AddressModelFactory>();
        services.AddTransient<Web.Factories.IBlogModelFactory, Web.Factories.BlogModelFactory>();
        services.AddTransient<Web.Factories.ICatalogModelFactory, Web.Factories.CatalogModelFactory>();
        services.AddTransient<Web.Factories.ICheckoutModelFactory, Web.Factories.CheckoutModelFactory>();
        services.AddTransient<Web.Factories.ICommonModelFactory, Web.Factories.CommonModelFactory>();
        services.AddTransient<Web.Factories.ICountryModelFactory, Web.Factories.CountryModelFactory>();
        services.AddTransient<Web.Factories.ICustomerModelFactory, Web.Factories.CustomerModelFactory>();
        services.AddTransient<Web.Factories.IForumModelFactory, Web.Factories.ForumModelFactory>();
        services
            .AddTransient<Web.Factories.IExternalAuthenticationModelFactory,
                Web.Factories.ExternalAuthenticationModelFactory>();
        services.AddTransient<Web.Factories.IJsonLdModelFactory, Web.Factories.JsonLdModelFactory>();
        services.AddTransient<Web.Factories.INewsModelFactory, Web.Factories.NewsModelFactory>();
        services.AddTransient<Web.Factories.INewsLetterModelFactory, Web.Factories.NewsLetterModelFactory>();
        services.AddTransient<Web.Factories.IOrderModelFactory, Web.Factories.OrderModelFactory>();
        services.AddTransient<Web.Factories.IPollModelFactory, Web.Factories.PollModelFactory>();
        services
            .AddTransient<Web.Factories.IPrivateMessagesModelFactory, Web.Factories.PrivateMessagesModelFactory>();
        services.AddTransient<Web.Factories.IProductModelFactory, Web.Factories.ProductModelFactory>();
        services.AddTransient<Web.Factories.IProfileModelFactory, Web.Factories.ProfileModelFactory>();
        services.AddTransient<Web.Factories.IReturnRequestModelFactory, Web.Factories.ReturnRequestModelFactory>();
        services.AddTransient<Web.Factories.IShoppingCartModelFactory, Web.Factories.ShoppingCartModelFactory>();
        services.AddTransient<Web.Factories.ISitemapModelFactory, Web.Factories.SitemapModelFactory>();
        services.AddTransient<Web.Factories.ITopicModelFactory, Web.Factories.TopicModelFactory>();
        services.AddTransient<Web.Factories.IVendorModelFactory, Web.Factories.VendorModelFactory>();

        _serviceProvider = services.BuildServiceProvider();

        EngineContext.Replace(new NopTestEngine(_serviceProvider));

        Init();
    }

    protected static T GetService<T>()
    {
        return _serviceProvider.GetRequiredService<T>();
    }

    protected static T GetService<T>(IServiceScope scope)
    {
        return scope.ServiceProvider.GetService<T>();
    }

    public static bool SetDataProviderType(DataProviderType type)
    {
        var dataConfig = Singleton<DataConfig>.Instance ?? new DataConfig();

        dataConfig.DataProvider = type;
        dataConfig.ConnectionString = string.Empty;

        switch (type)
        {
            case DataProviderType.SqlServer:
                dataConfig.ConnectionString = NopTestConfiguration.SqlServerConnectionString;
                break;
            case DataProviderType.MySql:
                dataConfig.ConnectionString = NopTestConfiguration.MySqlServerConnectionString;
                break;
            case DataProviderType.PostgreSQL:
                dataConfig.ConnectionString = NopTestConfiguration.PostgreSqlServerConnectionString;
                break;
            case DataProviderType.Unknown:
                dataConfig.ConnectionString = NopTestConfiguration.SqliteConnectionString;
                break;
        }
       
        Singleton<DataConfig>.Instance = dataConfig;
        var flag = !string.IsNullOrEmpty(dataConfig.ConnectionString);

        if (Singleton<AppSettings>.Instance == null)
            return flag;

        Singleton<AppSettings>.Instance.Update(new List<IConfig> { Singleton<DataConfig>.Instance });

        return flag;
    }

    #region Nested classes

    protected class NopTestUrlHelper : UrlHelperBase
    {
        public NopTestUrlHelper(ActionContext actionContext) : base(actionContext)
        {
        }

        public override string Action(UrlActionContext actionContext)
        {
            return string.Empty;
        }

        public override string RouteUrl(UrlRouteContext routeContext)
        {
            return string.Empty;
        }
    }

    protected class NopTestConventionSet : NopConventionSet
    {
        public NopTestConventionSet(INopDataProvider dataProvider) : base(dataProvider)
        {
        }
    }

    public partial class NopTestEngine : NopEngine
    {
        protected readonly IServiceProvider _internalServiceProvider;

        public NopTestEngine(IServiceProvider serviceProvider)
        {
            _internalServiceProvider = serviceProvider;
        }

        public override IServiceProvider ServiceProvider => _internalServiceProvider;
    }

    public class TestAuthenticationService : IAuthenticationService
    {
        public Task SignInAsync(Customer customer, bool isPersistent)
        {
            return Task.CompletedTask;
        }

        public Task SignOutAsync()
        {
            return Task.CompletedTask;
        }

        public async Task<Customer> GetAuthenticatedCustomerAsync()
        {
            return await _serviceProvider.GetService<ICustomerService>().GetCustomerByEmailAsync(NopTestsDefaults.AdminEmail);
        }
    }

    protected class TestPictureService : PictureService
    {
        public TestPictureService(IDownloadService downloadService,
            IHttpContextAccessor httpContextAccessor, ILogger logger, INopFileProvider fileProvider,
            IProductAttributeParser productAttributeParser, IProductAttributeService productAttributeService,
            IRepository<Picture> pictureRepository, IRepository<PictureBinary> pictureBinaryRepository,
            IRepository<ProductPicture> productPictureRepository, ISettingService settingService, IThumbService thumbService,
            IUrlRecordService urlRecordService, IWebHelper webHelper, MediaSettings mediaSettings) : base(
            downloadService, httpContextAccessor, logger, fileProvider, productAttributeParser, productAttributeService,
            pictureRepository, pictureBinaryRepository, productPictureRepository, settingService, thumbService, urlRecordService,
            webHelper, mediaSettings)
        {
        }

        // Not all CI/CD support working with named semaphore, that's why we use implementation without it 
        public override async Task<(string Url, Picture Picture)> GetPictureUrlAsync(Picture picture,
            int targetSize = 0,
            bool showDefaultPicture = true,
            string storeLocation = null,
            PictureType defaultPictureType = PictureType.Entity)
        {
            if (picture == null)
            {
                return showDefaultPicture
                    ? (await GetDefaultPictureUrlAsync(targetSize, defaultPictureType, storeLocation), null)
                    : (string.Empty, (Picture)null);
            }

            byte[] pictureBinary = null;
            if (picture.IsNew)
            {
                await _thumbService.DeletePictureThumbsAsync(picture);
                pictureBinary = await LoadPictureBinaryAsync(picture);

                if ((pictureBinary?.Length ?? 0) == 0)
                {
                    return showDefaultPicture
                        ? (await GetDefaultPictureUrlAsync(targetSize, defaultPictureType, storeLocation), picture)
                        : (string.Empty, picture);
                }

                //we do not validate picture binary here to ensure that no exception ("Parameter is not valid") will be thrown
                picture = await UpdatePictureAsync(picture.Id,
                    pictureBinary,
                    picture.MimeType,
                    picture.SeoFilename,
                    picture.AltAttribute,
                    picture.TitleAttribute,
                    false,
                    false);
            }

            var seoFileName = picture.SeoFilename; // = GetPictureSeName(picture.SeoFilename); //just for sure

            var lastPart = await GetFileExtensionFromMimeTypeAsync(picture.MimeType);
            string thumbFileName;
            if (targetSize == 0)
            {
                thumbFileName = !string.IsNullOrEmpty(seoFileName)
                    ? $"{picture.Id:0000000}_{seoFileName}.{lastPart}"
                    : $"{picture.Id:0000000}.{lastPart}";

                var thumbFilePath = await _thumbService.GetThumbLocalPathAsync(thumbFileName);
                if (await _thumbService.GeneratedThumbExistsAsync(thumbFilePath, thumbFileName))
                    return (await _thumbService.GetThumbUrlAsync(thumbFileName, storeLocation), picture);

                pictureBinary ??= await LoadPictureBinaryAsync(picture);

                //the named mutex helps to avoid creating the same files in different threads,
                //and does not decrease performance significantly, because the code is blocked only for the specific file.
                //you should be very careful, mutexes cannot be used in with the await operation
                //we can't use semaphore here, because it produces PlatformNotSupportedException exception on UNIX based systems
                using var mutex = new Mutex(false, thumbFileName);
                mutex.WaitOne();
                try
                {
                    _thumbService.SaveThumbAsync(thumbFilePath, thumbFileName, string.Empty, pictureBinary).Wait();
                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }
            else
            {
                thumbFileName = !string.IsNullOrEmpty(seoFileName)
                    ? $"{picture.Id:0000000}_{seoFileName}_{targetSize}.{lastPart}"
                    : $"{picture.Id:0000000}_{targetSize}.{lastPart}";

                var thumbFilePath = await _thumbService.GetThumbLocalPathAsync(thumbFileName);
                if (await _thumbService.GeneratedThumbExistsAsync(thumbFilePath, thumbFileName))
                    return (await _thumbService.GetThumbUrlAsync(thumbFileName, storeLocation), picture);

                pictureBinary ??= await LoadPictureBinaryAsync(picture);

                //the named mutex helps to avoid creating the same files in different threads,
                //and does not decrease performance significantly, because the code is blocked only for the specific file.
                //you should be very careful, mutexes cannot be used in with the await operation
                //we can't use semaphore here, because it produces PlatformNotSupportedException exception on UNIX based systems
                using var mutex = new Mutex(false, thumbFileName);
                mutex.WaitOne();
                try
                {
                    if (pictureBinary != null)
                    {
                        try
                        {
                            using var image = SKBitmap.Decode(pictureBinary);
                            var format = GetImageFormatByMimeType(picture.MimeType);
                            pictureBinary = ImageResize(image, format, targetSize);
                        }
                        catch
                        {
                        }
                    }

                    _thumbService.SaveThumbAsync(thumbFilePath, thumbFileName, string.Empty, pictureBinary).Wait();
                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }

            return (await _thumbService.GetThumbUrlAsync(thumbFileName, storeLocation), picture);
        }
    }

    private class TestMemoryDistributedCache
    {
        public TestMemoryDistributedCache()
        {
        }
    }

    private class TestMemoryDistributedCacheOptions : IOptions<MemoryDistributedCacheOptions>
    {
        public MemoryDistributedCacheOptions Value => new();
    }

    private class TestSeesion : ISession
    {
        private static ConcurrentDictionary<string, byte[]> _sessison = new();

        public Task LoadAsync(CancellationToken cancellationToken = new())
        {
            return Task.CompletedTask;
        }

        public Task CommitAsync(CancellationToken cancellationToken = new())
        {
            return Task.CompletedTask;
        }

        public bool TryGetValue(string key, out byte[] value)
        {
            return _sessison.TryGetValue(key, out value);
        }

        public void Set(string key, byte[] value)
        {
            if (!_sessison.ContainsKey(key))
                _sessison.TryAdd(key, value);
            else
                _sessison[key] = value;
        }

        public void Remove(string key)
        {
            _sessison.Remove(key, out _);
        }

        public void Clear()
        {
            _sessison.Clear();
        }

        public bool IsAvailable => true;
        public string Id => "nop_test_session";
        public IEnumerable<string> Keys => _sessison.Keys;
    }

    #endregion
}