// iyixiGames.Infrastructure/Data/ApplicationDbContext.cs

using Microsoft.EntityFrameworkCore;
using iyixiGames.Domain.Entities; // 确保这里引用了你的实体所在的命名空间

namespace iyixiGames.Infrastructure.Data
{
    public class ApplicationDbContext : DbContext
    {
        // 构造函数，用于接收 DbContextOptions
        // 外部（如 Program.cs）会通过依赖注入提供这些选项，包括数据库连接字符串等
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }

        // 定义 DbSet 属性，对应数据库中的表
        public DbSet<User> Users { get; set; } = default!; // 明确指示这是可为空的，并默认初始化
        public DbSet<Role> Roles { get; set; } = default!;
        public DbSet<Permission> Permissions { get; set; } = default!;
        public DbSet<UserRole> UserRoles { get; set; } = default!;
        public DbSet<RolePermission> RolePermissions { get; set; } = default!;
        
        public DbSet<Site> Sites { get; set; } = null!;
        public DbSet<SiteTeamMember> SiteTeamMembers { get; set; } = null!;
        public DbSet<SiteSeo> SiteSeos { get; set; } = null!;
        public DbSet<SiteAnalytics> SiteAnalytics { get; set; } = null!;
        public DbSet<SiteSettings> SiteSettings { get; set; } = null!;
        
        // --- 新增：游戏管理 DbSet ---
        public DbSet<Game> Games { get; set; } = null!; // 添加 Game DbSet

        // 重写 OnModelCreating 方法，用于配置实体与数据库表的映射关系
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // 调用基类的 OnModelCreating，以确保处理好所有默认的约定
            base.OnModelCreating(modelBuilder);

            // 配置 User 实体
            modelBuilder.Entity<User>(entity =>
            {
                // 设置 Username 字段为唯一索引，并设为必填，最大长度为50
                entity.HasIndex(u => u.Username).IsUnique();
                entity.Property(u => u.Username).HasMaxLength(50).IsRequired();

                // 密码哈希和盐值必填，并设置最大长度
                entity.Property(u => u.PasswordHash).HasMaxLength(255).IsRequired();
                entity.Property(u => u.Salt).HasMaxLength(512).IsRequired();

                // Email 和 FullName 为可选，并设置最大长度
                entity.Property(u => u.Email).HasMaxLength(255);
                entity.Property(u => u.FullName).HasMaxLength(100);

                // IsActive 默认值为 true
                entity.Property(u => u.IsActive).HasDefaultValue(true);

                // CreatedAt 默认为 UTC 当前时间
                entity.Property(u => u.CreatedAt).HasDefaultValueSql("CURRENT_TIMESTAMP");
                // UpdatedAt 和 LastLoginAt 可以为空
                entity.Property(u => u.UpdatedAt).IsRequired(false);
                entity.Property(u => u.LastLoginAt).IsRequired(false);
                // 检查这里的 CURRENT_TIMESTAMP(6)
                entity.Property(u => u.CreatedAt)
                    .HasColumnType("datetime(6)")
                    .ValueGeneratedOnAdd()
                    .HasDefaultValueSql("CURRENT_TIMESTAMP(6)"); // <--- 确保有 (6)

                // 检查这里是否移除了 HasComputedColumnSql
                entity.Property(u => u.UpdatedAt)
                    .HasColumnType("datetime(6)")
                    .ValueGeneratedOnAddOrUpdate()
                    .IsRequired(false);
            });

