using Abp.Application.Navigation;
using Abp.AutoMapper;
using Abp.Collections.Extensions;
using Abp.Configuration.Startup;
using Abp.Dependency;
using Abp.MailKit;
using Abp.Modules;
using Abp.Reflection.Extensions;
using Abp.Threading.BackgroundWorkers;

using VberZero.Authorization.Users;
using VberZero.BaseSystem;
using VberZero.Configuration;
using VberZero.DomainService.AppGuids;
using VberZero.Localization;
using VberZero.MultiTenancy;
using VberZero.Navigation;
using VberZero.Settings;
using VberZero.Workflow;
using VberZero.Workflows;

namespace VberZero;

[DependsOn(
    typeof(VberWorkflowModule),
    typeof(AbpAutoMapperModule),
    typeof(AbpMailKitModule)
    )]
public class VberZeroModule : AbpModule
{
    public bool IsSkip = false;

    public override void PreInitialize()
    {
        //IocManager.RegisterIfNot<IAbpZeroEntityTypes, AbpZeroEntityTypes>(); //Registered on services.AddAbpIdentity() for Abp.ZeroCore.

        IocManager.Register<IRoleManagementConfig, RoleManagementConfig>();
        IocManager.Register<IUserManagementConfig, UserManagementConfig>();
        //IocManager.Register<ILanguageManagementConfig, LanguageManagementConfig>();
        IocManager.Register<IVzConfig, VzConfig>();

        Configuration.ReplaceService<Abp.MultiTenancy.ITenantStore, TenantStore>(DependencyLifeStyle.Transient);

        IocManager.Register<INavigationProviderContext, VzNavigationProviderContext>();
        Configuration.ReplaceService<INavigationManager, VzNavigationManager>();
        Configuration.ReplaceService<IVberPersistenceProvider, VbWorkflowPersistenceProvider>();

        Configuration.Settings.Providers.Add<VzSettingProvider>();

        Configuration.Localization.Configure();

        IocManager.IocContainer.Kernel.ComponentRegistered += Kernel_ComponentRegistered;
        AddIgnoredTypes();

        //添加StepBody
        Configuration.GetStepBodyConfiguration().Providers.Add<DefaultStepBodyProvider>();
    }

    public override void Initialize()
    {
        //FillMissingEntityTypes();
        //IocManager.Register<IMultiTenantLocalizationDictionary, MultiTenantLocalizationDictionary>(DependencyLifeStyle.Transient);

        IocManager.Register(typeof(UserTokenExpirationWorker));
        var thisAssembly = typeof(VberZeroModule).GetAssembly();
        IocManager.RegisterAssemblyByConvention(thisAssembly);
        Configuration.Modules.AbpAutoMapper().Configurators.Add(
            //程序集中从 AutoMapper.Profile 继承的类
            cfg => cfg.AddMaps(thisAssembly)
        );

        RegisterTenantCache();
    }

    public override void PostInitialize()
    {
        if (Configuration.BackgroundJobs.IsJobExecutionEnabled)
        {
            var workerManager = IocManager.Resolve<IBackgroundWorkerManager>();
            workerManager.Add(IocManager.Resolve(typeof(UserTokenExpirationWorker)) as IBackgroundWorker);
        }

        if (!IsSkip)
        {
            IocManager.Resolve<VzNavigationManager>().Initialize();
            IocManager.Resolve<RecordIdManager>().LoadDictionary();
        }
    }

    private void Kernel_ComponentRegistered(string key, Castle.MicroKernel.IHandler handler)
    {
        //if (typeof(IAbpZeroFeatureValueStore).IsAssignableFrom(handler.ComponentModel.Implementation) && !IocManager.IsRegistered<IAbpZeroFeatureValueStore>())
        //{
        //    IocManager.IocContainer.Register(
        //        Component.For<IAbpZeroFeatureValueStore>().ImplementedBy(handler.ComponentModel.Implementation).Named("AbpZeroFeatureValueStore").LifestyleTransient()
        //        );
        //}
    }

    private void AddIgnoredTypes()
    {
        var ignoredTypes = new[] { typeof(AuditLog) };

        foreach (var ignoredType in ignoredTypes)
        {
            Configuration.EntityHistory.IgnoredTypes.AddIfNotContains(ignoredType);
        }
    }

    private void RegisterTenantCache()
    {
        if (IocManager.IsRegistered<ITenantCache>())
        {
            return;
        }

        //using var entityTypes = IocManager.ResolveAsDisposable<IAbpZeroEntityTypes>();
        //var implType = typeof(TenantCache)
        //    .MakeGenericType(entityTypes.Object.Tenant, entityTypes.Object.User);

        IocManager.Register(typeof(ITenantCache), typeof(TenantCache), DependencyLifeStyle.Transient);
    }

    //private void FillMissingEntityTypes()
    //{
    //    using var entityTypes = IocManager.ResolveAsDisposable<IAbpZeroEntityTypes>();
    //    if (entityTypes.Object.User != null &&
    //        entityTypes.Object.Role != null &&
    //        entityTypes.Object.Tenant != null)
    //    {
    //        return;
    //    }

    //    using var typeFinder = IocManager.ResolveAsDisposable<ITypeFinder>();
    //    var types = typeFinder.Object.FindAll();
    //    entityTypes.Object.Tenant = types.FirstOrDefault(t => typeof(Tenant).IsAssignableFrom(t) && !t.GetTypeInfo().IsAbstract);
    //    entityTypes.Object.Role = types.FirstOrDefault(t => typeof(Role).IsAssignableFrom(t) && !t.GetTypeInfo().IsAbstract);
    //    entityTypes.Object.User = types.FirstOrDefault(t => typeof(User).IsAssignableFrom(t) && !t.GetTypeInfo().IsAbstract);
    //}

    //private void RegisterUserTokenExpirationWorker()
    //{
    //    using var entityTypes = IocManager.ResolveAsDisposable<IAbpZeroEntityTypes>();
    //    var implType = typeof(UserTokenExpirationWorker)
    //        .MakeGenericType(entityTypes.Object.Tenant, entityTypes.Object.User);
    //    IocManager.Register(implType);
    //}
}