using Microsoft.EntityFrameworkCore;
using MotoresArgentinosV2.Core.Entities;

namespace MotoresArgentinosV2.Infrastructure.Data;

public class MotoresV2DbContext : DbContext
{
    public MotoresV2DbContext(DbContextOptions<MotoresV2DbContext> options)
        : base(options)
    {
    }

    public DbSet<User> Users { get; set; }
    public DbSet<Ad> Ads { get; set; }
    public DbSet<AdPhoto> AdPhotos { get; set; }
    public DbSet<AdFeature> AdFeatures { get; set; }
    public DbSet<Brand> Brands { get; set; }
    public DbSet<Model> Models { get; set; }
    public DbSet<TransactionRecord> Transactions { get; set; }
    public DbSet<Favorite> Favorites { get; set; }
    public DbSet<ChatMessage> ChatMessages { get; set; }
    public DbSet<AuditLog> AuditLogs { get; set; }
    public DbSet<PaymentMethod> PaymentMethods { get; set; }
    public DbSet<RefreshToken> RefreshTokens { get; set; }
    public DbSet<AdViewLog> AdViewLogs { get; set; }
    public DbSet<UserNotificationPreference> NotificationPreferences { get; set; }
    public DbSet<UnsubscribeToken> UnsubscribeTokens { get; set; }

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

        modelBuilder.Entity<PaymentMethod>().HasKey(p => p.PaymentMethodID);
        modelBuilder.Entity<ChatMessage>().HasKey(m => m.MessageID);
        modelBuilder.Entity<ChatMessage>().ToTable("ChatMessages");

        // Configuración de Cascada para Mensajes
        modelBuilder.Entity<ChatMessage>()
            .HasOne(m => m.Ad)
            .WithMany(a => a.Messages)
            .HasForeignKey(m => m.AdID)
            .OnDelete(DeleteBehavior.Cascade); // Esto asegura que EF intente borrar los mensajes

        // Configuración de Favorites (Clave compuesta)
        modelBuilder.Entity<Favorite>()
            .HasKey(f => new { f.UserID, f.AdID });

        // Nombres de tablas exactos
        modelBuilder.Entity<Favorite>().ToTable("Favorites");

        // Configuración de AdFeatures (Clave compuesta)
        modelBuilder.Entity<AdFeature>()
            .HasKey(af => new { af.AdID, af.FeatureKey });

        // Configuración de Identificadores (Claves Primarias)
        modelBuilder.Entity<AdPhoto>().HasKey(p => p.PhotoID);
        modelBuilder.Entity<Brand>().HasKey(b => b.BrandID);
        modelBuilder.Entity<Model>().HasKey(m => m.ModelID);
        modelBuilder.Entity<User>().HasKey(u => u.UserID);
        modelBuilder.Entity<Ad>().HasKey(a => a.AdID);
        modelBuilder.Entity<TransactionRecord>().HasKey(t => t.TransactionID);
        modelBuilder.Entity<Ad>().Property(a => a.Price).HasColumnType("decimal(18,2)");
        modelBuilder.Entity<TransactionRecord>().Property(t => t.Amount).HasColumnType("decimal(18,2)");

        // Nombres de tablas exactos para coincidir con el Roadmap
        modelBuilder.Entity<User>().ToTable("Users");
        modelBuilder.Entity<Ad>().ToTable("Ads");
        modelBuilder.Entity<AdPhoto>().ToTable("AdPhotos");
        modelBuilder.Entity<AdFeature>().ToTable("AdFeatures");
        modelBuilder.Entity<TransactionRecord>().ToTable("Transactions");

        modelBuilder.Entity<AdViewLog>().ToTable("AdViewLogs");
        modelBuilder.Entity<AdViewLog>().HasIndex(l => new { l.AdID, l.IPAddress, l.ViewDate });

        // Configuración de UserNotificationPreference
        modelBuilder.Entity<UserNotificationPreference>().ToTable("UserNotificationPreferences");
        modelBuilder.Entity<UserNotificationPreference>().HasKey(p => p.PreferenceID);
        // Índice único: un usuario no puede tener dos registros para la misma categoría
        modelBuilder.Entity<UserNotificationPreference>()
            .HasIndex(p => new { p.UserID, p.Category })
            .IsUnique();
        modelBuilder.Entity<UserNotificationPreference>()
            .HasOne(p => p.User)
            .WithMany()
            .HasForeignKey(p => p.UserID)
            .OnDelete(DeleteBehavior.Cascade);

        // Configuración de UnsubscribeToken
        modelBuilder.Entity<UnsubscribeToken>().ToTable("UnsubscribeTokens");
        modelBuilder.Entity<UnsubscribeToken>().HasKey(t => t.TokenID);
        // Índice para búsqueda rápida por valor del token
        modelBuilder.Entity<UnsubscribeToken>().HasIndex(t => t.Token).IsUnique();
        modelBuilder.Entity<UnsubscribeToken>()
            .HasOne(t => t.User)
            .WithMany()
            .HasForeignKey(t => t.UserID)
            .OnDelete(DeleteBehavior.Cascade);
    }
}