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

namespace AmtScanner.Api.Data;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
    {
    }
    
    // 用户认证相关
    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; }
    
    // AMT设备相关（新表）
    public DbSet<AmtPendingDevice_new> AmtPendingDevices_new { get; set; }
    public DbSet<AmtDevice_new> AmtDevices_new { get; set; }
    
    // Agent 设备（新表）
    public DbSet<AgentDevice> AgentDevices_new { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        // 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);
        
        // AmtPendingDevice_new 配置
        modelBuilder.Entity<AmtPendingDevice_new>()
            .HasIndex(d => d.IpAddress)
            .IsUnique();
        
        // AmtDevice_new 配置
        modelBuilder.Entity<AmtDevice_new>()
            .HasKey(d => d.Uuid);
        
        modelBuilder.Entity<AmtDevice_new>()
            .HasIndex(d => d.IpAddress);
        
        // AgentDevice 配置
        modelBuilder.Entity<AgentDevice>()
            .HasKey(d => d.Uuid);
        
        modelBuilder.Entity<AgentDevice>()
            .HasIndex(d => d.IpAddress);
    }
}