using IRaCIS.Core.Domain.Models;
using Microsoft.EntityFrameworkCore.Metadata.Builders;


namespace IRaCIS.Core.Infra.EFCore.EntityConfigration
{
    public class SubjectConfigration : IEntityTypeConfiguration<Subject>
    {
        public void Configure(EntityTypeBuilder<Subject> builder)
        {
            //不能同时配置一对多 和一对一 但是有时表要存储多的最新的  比如受试者 最新的访视  在这里要显示配置
            builder.HasOne(s => s.LatestSubjectVisit).WithMany().HasForeignKey(t => t.LatestSubjectVisitId);
            builder.HasOne(s => s.FinalSubjectVisit).WithMany().HasForeignKey(t => t.FinalSubjectVisitId);
            builder.HasMany(s => s.SubjectVisitList).WithOne(sv => sv.Subject).HasForeignKey(t => t.SubjectId);
        }
    }
    public class DictionaryConfigration : IEntityTypeConfiguration<Dictionary>
    {
        public void Configure(EntityTypeBuilder<Dictionary> builder)
        {
            builder.HasOne(t => t.ConfigDictionary).WithMany().HasForeignKey(d => d.ConfigTypeId);
            //自身同时存在一对多 和一对一的关系，配置一对多的就可以，一对一 不用配置，有点奇怪
            builder.HasMany(t => t.ChildList).WithOne(t => t.Parent).HasForeignKey(d => d.ParentId);
        }
    }

    public class NoneDicomStudyConfigration : IEntityTypeConfiguration<NoneDicomStudy>
    {
        public void Configure(EntityTypeBuilder<NoneDicomStudy> builder)
        {
            //同样一个实体 有两个相同的类型的导航属性，需要手动配置
            builder.HasMany(t => t.NoneDicomFileList).WithOne(s => s.NoneDicomStudy).HasForeignKey(t => t.NoneDicomStudyId);
            builder.HasMany(t => t.TaskNoneDicomFileList).WithOne(s => s.OriginNoneDicomStudy).HasForeignKey(t => t.OriginNoneDicomStudyId);

            builder.HasMany(t => t.ImageLabelNoneDicomFileList).WithOne(s => s.ImageMarkNoneDicomStudy).HasForeignKey(t => t.ImageLabelNoneDicomStudyId);


        }
    }

    public class SubjectUserConfigration : IEntityTypeConfiguration<SubjectUser>
    {
        public void Configure(EntityTypeBuilder<SubjectUser> builder)
        {
            //自身存在一对多的关系
            //对于替换后的医生而言，关联多个之前的医生
            builder.HasMany(t => t.EarlierSubjectUserList).WithOne(t => t.ReplacedSubjectUser).HasForeignKey(t => t.ReplacedSubjectUserId);
        }
    }

    public class UserConfigration : IEntityTypeConfiguration<UserRole>
    {
        public void Configure(EntityTypeBuilder<UserRole> builder)
        {
            //User 和VisitTask 存在一对多的关系  这里不显式配置就报错，why?
            builder.HasMany(t => t.VisitTaskList).WithOne(t => t.DoctorUser).HasForeignKey(t => t.DoctorUserId);

            //builder.HasOne(t => t.Doctor).WithOne(t => t.User);
        }
    }

    public class SystemDocConfirmedUserConfigration : IEntityTypeConfiguration<SystemDocConfirmedIdentityUser>
    {
        public void Configure(EntityTypeBuilder<SystemDocConfirmedIdentityUser> builder)
        {
            #region 不用显示配置
            //// 配置 CreateUser 关系
            //builder.HasOne(s => s.CreateUser)
            //    .WithMany()  // 假设 User 表没有对应的反向导航属性，如果有，填入属性名
            //    .HasForeignKey(s => s.CreateUserId);
            ////.OnDelete(DeleteBehavior.Restrict);  // 可根据业务需求调整删除行为
            #endregion

            // 配置 ConfirmUser 关系  （一个用户可以签名多个文档）
            builder.HasOne(s => s.ConfirmUser)  // ConfirmUser
                .WithMany(t => t.SystemDocConfirmedList)
                .HasForeignKey(s => s.ConfirmUserId);
            //.OnDelete(DeleteBehavior.Restrict);
        }
    }

    public class TrialUserConfigration : IEntityTypeConfiguration<TrialUserRole>
    {
        //当一个实体，针对同一个类，有两个一对一导航属性，但是是不同的外键，一个外键是一对一，一个是一对多，那么需要显示配置一对多的关系
        public void Configure(EntityTypeBuilder<TrialUserRole> builder)
        {
            //TrialUser  和User 之间 一对多 （一个用户可以参与多个项目）
            builder.HasOne(s => s.UserRole)
              .WithMany(t => t.UserRoleTrials)
              .HasForeignKey(s => s.UserId);

            //TrialUser User 一对一  创建人
        }
    }

    public class IdentityUserConfigration : IEntityTypeConfiguration<IdentityUser>
    {
        //当一个实体，针对同一个类，有两个一对一导航属性，但是是不同的外键，一个外键是一对一，一个是一对多，那么需要显示配置一对多的关系
        public void Configure(EntityTypeBuilder<IdentityUser> builder)
        {
            builder.HasMany(s => s.UserRoleList)
              .WithOne(t => t.IdentityUser)
              .HasForeignKey(s => s.IdentityUserId);



        }
    }


    public class TrialIdentityUserConfigration : IEntityTypeConfiguration<TrialIdentityUser>
    {
        //当一个实体，针对同一个类，有两个一对一导航属性，但是是不同的外键，一个外键是一对一，一个是一对多，那么需要显示配置一对多的关系
        public void Configure(EntityTypeBuilder<TrialIdentityUser> builder)
        {
            builder.HasMany(s => s.TrialUserRoleList)
              .WithOne(t => t.TrialUser)
              .HasForeignKey(s => s.TrialUserId);
        }
    }


}
