using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FaKrosnoEfDataModel.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;

namespace FaKrosnoEfDataModel
{
    public class FaKrosnoDbContext : DbContext
    {
        public FaKrosnoDbContext(DbContextOptions<FaKrosnoDbContext> options) : base(options) { }

        public DbSet<Purchaser> Purchasers { get; set; }
        public DbSet<Recipient> Recipients { get; set; }
        public DbSet<ScheduleOrder> ScheduleOrders { get; set; }
        public DbSet<ScheduleOrderDetail> ScheduleOrderDetails { get; set; }
        public DbSet<ScheduleOrderDetailDetail> ScheduleOrderDetailDetails { get; set; }
        public DbSet<ScheduleOrderDetailDetailMisc> ScheduleOrderDetailDetailMiscs { get; set; }
        public DbSet<ScheduleOrderDetailMisc> ScheduleOrderDetailMiscs { get; set; }
        public DbSet<ScheduleOrderMisc> ScheduleOrderMiscs { get; set; }
        public DbSet<Product> Products { get; set; }
        
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            var configuration = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json")
                .Build();

            var connectionString = configuration.GetConnectionString("FaKrosnoConnection");
            optionsBuilder.UseSqlServer(connectionString, options => options.CommandTimeout(300));
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Purchaser>().ToTable("purchaser");

            modelBuilder.Entity<Recipient>().ToTable("recipient")
                .HasOne(p => p.Purchaser)
                .WithMany(p => p.Recipients)
                .HasForeignKey(p => p.PurchaserID);

            modelBuilder.Entity<ScheduleOrder>().ToTable("schedule_order")
                .HasOne(s => s.Recipient)
                .WithMany(r => r.ScheduleOrders)
                .HasForeignKey(s => s.RecipientID);

            modelBuilder.Entity<ScheduleOrderDetail>().ToTable("schedule_order_detail")
                .HasOne(s => s.ScheduleOrder)
                .WithMany(s => s.ScheduleOrderDetails)
                .HasForeignKey(s => s.ScheduleOrderID);

            modelBuilder.Entity<ScheduleOrderDetailDetail>().ToTable("schedule_order_detail_detail")
                .HasOne(s => s.ScheduleOrderDetail)
                .WithMany(s => s.ScheduleOrderDetailDetails)
                .HasForeignKey(s => s.ScheduleOrderDetailID);

            modelBuilder.Entity<ScheduleOrderDetailDetailMisc>().ToTable("schedule_order_detail_detail_misc")
                .HasOne(s => s.ScheduleOrderDetailDetail)
                .WithMany(s => s.ScheduleOrderDetailDetailMiscs)
                .HasForeignKey(s => s.ScheduleOrderDetailDetailID);

            modelBuilder.Entity<ScheduleOrderDetailMisc>().ToTable("schedule_order_detail_misc")
                .HasOne(s => s.ScheduleOrderDetail)
                .WithMany(s => s.ScheduleOrderDetailMiscs)
                .HasForeignKey(s => s.ScheduleOrderDetailID);

            modelBuilder.Entity<ScheduleOrderMisc>().ToTable("schedule_order_misc")
                .HasOne(s => s.ScheduleOrder)
                .WithMany(s => s.ScheduleOrderMiscs)
                .HasForeignKey(s => s.ScheduleOrderID);

            modelBuilder.Entity<ScheduleOrderDetail>(entity => entity.Property(x => x.Price).IsRequired(false));

            modelBuilder.Entity<ScheduleOrderDetailMisc>(entity => entity.Property(x => x.Label).IsRequired(false));

            modelBuilder.Entity<ScheduleOrderDetailDetailMisc>(entity => entity.Property(x => x.Label).IsRequired(false));

            modelBuilder.Entity<ScheduleOrderDetailDetail>(entity =>
            {
                entity.Property(x => x.SccDesc).IsRequired(false);
                entity.Property(x => x.QtyType).IsRequired(false);
                entity.Property(x => x.QtyDesc).IsRequired(false);
                entity.Property(x => x.ShipDate).IsRequired(false);
            });
            
            modelBuilder.Entity<Product>(entity =>
            {
                entity.ToTable("product");

                entity.HasKey(e => e.ID);

                entity.Property(e => e.ID)
                    .HasColumnName("ID")
                    .ValueGeneratedOnAdd();

                entity.Property(e => e.RecipientID)
                    .HasColumnName("recipientID")
                    .IsRequired();

                entity.Property(e => e.RecipientIdx)
                    .HasColumnName("recipientIdx")
                    .HasMaxLength(50)
                    .IsRequired();

                entity.Property(e => e.FaIdx)
                    .HasColumnName("faIdx")
                    .HasMaxLength(50)
                    .IsRequired();

                // Define the unique constraint for recipientID and recipientIdx
                entity.HasIndex(e => new { e.RecipientID, e.RecipientIdx })
                    .HasDatabaseName("IX_product")
                    .IsUnique();
            });
        }
    }
}