using EnertechWebAPI.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Hosting;

namespace EnertechWebAPI.Data
{
    public class DataContext : DbContext
    {
        public DataContext(DbContextOptions<DataContext> options) : base(options) { }

        public DbSet<EnertechUser> EnertechUsers => Set<EnertechUser>();
        public DbSet<Dashboard> Dashboard => Set<Dashboard>();
        public DbSet<Training> Training => Set<Training>();
        public DbSet<Education> Education => Set<Education>();
        public DbSet<EMobility> EMobility => Set<EMobility>();
        public DbSet<Appliances> Appliances => Set<Appliances>();
        public DbSet<Family> Family => Set<Family>();
        public DbSet<Community> Community => Set<Community>();
        public DbSet<House> House => Set<House>();
        public DbSet<Prices> Prices => Set<Prices>();
        public DbSet<Wallet> Wallet => Set<Wallet>();
        public DbSet<RefreshToken> RefreshTokens { get; set; }

        public DbSet<UserTraining> UserTraining => Set<UserTraining>();
        public DbSet<UserAppliance> UserAppliance => Set<UserAppliance>();
        public DbSet<UserEducation> UserEducation => Set<UserEducation>();
        public DbSet<UserEMobility> UserEMobility => Set<UserEMobility>();
        public DbSet<UserFamily> UserFamily => Set<UserFamily>();

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<EnertechUser>()
                .HasMany(p => p.Trainings)
                .WithMany(p => p.EnertechUsers)
                .UsingEntity<UserTraining>(
                    j => j
                        .HasOne(pt => pt.Training)
                        .WithMany(t => t.UserTrainings)
                        .HasForeignKey(pt => pt.TrainingId),
                    j => j
                        .HasOne(pt => pt.EnertechUser)
                        .WithMany(p => p.UserTrainings)
                        .HasForeignKey(pt => pt.userId),
                    j =>
                    {
                        j.Property(pt => pt.takeTraining).HasDefaultValueSql("CURRENT_TIMESTAMP");
                        j.HasKey(t => new { t.userId, t.TrainingId });
                    });

            modelBuilder.Entity<EnertechUser>()
                .HasMany(p => p.Appliances)
                .WithMany(p => p.EnertechUsers)
                .UsingEntity<UserAppliance>(
                    j => j
                        .HasOne(pt => pt.Appliance)
                        .WithMany(t => t.UserAppliances)
                        .HasForeignKey(pt => pt.ApplianceId),
                    j => j
                        .HasOne(pt => pt.EnertechUser)
                        .WithMany(p => p.UserAppliances)
                        .HasForeignKey(pt => pt.userId),
                    j =>
                    {
                        j.HasKey(t => new { t.userId, t.ApplianceId });
                    });

            modelBuilder.Entity<EnertechUser>()
                .HasMany(p => p.Educations)
                .WithMany(p => p.EnertechUsers)
                .UsingEntity<UserEducation>(
                    j => j
                        .HasOne(pt => pt.Education)
                        .WithMany(t => t.UserEducations)
                        .HasForeignKey(pt => pt.EducationId),
                    j => j
                        .HasOne(pt => pt.EnertechUser)
                        .WithMany(p => p.UserEducations)
                        .HasForeignKey(pt => pt.userId),
                    j =>
                    {
                        j.HasKey(t => new { t.userId, t.EducationId });
                    });

            modelBuilder.Entity<EnertechUser>()
                .HasMany(p => p.EMobilities)
                .WithMany(p => p.EnertechUsers)
                .UsingEntity<UserEMobility>(
                    j => j
                        .HasOne(pt => pt.EMobility)
                        .WithMany(t => t.UserEMobilites)
                        .HasForeignKey(pt => pt.EMobilityId),
                    j => j
                        .HasOne(pt => pt.EnertechUser)
                        .WithMany(p => p.UserEMobilites)
                        .HasForeignKey(pt => pt.userId),
                    j =>
                    {
                        j.HasKey(t => new { t.userId, t.EMobilityId });
                    });

            //modelBuilder.Entity<UserFamily>()
            //                    .HasMany(b => b.Families)
            //                    .WithOne(i => i.UserFamily)
            //                    .HasForeignKey("FamilyId");

            modelBuilder.Entity<RefreshToken>(entity =>
            {
                entity.Property(e => e.ExpiryDate).HasColumnType("smalldatetime");

                entity.Property(e => e.TokenHash)
                    .IsRequired()
                    .HasMaxLength(1000);

                entity.Property(e => e.TokenSalt)
                    .IsRequired()
                    .HasMaxLength(1000);

                entity.Property(e => e.Ts)
                    .HasColumnType("smalldatetime")
                    .HasColumnName("TS");

                entity.HasOne(d => d.EnertechUser)
                    .WithMany(p => p.RefreshTokens)
                    .HasForeignKey(d => d.userId)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_RefreshToken_User");

                entity.ToTable("RefreshToken");
            });

        }

    }
                    
}