            // 配置 Role 实体
            modelBuilder.Entity<Role>(entity =>
            {
                entity.HasKey(r => r.Id);
                entity.Property(r => r.Name).HasMaxLength(50).IsRequired();
                entity.Property(r => r.Description).HasMaxLength(255).IsRequired();
                entity.Property(r => r.IsActive).HasDefaultValue(true);

                // CreatedAt 的配置保持不变，这是正确的
                entity.Property(r => r.CreatedAt)
                    .HasColumnType("datetime(6)")
                    .ValueGeneratedOnAdd()
                    .HasDefaultValueSql("CURRENT_TIMESTAMP(6)"); // 新插入时设置默认值

                // **** 关键修改：针对 UpdatedAt，移除 HasComputedColumnSql ****
                // 我们只告诉 EF Core 这个值是由数据库在插入/更新时生成的
                // 具体由 MySQL 的 ON UPDATE CURRENT_TIMESTAMP 负责
                entity.Property(r => r.UpdatedAt)
                    .HasColumnType("datetime(6)") // 确保列类型一致
                    .ValueGeneratedOnAddOrUpdate() // 表示此属性的值由数据库生成（插入和更新时）
                    .IsRequired(false); // UpdatedAt 字段通常是可空的，因为在首次创建时可能没有更新
                // 注意：这里我们不再使用 HasComputedColumnSql，
                // 而是依赖 MySqlConnector 自动处理 ValueGeneratedOnAddOrUpdate()
                // 为 MySQL 数据库生成 ON UPDATE CURRENT_TIMESTAMP
            });

            // 配置 Permission 实体
            modelBuilder.Entity<Permission>(entity =>
            {
                // 设置 Name 字段为唯一索引，并设为必填，最大长度为100
                entity.HasIndex(p => p.Name).IsUnique();
                entity.Property(p => p.Name).HasMaxLength(100).IsRequired();

                // Description 为可选，并设置最大长度
                entity.Property(p => p.Description).HasMaxLength(255);
            });

            // 配置 UserRole (用户-角色联结表)
            modelBuilder.Entity<UserRole>(entity =>
            {
                // 定义复合主键
                entity.HasKey(ur => new { ur.UserId, ur.RoleId });

                // 配置外键
                entity.HasOne(ur => ur.User)
                    .WithMany(u => u.UserRoles)
                    .HasForeignKey(ur => ur.UserId)
                    .OnDelete(DeleteBehavior.Cascade); // 根据你的业务需求调整级联删除行为

                entity.HasOne(ur => ur.Role)
                    .WithMany(r => r.UserRoles)
                    .HasForeignKey(ur => ur.RoleId)
                    .OnDelete(DeleteBehavior.Cascade); // 根据你的业务需求调整级联删除行为

                // *** UserRole 实体 AssignedAt 的正确配置 ***
                entity.Property(ur => ur.AssignedAt)
                    .HasColumnType("datetime(6)") // 确保这与 MySQL 期望的精度匹配
                    .ValueGeneratedOnAdd()
                    .HasDefaultValueSql("CURRENT_TIMESTAMP(6)"); // 这会告诉 EF Core 使用这个 SQL 表达式
            });

            // 配置 RolePermission (角色-权限联结表)
            modelBuilder.Entity<RolePermission>(entity =>
            {
                // 定义复合主键
                entity.HasKey(rp => new { rp.RoleId, rp.PermissionId });

                // 配置外键
                entity.HasOne(rp => rp.Role)
                    .WithMany(r => r.RolePermissions)
                    .HasForeignKey(rp => rp.RoleId)
                    .OnDelete(DeleteBehavior.Cascade); // 根据你的业务需求调整级联删除行为

                entity.HasOne(rp => rp.Permission)
                    .WithMany(p => p.RolePermissions)
                    .HasForeignKey(rp => rp.PermissionId)
                    .OnDelete(DeleteBehavior.Cascade); // 根据你的业务需求调整级联删除行为

                // *** RolePermission 实体 AssignedAt 的正确配置 ***
                entity.Property(rp => rp.AssignedAt)
                    .HasColumnType("datetime(6)") // 确保这与 MySQL 期望的精度匹配
                    .ValueGeneratedOnAdd()
                    .HasDefaultValueSql("CURRENT_TIMESTAMP(6)"); // 这会告诉 EF Core 使用这个 SQL 表达式
            });

