using Microsoft.EntityFrameworkCore;
using foundation_system.Models;

namespace foundation_system.Data;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<Persona> Personas { get; set; }
    public DbSet<Usuario> Usuarios { get; set; }
    public DbSet<RolSistema> RolesSistema { get; set; }
    public DbSet<RolUsuario> RolesUsuario { get; set; }
    public DbSet<Permiso> Permisos { get; set; }
    public DbSet<Modulo> Modulos { get; set; }
    public DbSet<RolPermiso> RolesPermisos { get; set; }
    public DbSet<Colaborador> Colaboradores { get; set; }
    public DbSet<CargoColaborador> CargosColaboradores { get; set; }
    
    // Caja Chica
    public DbSet<CajaChica> CajasChicas { get; set; }
    public DbSet<CajaChicaMovimiento> CajaChicaMovimientos { get; set; }
    public DbSet<CategoriaGasto> CategoriasGastos { get; set; }
    public DbSet<Proveedor> Proveedores { get; set; }
    public DbSet<DocumentoSoporte> DocumentosSoporte { get; set; }
    public DbSet<AsistenciaColaborador> AsistenciasColaboradores { get; set; }
    public DbSet<Nino> Ninos { get; set; }
    public DbSet<Asistencia> Asistencias { get; set; }
    public DbSet<ConfiguracionSistema> Configuraciones { get; set; }
    public DbSet<EncargadoNino> EncargadosNino { get; set; }
    public DbSet<AntecedenteNino> AntecedentesNino { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        // Configure composite key for RolUsuario
        modelBuilder.Entity<RolUsuario>()
            .HasKey(ru => new { ru.UsuarioId, ru.RolId });
        
        // Configure relationships
        modelBuilder.Entity<RolUsuario>()
            .HasOne(ru => ru.Usuario)
            .WithMany(u => u.RolesUsuario)
            .HasForeignKey(ru => ru.UsuarioId);
        
        modelBuilder.Entity<RolUsuario>()
            .HasOne(ru => ru.Rol)
            .WithMany(r => r.RolesUsuario)
            .HasForeignKey(ru => ru.RolId);

        // Configure composite key for RolPermiso
        modelBuilder.Entity<RolPermiso>()
            .HasKey(rp => new { rp.RolId, rp.PermisoId });

        modelBuilder.Entity<RolPermiso>()
            .HasOne(rp => rp.Rol)
            .WithMany(r => r.RolesPermisos)
            .HasForeignKey(rp => rp.RolId);

        modelBuilder.Entity<RolPermiso>()
            .HasOne(rp => rp.Permiso)
            .WithMany()
            .HasForeignKey(rp => rp.PermisoId);

        modelBuilder.Entity<Permiso>()
            .HasOne(p => p.Modulo)
            .WithMany(m => m.Permisos)
            .HasForeignKey(p => p.ModuloId);
        
        modelBuilder.Entity<Usuario>()
            .HasOne(u => u.Persona)
            .WithMany()
            .HasForeignKey(u => u.PersonaId);

        modelBuilder.Entity<Colaborador>()
            .HasOne(c => c.Cargo)
            .WithMany(cc => cc.Colaboradores)
            .HasForeignKey(c => c.CargoId);

        // Global configuration: Convert all dates to UTC when saving
        foreach (var entityType in modelBuilder.Model.GetEntityTypes())
        {
            var properties = entityType.GetProperties()
                .Where(p => p.ClrType == typeof(DateTime) || p.ClrType == typeof(DateTime?));

            foreach (var property in properties)
            {
                property.SetValueConverter(new Microsoft.EntityFrameworkCore.Storage.ValueConversion.ValueConverter<DateTime, DateTime>(
                    v => v.Kind == DateTimeKind.Utc ? v : DateTime.SpecifyKind(v, DateTimeKind.Utc),
                    v => v));
            }
        }
    }
}