using Microsoft.EntityFrameworkCore;

namespace SQLInsight.Hub.Data;

public sealed class HubDbContext(DbContextOptions<HubDbContext> options) : DbContext(options)
{
    public DbSet<Customer> Customers => Set<Customer>();
    public DbSet<LicenseRecord> Licenses => Set<LicenseRecord>();
    public DbSet<Instance> Instances => Set<Instance>();
    public DbSet<Submission> Submissions => Set<Submission>();
    public DbSet<HubFinding> Findings => Set<HubFinding>();
    public DbSet<RuleState> RuleStates => Set<RuleState>();
    public DbSet<SupportCase> SupportCases => Set<SupportCase>();
    public DbSet<StaffUser> StaffUsers => Set<StaffUser>();
    public DbSet<InstanceVersionChange> VersionChanges => Set<InstanceVersionChange>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        ArgumentNullException.ThrowIfNull(modelBuilder);

        modelBuilder.Entity<Customer>(e =>
        {
            e.HasIndex(c => c.Name).IsUnique();
        });

        modelBuilder.Entity<LicenseRecord>(e =>
        {
            e.HasKey(l => l.LicenseId);
            e.HasOne(l => l.Customer).WithMany(c => c.Licenses).HasForeignKey(l => l.CustomerId);
        });

        modelBuilder.Entity<Instance>(e =>
        {
            e.HasIndex(i => new { i.CustomerId, i.InstanceKey }).IsUnique();
            e.HasOne(i => i.Customer).WithMany(c => c.Instances).HasForeignKey(i => i.CustomerId);
        });

        modelBuilder.Entity<Submission>(e =>
        {
            e.HasKey(s => s.SubmissionId);
            e.HasIndex(s => s.ReceivedAt);
        });

        modelBuilder.Entity<HubFinding>(e =>
        {
            e.HasOne(f => f.Instance).WithMany(i => i.Findings).HasForeignKey(f => f.InstanceId);
            e.Property(f => f.EvidenceJson).HasColumnType("jsonb");
            // One active occurrence per instance, rule and subject; history keeps resolved ones.
            e.HasIndex(f => new { f.InstanceId, f.RuleId, f.Subject }).IsUnique().HasFilter("resolved_at IS NULL");
            e.HasIndex(f => new { f.Severity, f.ResolvedAt });
            e.HasOne(f => f.SupportCase).WithMany(c => c.Findings).HasForeignKey(f => f.SupportCaseId).OnDelete(DeleteBehavior.SetNull);
        });

        modelBuilder.Entity<RuleState>(e =>
        {
            e.HasKey(r => new { r.InstanceId, r.RuleId });
        });

        modelBuilder.Entity<SupportCase>(e =>
        {
            e.HasOne(c => c.Customer).WithMany(c => c.SupportCases).HasForeignKey(c => c.CustomerId);
        });

        modelBuilder.Entity<InstanceVersionChange>(e =>
        {
            e.HasOne(v => v.Instance).WithMany().HasForeignKey(v => v.InstanceId);
            e.HasIndex(v => new { v.InstanceId, v.ChangedAt });
        });

        modelBuilder.Entity<StaffUser>(e =>
        {
            e.HasIndex(u => u.UserName).IsUnique();
        });
    }
}