            // 配置 Site 实体
            modelBuilder.Entity<Site>(entity =>
            {
                entity.HasKey(s => s.Id); // Id 作为主键
                entity.Property(s => s.Id).ValueGeneratedOnAdd(); // ID 自动生成

                entity.Property(s => s.Name).IsRequired().HasMaxLength(100);
                entity.Property(s => s.Domain).IsRequired().HasMaxLength(255);
                entity.HasIndex(s => s.Domain).IsUnique(); // 确保域名唯一
                entity.Property(s => s.OwnerUserId).IsRequired().HasMaxLength(50);
                entity.Property(s => s.Status).IsRequired().HasMaxLength(50);
                entity.Property(s => s.CreatedAt).IsRequired();
                entity.Property(s => s.UpdatedAt).IsRequired();

                // 配置一对一关系
                entity.HasOne(s => s.Seo)
                      .WithOne(seo => seo.Site)
                      .HasForeignKey<SiteSeo>(seo => seo.SiteId)
                      .OnDelete(DeleteBehavior.Cascade); // 级联删除

                entity.HasOne(s => s.Analytics)
                      .WithOne(a => a.Site)
                      .HasForeignKey<SiteAnalytics>(a => a.SiteId)
                      .OnDelete(DeleteBehavior.Cascade);

                entity.HasOne(s => s.Settings)
                      .WithOne(s => s.Site)
                      .HasForeignKey<SiteSettings>(s => s.SiteId)
                      .OnDelete(DeleteBehavior.Cascade);

                // 配置一对多关系
                entity.HasMany(s => s.TeamMembers)
                      .WithOne(tm => tm.Site)
                      .HasForeignKey(tm => tm.SiteId)
                      .OnDelete(DeleteBehavior.Cascade);
            });

            // 配置 SiteTeamMember 实体
            modelBuilder.Entity<SiteTeamMember>(entity =>
            {
                entity.HasKey(tm => tm.Id); // 简单主键，也可以考虑复合主键 {SiteId, UserId}
                entity.Property(tm => tm.SiteId).IsRequired();
                entity.Property(tm => tm.UserId).IsRequired().HasMaxLength(50);
                entity.Property(tm => tm.Role).IsRequired().HasMaxLength(50);
                // 可以添加复合唯一索引来确保一个用户在一个网站中只有一个角色
                entity.HasIndex(tm => new { tm.SiteId, tm.UserId }).IsUnique();
            });

            // 配置子实体作为独立实体表
            modelBuilder.Entity<SiteSeo>(entity =>
            {
                entity.HasKey(seo => seo.SiteId); // SiteId 作为主键和外键
                entity.Property(seo => seo.Description).HasMaxLength(500);
                entity.Property(seo => seo.Keywords).HasMaxLength(255);
            });

            modelBuilder.Entity<SiteAnalytics>(entity =>
            {
                entity.HasKey(a => a.SiteId);
                entity.Property(a => a.PopularGames).HasMaxLength(500);
            });

            modelBuilder.Entity<SiteSettings>(entity =>
            {
                entity.HasKey(s => s.SiteId);
                entity.Property(s => s.Theme).HasMaxLength(50);
                entity.Property(s => s.Language).HasMaxLength(50);
            });
            
            // --- 新增：游戏实体配置 ---
            modelBuilder.Entity<Game>(entity =>
            {
                entity.HasKey(g => g.Id);
                entity.Property(g => g.Id).ValueGeneratedOnAdd();
                entity.Property(g => g.Name).IsRequired().HasMaxLength(100);
                entity.Property(g => g.Path).IsRequired().HasMaxLength(1024);
                // New: Configure Description property
                entity.Property(g => g.Description).HasMaxLength(1000); // Allow null by default

                entity.Property(g => g.Category).IsRequired().HasMaxLength(255);
                entity.Property(g => g.Popularity).IsRequired();
                entity.Property(g => g.AvgRating).IsRequired();
                entity.Property(g => g.ReleaseDate).IsRequired();
                entity.Property(g => g.CreatedAt).IsRequired();
                entity.Property(g => g.UpdatedAt).IsRequired();

                entity.HasIndex(g => g.Name).IsUnique();
            });
            // 你可以在这里添加其他实体的配置...
        }
    }
}