using AmtScanner.Api.Models;
using Microsoft.EntityFrameworkCore;

namespace AmtScanner.Api.Data;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
    {
    }
    
    // AMT 相关
    public DbSet<AmtDevice> AmtDevices { get; set; }
    public DbSet<AmtCredential> AmtCredentials { get; set; }
    public DbSet<HardwareInfo> HardwareInfos { get; set; }
    public DbSet<MemoryModule> MemoryModules { get; set; }
    public DbSet<StorageDevice> StorageDevices { get; set; }
    public DbSet<WindowsCredential> WindowsCredentials { get; set; }
    public DbSet<RemoteAccessToken> RemoteAccessTokens { get; set; }
    
    // 用户认证相关
    public DbSet<User> Users { get; set; }
    public DbSet<Role> Roles { get; set; }
    public DbSet<UserRole> UserRoles { get; set; }
    public DbSet<Menu> Menus { get; set; }
    public DbSet<RoleMenu> RoleMenus { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        // 限制索引字段长度以适应 MySQL
        modelBuilder.Entity<AmtDevice>()
            .Property(d => d.IpAddress)
            .HasMaxLength(50);
        
        modelBuilder.Entity<AmtDevice>()
            .HasIndex(d => d.IpAddress)
            .IsUnique();
        
        modelBuilder.Entity<AmtCredential>()
            .Property(c => c.Name)
            .HasMaxLength(200);
        
        modelBuilder.Entity<AmtCredential>()
            .HasIndex(c => c.Name);
        
        // HardwareInfo 配置
        modelBuilder.Entity<HardwareInfo>()
            .HasOne(h => h.Device)
            .WithMany()
            .HasForeignKey(h => h.DeviceId)
            .OnDelete(DeleteBehavior.Cascade);
        
        modelBuilder.Entity<HardwareInfo>()
            .HasIndex(h => h.DeviceId);
        
        modelBuilder.Entity<HardwareInfo>()
            .HasIndex(h => h.LastUpdated);
        
        // MemoryModule 配置
        modelBuilder.Entity<MemoryModule>()
            .HasOne(m => m.HardwareInfo)
            .WithMany(h => h.MemoryModules)
            .HasForeignKey(m => m.HardwareInfoId)
            .OnDelete(DeleteBehavior.Cascade);
        
        // StorageDevice 配置
        modelBuilder.Entity<StorageDevice>()
            .HasOne(s => s.HardwareInfo)
            .WithMany(h => h.StorageDevices)
            .HasForeignKey(s => s.HardwareInfoId)
            .OnDelete(DeleteBehavior.Cascade);
        
        // WindowsCredential 配置
        modelBuilder.Entity<WindowsCredential>()
            .Property(w => w.Name)
            .HasMaxLength(200);
        
        modelBuilder.Entity<WindowsCredential>()
            .HasIndex(w => w.Name);
        
        // RemoteAccessToken 配置
        modelBuilder.Entity<RemoteAccessToken>()
            .Property(t => t.Token)
            .HasMaxLength(64);
        
        modelBuilder.Entity<RemoteAccessToken>()
            .HasIndex(t => t.Token)
            .IsUnique();
        
        modelBuilder.Entity<RemoteAccessToken>()
            .HasOne(t => t.Device)
            .WithMany()
            .HasForeignKey(t => t.DeviceId)
            .OnDelete(DeleteBehavior.Cascade);
        
        modelBuilder.Entity<RemoteAccessToken>()
            .HasOne(t => t.WindowsCredential)
            .WithMany()
            .HasForeignKey(t => t.WindowsCredentialId)
            .OnDelete(DeleteBehavior.SetNull);
        
        // User 配置
        modelBuilder.Entity<User>()
            .Property(u => u.UserName)
            .HasMaxLength(100);
        
        modelBuilder.Entity<User>()
            .HasIndex(u => u.UserName)
            .IsUnique();
        
        modelBuilder.Entity<User>()
            .HasQueryFilter(u => !u.IsDeleted); // 全局过滤已删除用户
        
        // Role 配置
        modelBuilder.Entity<Role>()
            .Property(r => r.RoleCode)
            .HasMaxLength(50);
        
        modelBuilder.Entity<Role>()
            .HasIndex(r => r.RoleCode)
            .IsUnique();
        
        // UserRole 配置（多对多）
        modelBuilder.Entity<UserRole>()
            .HasKey(ur => new { ur.UserId, ur.RoleId });
        
        modelBuilder.Entity<UserRole>()
            .HasOne(ur => ur.User)
            .WithMany(u => u.UserRoles)
            .HasForeignKey(ur => ur.UserId)
            .OnDelete(DeleteBehavior.Cascade);
        
        modelBuilder.Entity<UserRole>()
            .HasOne(ur => ur.Role)
            .WithMany(r => r.UserRoles)
            .HasForeignKey(ur => ur.RoleId)
            .OnDelete(DeleteBehavior.Cascade);
        
        // Menu 配置
        modelBuilder.Entity<Menu>()
            .Property(m => m.Name)
            .HasMaxLength(100);
        
        modelBuilder.Entity<Menu>()
            .HasIndex(m => m.Name);
        
        modelBuilder.Entity<Menu>()
            .HasOne(m => m.Parent)
            .WithMany(m => m.Children)
            .HasForeignKey(m => m.ParentId)
            .OnDelete(DeleteBehavior.Restrict);
        
        // RoleMenu 配置（多对多）
        modelBuilder.Entity<RoleMenu>()
            .HasKey(rm => new { rm.RoleId, rm.MenuId });
        
        modelBuilder.Entity<RoleMenu>()
            .HasOne(rm => rm.Role)
            .WithMany(r => r.RoleMenus)
            .HasForeignKey(rm => rm.RoleId)
            .OnDelete(DeleteBehavior.Cascade);
        
        modelBuilder.Entity<RoleMenu>()
            .HasOne(rm => rm.Menu)
            .WithMany(m => m.RoleMenus)
            .HasForeignKey(rm => rm.MenuId)
            .OnDelete(DeleteBehavior.Cascade);
    }
}