Academic-Affairs-System/src/Jiaowu.Api/Infrastructure/Persistence/AppDbContext.cs

using Jiaowu.Api.Domain.Academic;
using Jiaowu.Api.Domain.Common;
using Jiaowu.Api.Domain.Identity;
using Jiaowu.Api.Domain.System;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace Jiaowu.Api.Infrastructure.Persistence;

public sealed class AppDbContext(DbContextOptions<AppDbContext> options)
    : IdentityDbContext<ApplicationUser, ApplicationRole, Guid>(options)
{
    public DbSet<Campus> Campuses => Set<Campus>();
    public DbSet<College> Colleges => Set<College>();
    public DbSet<Major> Majors => Set<Major>();
    public DbSet<AdministrativeClass> AdministrativeClasses => Set<AdministrativeClass>();
    public DbSet<Building> Buildings => Set<Building>();
    public DbSet<Classroom> Classrooms => Set<Classroom>();
    public DbSet<AcademicTerm> AcademicTerms => Set<AcademicTerm>();
    public DbSet<Teacher> Teachers => Set<Teacher>();
    public DbSet<Student> Students => Set<Student>();
    public DbSet<Course> Courses => Set<Course>();
    public DbSet<CurriculumPlan> CurriculumPlans => Set<CurriculumPlan>();
    public DbSet<CurriculumModule> CurriculumModules => Set<CurriculumModule>();
    public DbSet<CurriculumCourse> CurriculumCourses => Set<CurriculumCourse>();
    public DbSet<TeachingTask> TeachingTasks => Set<TeachingTask>();
    public DbSet<TeachingTaskTeacher> TeachingTaskTeachers => Set<TeachingTaskTeacher>();
    public DbSet<TeachingTaskClass> TeachingTaskClasses => Set<TeachingTaskClass>();
    public DbSet<AuditLog> AuditLogs => Set<AuditLog>();

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        builder.Entity<ApplicationUser>(entity =>
        {
            entity.Property(x => x.DisplayName).HasMaxLength(50);
            entity.Property(x => x.StaffNumber).HasMaxLength(30);
            entity.HasIndex(x => x.StaffNumber);
        });

        builder.Entity<ApplicationRole>(entity =>
        {
            entity.Property(x => x.Description).HasMaxLength(100);
        });

        ConfigureCatalog<Campus>(builder);
        ConfigureCatalog<College>(builder);
        ConfigureCatalog<Major>(builder);
        ConfigureCatalog<AdministrativeClass>(builder);
        ConfigureCatalog<Building>(builder);
        ConfigureCatalog<Classroom>(builder);
        ConfigureCatalog<AcademicTerm>(builder);
        ConfigureCatalog<Course>(builder);

        builder.Entity<College>()
            .HasOne(x => x.Campus)
            .WithMany()
            .HasForeignKey(x => x.CampusId)
            .OnDelete(DeleteBehavior.Restrict);

        builder.Entity<Major>()
            .HasOne(x => x.College)
            .WithMany()
            .HasForeignKey(x => x.CollegeId)
            .OnDelete(DeleteBehavior.Restrict);

        builder.Entity<AdministrativeClass>()
            .HasOne(x => x.Major)
            .WithMany()
            .HasForeignKey(x => x.MajorId)
            .OnDelete(DeleteBehavior.Restrict);

        builder.Entity<Building>()
            .HasOne(x => x.Campus)
            .WithMany()
            .HasForeignKey(x => x.CampusId)
            .OnDelete(DeleteBehavior.Restrict);

        builder.Entity<Classroom>()
            .HasOne(x => x.Building)
            .WithMany()
            .HasForeignKey(x => x.BuildingId)
            .OnDelete(DeleteBehavior.Restrict);

        builder.Entity<AcademicTerm>()
            .HasIndex(x => x.IsCurrent);

        builder.Entity<Teacher>(entity =>
        {
            entity.Property(x => x.TeacherNumber).HasMaxLength(30);
            entity.Property(x => x.Name).HasMaxLength(50);
            entity.Property(x => x.Title).HasMaxLength(30);
            entity.Property(x => x.Phone).HasMaxLength(30);
            entity.Property(x => x.Email).HasMaxLength(100);
            entity.Property(x => x.Notes).HasMaxLength(500);
            entity.HasIndex(x => x.TeacherNumber).IsUnique();
            entity.HasIndex(x => new { x.CollegeId, x.Status });
            entity.HasOne(x => x.College)
                .WithMany()
                .HasForeignKey(x => x.CollegeId)
                .OnDelete(DeleteBehavior.Restrict);
            entity.HasOne<ApplicationUser>()
                .WithMany()
                .HasForeignKey(x => x.UserId)
                .OnDelete(DeleteBehavior.SetNull);
        });

        builder.Entity<Student>(entity =>
        {
            entity.Property(x => x.StudentNumber).HasMaxLength(30);
            entity.Property(x => x.Name).HasMaxLength(50);
            entity.Property(x => x.Phone).HasMaxLength(30);
            entity.Property(x => x.Email).HasMaxLength(100);
            entity.Property(x => x.Notes).HasMaxLength(500);
            entity.HasIndex(x => x.StudentNumber).IsUnique();
            entity.HasIndex(x => new { x.AdministrativeClassId, x.Status });
            entity.HasIndex(x => x.EnrollmentYear);
            entity.HasOne(x => x.AdministrativeClass)
                .WithMany(x => x.Students)
                .HasForeignKey(x => x.AdministrativeClassId)
                .OnDelete(DeleteBehavior.Restrict);
            entity.HasOne<ApplicationUser>()
                .WithMany()
                .HasForeignKey(x => x.UserId)
                .OnDelete(DeleteBehavior.SetNull);
        });

        builder.Entity<Course>(entity =>
        {
            entity.Property(x => x.EnglishName).HasMaxLength(150);
            entity.Property(x => x.Credits).HasPrecision(5, 2);
            entity.Property(x => x.Description).HasMaxLength(1000);
            entity.HasIndex(x => new { x.CollegeId, x.Nature });
            entity.HasOne(x => x.College)
                .WithMany()
                .HasForeignKey(x => x.CollegeId)
                .OnDelete(DeleteBehavior.Restrict);
        });

        builder.Entity<CurriculumPlan>(entity =>
        {
            entity.Property(x => x.Name).HasMaxLength(120);
            entity.Property(x => x.Version).HasMaxLength(30);
            entity.Property(x => x.TotalCredits).HasPrecision(6, 2);
            entity.Property(x => x.Description).HasMaxLength(1000);
            entity.HasIndex(x => new { x.MajorId, x.EffectiveGrade, x.Version }).IsUnique();
            entity.HasIndex(x => new { x.Status, x.EffectiveGrade });
            entity.HasOne(x => x.Major)
                .WithMany()
                .HasForeignKey(x => x.MajorId)
                .OnDelete(DeleteBehavior.Restrict);
        });

        builder.Entity<CurriculumModule>(entity =>
        {
            entity.Property(x => x.Code).HasMaxLength(30);
            entity.Property(x => x.Name).HasMaxLength(100);
            entity.Property(x => x.RequiredCredits).HasPrecision(6, 2);
            entity.HasIndex(x => new { x.CurriculumPlanId, x.Code }).IsUnique();
            entity.HasOne(x => x.CurriculumPlan)
                .WithMany(x => x.Modules)
                .HasForeignKey(x => x.CurriculumPlanId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        builder.Entity<CurriculumCourse>(entity =>
        {
            entity.Property(x => x.Notes).HasMaxLength(500);
            entity.HasIndex(x => new { x.CurriculumModuleId, x.CourseId }).IsUnique();
            entity.HasOne(x => x.CurriculumModule)
                .WithMany(x => x.Courses)
                .HasForeignKey(x => x.CurriculumModuleId)
                .OnDelete(DeleteBehavior.Cascade);
            entity.HasOne(x => x.Course)
                .WithMany()
                .HasForeignKey(x => x.CourseId)
                .OnDelete(DeleteBehavior.Restrict);
        });

        builder.Entity<TeachingTask>(entity =>
        {
            entity.Property(x => x.TaskNumber).HasMaxLength(40);
            entity.Property(x => x.Name).HasMaxLength(120);
            entity.Property(x => x.Notes).HasMaxLength(500);
            entity.HasIndex(x => x.TaskNumber).IsUnique();
            entity.HasIndex(x => new { x.AcademicTermId, x.Status });
            entity.HasOne(x => x.AcademicTerm)
                .WithMany()
                .HasForeignKey(x => x.AcademicTermId)
                .OnDelete(DeleteBehavior.Restrict);
            entity.HasOne(x => x.Course)
                .WithMany()
                .HasForeignKey(x => x.CourseId)
                .OnDelete(DeleteBehavior.Restrict);
        });

        builder.Entity<TeachingTaskTeacher>(entity =>
        {
            entity.HasKey(x => new { x.TeachingTaskId, x.TeacherId });
            entity.HasOne(x => x.TeachingTask)
                .WithMany(x => x.Teachers)
                .HasForeignKey(x => x.TeachingTaskId)
                .OnDelete(DeleteBehavior.Cascade);
            entity.HasOne(x => x.Teacher)
                .WithMany()
                .HasForeignKey(x => x.TeacherId)
                .OnDelete(DeleteBehavior.Restrict);
        });

        builder.Entity<TeachingTaskClass>(entity =>
        {
            entity.HasKey(x => new { x.TeachingTaskId, x.AdministrativeClassId });
            entity.HasOne(x => x.TeachingTask)
                .WithMany(x => x.Classes)
                .HasForeignKey(x => x.TeachingTaskId)
                .OnDelete(DeleteBehavior.Cascade);
            entity.HasOne(x => x.AdministrativeClass)
                .WithMany()
                .HasForeignKey(x => x.AdministrativeClassId)
                .OnDelete(DeleteBehavior.Restrict);
        });

        builder.Entity<AuditLog>(entity =>
        {
            entity.Property(x => x.Method).HasMaxLength(10);
            entity.Property(x => x.Path).HasMaxLength(300);
            entity.Property(x => x.UserName).HasMaxLength(100);
            entity.Property(x => x.IpAddress).HasMaxLength(64);
            entity.HasIndex(x => x.CreatedAt);
        });
    }

    public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
    {
        foreach (var entry in ChangeTracker.Entries<EntityBase>()
                     .Where(x => x.State == EntityState.Modified))
        {
            entry.Entity.UpdatedAt = DateTime.UtcNow;
        }

        return base.SaveChangesAsync(cancellationToken);
    }

    private static void ConfigureCatalog<TEntity>(ModelBuilder builder)
        where TEntity : CatalogEntity
    {
        builder.Entity<TEntity>(entity =>
        {
            entity.Property(x => x.Code).HasMaxLength(40);
            entity.Property(x => x.Name).HasMaxLength(100);
            entity.HasIndex(x => x.Code).IsUnique();
            entity.HasIndex(x => new { x.IsEnabled, x.SortOrder });
        });
    }
}