#nullable enable

using Abp.Domain.Entities;
using Abp.EntityFrameworkCore;
using Abp.Notifications;
using Abp.Webhooks;

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

using System.ComponentModel.DataAnnotations.Schema;
using System.Reflection;

using VberZero.BaseSystem;
using VberZero.BaseSystem.Organizations;
using VberZero.BaseSystem.Roles;
using VberZero.BaseSystem.Users;
using VberZero.EntityHistory;

namespace VberZero.EntityFramework;

public abstract class VzCommonDbContext<TSelf> : AbpDbContext
    where TSelf : VzCommonDbContext<TSelf>
{
    public virtual DbSet<Role> Roles { get; set; }

    public virtual DbSet<User> Users { get; set; }

    public virtual DbSet<SysFunction> SysFunctions { get; set; }
    public virtual DbSet<SysHelp> SysHelps { get; set; }
    public virtual DbSet<SysAttach> SysAttaches { get; set; }
    public virtual DbSet<SysState> SysStates { get; set; }
    public virtual DbSet<SysCalendar> SysCalendars { get; set; }
    public virtual DbSet<SysAutoCompleteQuery> SysAutoCompleteQueries { get; set; }

    public virtual DbSet<SysSetting> SysSettings { get; set; }

    public virtual DbSet<UserLogin> UserLogins { get; set; }

    public virtual DbSet<UserLoginAttempt> UserLoginAttempts { get; set; }

    public virtual DbSet<UserRole> UserRoles { get; set; }

    public virtual DbSet<UserClaim> UserClaims { get; set; }

    public virtual DbSet<UserToken> UserTokens { get; set; }

    public virtual DbSet<RoleClaim> RoleClaims { get; set; }

    public virtual DbSet<PermissionSetting> Permissions { get; set; }

    public virtual DbSet<RolePermissionSetting> RolePermissions { get; set; }

    public virtual DbSet<UserPermissionSetting> UserPermissions { get; set; }

    public virtual DbSet<AuditLog> AuditLogs { get; set; }

    public virtual DbSet<OrganizationUnit> OrganizationUnits { get; set; }

    public virtual DbSet<UserOrganizationUnit> UserOrganizationUnits { get; set; }

    public virtual DbSet<OrganizationUnitRole> OrganizationUnitRoles { get; set; }

    public virtual DbSet<TenantNotificationInfo> TenantNotifications { get; set; }

    public virtual DbSet<UserNotificationInfo> UserNotifications { get; set; }

    public virtual DbSet<NotificationSubscriptionInfo> NotificationSubscriptions { get; set; }
    public virtual DbSet<WebhookEvent> WebhookEvents { get; set; }

    public virtual DbSet<WebhookSubscriptionInfo> WebhookSubscriptions { get; set; }

    public virtual DbSet<WebhookSendAttempt> WebhookSendAttempts { get; set; }

    //public virtual DbSet<EntityChange> EntityChanges { get; set; }
    //public virtual DbSet<EntityChangeSet> EntityChangeSets { get; set; }
    //public virtual DbSet<EntityPropertyChange> EntityPropertyChanges { get; set; }

    //public virtual DbSet<ApplicationLanguage> Languages { get; set; }
    //public virtual DbSet<ApplicationLanguageText> LanguageTexts { get; set; }

    //public virtual DbSet<DynamicProperty> DynamicProperties { get; set; }
    //public virtual DbSet<DynamicPropertyValue> DynamicPropertyValues { get; set; }
    //public virtual DbSet<DynamicEntityProperty> DynamicEntityProperties { get; set; }
    //public virtual DbSet<DynamicEntityPropertyValue> DynamicEntityPropertyValues { get; set; }

    public IEntityHistoryHelper EntityHistoryHelper { get; set; }

    /// <summary>
    ///
    /// </summary>
    /// <param name="options"></param>
    protected VzCommonDbContext(DbContextOptions<TSelf> options)
        : base(options)
    {
    }

    public override int SaveChanges()
    {
        //var changeSet = EntityHistoryHelper.CreateEntityChangeSet(ChangeTracker.Entries().ToList());

        var result = base.SaveChanges();

        //EntityHistoryHelper.Save(changeSet);

        return result;
    }

    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken))
    {
        //var changeSet = EntityHistoryHelper.CreateEntityChangeSet(ChangeTracker.Entries().ToList());

        var result = await base.SaveChangesAsync(cancellationToken);

        //if (EntityHistoryHelper != null)
        //{
        //    await EntityHistoryHelper.SaveAsync(changeSet);
        //}

        return result;
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        //base.OnModelCreating(modelBuilder);

        //取消删除级联
        SetForeignKeyDeleteBehaviors(modelBuilder);

        //全局配置
        foreach (var entityType in modelBuilder.Model.GetEntityTypes())
        {
            ConfigureGlobalFiltersMethodInfo?.MakeGenericMethod(entityType.ClrType)
                .Invoke(this, new object[] { modelBuilder, entityType });

            ConfigureGlobalValueConverterMethodInfo?.MakeGenericMethod(entityType.ClrType)
                .Invoke(this, new object[] { modelBuilder, entityType });
        }

        modelBuilder.Entity<User>(b =>
        {
            b.Property(u => u.ConcurrencyStamp).IsConcurrencyToken();

            b.HasOne(p => p.DeleterUser)
                .WithMany()
                .HasForeignKey(p => p.DeleterUserId).OnDelete(DeleteBehavior.Restrict);

            b.HasOne(p => p.CreatorUser)
                .WithMany()
                .HasForeignKey(p => p.CreatorUserId).OnDelete(DeleteBehavior.Restrict);

            b.HasOne(p => p.LastModifierUser)
                .WithMany()
                .HasForeignKey(p => p.LastModifierUserId).OnDelete(DeleteBehavior.Restrict);

            b.HasIndex(e => new { e.TenantId, e.NormalizedUserName });
            b.HasIndex(e => new { e.TenantId, e.NormalizedEmailAddress });
        });

        modelBuilder.Entity<Role>(b =>
        {
            b.Property(r => r.ConcurrencyStamp).IsConcurrencyToken();

            b.HasIndex(e => new { e.TenantId, e.NormalizedName });
        });

        modelBuilder.Entity<AuditLog>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.UserId });
            b.HasIndex(e => new { e.TenantId, e.ExecutionTime });
            b.HasIndex(e => new { e.TenantId, e.ExecutionDuration });
        });

        modelBuilder.Entity<NotificationSubscriptionInfo>(b =>
        {
            b.HasIndex(e => new { e.NotificationName, e.EntityTypeName, e.EntityId, e.UserId });
            b.HasIndex(e => new { e.TenantId, e.NotificationName, e.EntityTypeName, e.EntityId, e.UserId });
        });

        modelBuilder.Entity<OrganizationUnit>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.Code }).IsUnique(false);
        });

        modelBuilder.Entity<PermissionSetting>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.Name });
        });

        modelBuilder.Entity<RoleClaim>(b =>
        {
            b.HasIndex(e => new { e.RoleId });
            b.HasIndex(e => new { e.TenantId, e.ClaimType });
        });

        modelBuilder.Entity<SysSetting>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.Name, e.UserId }).IsUnique().HasFilter(null);
        });

        modelBuilder.Entity<TenantNotificationInfo>(b =>
        {
            b.HasIndex(e => new { e.TenantId });
        });

        modelBuilder.Entity<UserClaim>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.ClaimType });
        });

        modelBuilder.Entity<UserLoginAttempt>(b =>
        {
            b.HasIndex(e => new { e.TenancyName, e.UserNameOrEmailOrPhone, e.Result });
            b.HasIndex(ula => new { ula.UserId, ula.TenantId });
        });

        modelBuilder.Entity<UserLogin>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.LoginProvider, e.ProviderKey });
            b.HasIndex(e => new { e.TenantId, e.UserId });
            b.HasIndex(e => new { e.ProviderKey, e.TenantId }).IsUnique();
        });

        modelBuilder.Entity<UserNotificationInfo>(b =>
        {
            b.HasIndex(e => new { e.UserId, e.State, e.CreationTime });
        });

        modelBuilder.Entity<UserOrganizationUnit>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.UserId });
            b.HasIndex(e => new { e.TenantId, e.OrganizationUnitId });
        });

        modelBuilder.Entity<OrganizationUnitRole>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.RoleId });
            b.HasIndex(e => new { e.TenantId, e.OrganizationUnitId });
        });

        modelBuilder.Entity<UserRole>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.UserId });
            b.HasIndex(e => new { e.TenantId, e.RoleId });
        });

        modelBuilder.Entity<UserToken>(b =>
        {
            b.HasIndex(e => new { e.TenantId, e.UserId });
        });

        //modelBuilder.Entity<DynamicProperty>(b =>
        //{
        //    b.HasIndex(e => new { e.PropertyName, e.TenantId }).IsUnique();
        //});

        //modelBuilder.Entity<DynamicEntityProperty>(b =>
        //{
        //    b.HasIndex(e => new { e.EntityFullName, e.DynamicPropertyId, e.TenantId }).IsUnique();
        //});

        //modelBuilder.Entity<ApplicationLanguage>(b =>
        //{
        //    b.HasIndex(e => new { e.TenantId, e.Name });
        //});

        //modelBuilder.Entity<ApplicationLanguageText>(b =>
        //{
        //    b.HasIndex(e => new { e.TenantId, e.Source, e.LanguageName, e.Key });
        //});

        //modelBuilder.Entity<EntityChange>(b =>
        //{
        //    b.HasMany(p => p.PropertyChanges)
        //        .WithOne()
        //        .HasForeignKey(p => p.EntityChangeId);

        //    b.HasIndex(e => new { e.EntityChangeSetId });
        //    b.HasIndex(e => new { e.EntityTypeFullName, e.EntityId });
        //});

        //modelBuilder.Entity<EntityChangeSet>(b =>
        //{
        //    b.HasMany(p => p.EntityChanges)
        //        .WithOne()
        //        .HasForeignKey(p => p.EntityChangeSetId);

        //    b.HasIndex(e => new { e.TenantId, e.UserId });
        //    b.HasIndex(e => new { e.TenantId, e.CreationTime });
        //    b.HasIndex(e => new { e.TenantId, e.Reason });
        //});

        //modelBuilder.Entity<EntityPropertyChange>(b =>
        //{
        //    b.HasIndex(e => e.EntityChangeId);
        //});
    }

    private static readonly MethodInfo? ConfigureGlobalFiltersMethodInfo = typeof(VzCommonDbContext<TSelf>).GetMethod(nameof(ConfigureGlobalFilters), BindingFlags.Instance | BindingFlags.NonPublic);

    private static readonly MethodInfo? ConfigureGlobalValueConverterMethodInfo = typeof(VzCommonDbContext<TSelf>).GetMethod(nameof(VzConfigureGlobalValueConverter), BindingFlags.Instance | BindingFlags.NonPublic);

    /// <summary>
    /// 全局配置
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <param name="modelBuilder"></param>
    /// <param name="entityType"></param>
    protected void VzConfigureGlobalValueConverter<TEntity>(ModelBuilder modelBuilder, IMutableEntityType entityType)
        where TEntity : class
    {
        ConfigureGlobalValueConverter<TEntity>(modelBuilder, entityType);
        if (entityType.BaseType == null && !typeof(TEntity).IsDefined(typeof(OwnedAttribute), true) &&
            !entityType.IsOwned())
        {
            if (typeof(IEntity<string>).IsAssignableFrom(typeof(TEntity)))
            {
                //Console.WriteLine(typeof(TEntity).Name);
                //定义主键为string的长度
                modelBuilder
                    .Entity<TEntity>()
                    .Property("Id").HasMaxLength(VzConsts.PrimaryKey);
            }

            //定义外键为string的长度
            var propertyInfos = typeof(TEntity).GetProperties();
            foreach (var info in propertyInfos)
            {
                var name = info.GetCustomAttribute<ForeignKeyAttribute>()?.Name;
                //Console.WriteLine(typeof(TEntity).Name + "====>" + info.Name + "====>" + name);
                if (name != null && typeof(TEntity).GetProperty(name)?.PropertyType == typeof(string))
                {
                    //Console.WriteLine("YYYY");
                    modelBuilder
                        .Entity<TEntity>()
                        .Property(name).HasMaxLength(VzConsts.PrimaryKey);
                    Console.WriteLine(typeof(TEntity).Name + "====>" + info.Name + "====>" + name + "====>长度设为" + VzConsts.PrimaryKey);
                }
            }

            var userId = propertyInfos.FirstOrDefault(a => a.Name == "UserId");
            var tenantId = propertyInfos.FirstOrDefault(a => a.Name == "TenantId");
            if (userId != null && tenantId != null)
            {
                modelBuilder
                    .Entity<TEntity>().HasIndex("UserId", "TenantId");
            }
            else if (userId != null)
            {
                modelBuilder
                    .Entity<TEntity>().HasIndex("UserId");
            }
            else if (tenantId != null)
            {
                modelBuilder
                    .Entity<TEntity>().HasIndex("TenantId");
            }
        }
    }

    /// <summary>
    /// 取消级联删除
    /// </summary>
    /// <param name="modelBuilder"></param>
    protected virtual void SetForeignKeyDeleteBehaviors(ModelBuilder modelBuilder)
    {
        var foreignKeys = modelBuilder.Model.GetEntityTypes().SelectMany(e => e.GetForeignKeys()).Where(fk => fk.DeleteBehavior == DeleteBehavior.Cascade);
        foreach (var fk in foreignKeys)
        {
            fk.DeleteBehavior = DeleteBehavior.Restrict;
        }
    }
}