using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Debug;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using WMS.Web.Domain.Entitys;
using WMS.Web.Repositories.Configuration.Log;

namespace WMS.Web.Repositories.Configuration
{
    /// <summary>
    /// db上下文
    /// </summary>
    public class RepositoryDbContext : DbContext
    {
        [Obsolete]
        public readonly LoggerFactory LoggerFactory = new LoggerFactory(new[] { new DebugLoggerProvider() });
        public RepositoryDbContext(DbContextOptions<RepositoryDbContext> options) : base(options)
        {
        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            LoggerFactory.AddProvider(new EFCoreLoggerProvider());
            base.OnConfiguring(optionsBuilder);
            optionsBuilder.UseLoggerFactory(LoggerFactory).EnableSensitiveDataLogging();
        }

        protected override void OnModelCreating(ModelBuilder builder)
        {

            //改箱
            builder.Entity<ChangeBoxRecord>(ent =>
            {
                ent.ToTable("t_wms_changebox_record");
                ent.HasKey(x => x.Id);

                ent.Property(f => f.SerialNumbers).HasConversion(
         v => JsonConvert.SerializeObject(v),
         v => JsonConvert.DeserializeObject<List<string>>(v));
            });
            //移箱
            builder.Entity<MoveBoxRecord>(ent =>
            {
                ent.ToTable("t_wms_movebox_record");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.Details)
                .WithOne()
                .HasForeignKey(p => p.Fid)
                .OnDelete(DeleteBehavior.Cascade);
            });
            //移箱明细
            builder.Entity<MoveBoxRecordDetails>(ent =>
            {
                ent.ToTable("t_wms_movebox_record_details");
                ent.HasKey(x => x.Id);

                ent.Property(f => f.SerialNumbers).HasConversion(
       v => JsonConvert.SerializeObject(v),
       v => JsonConvert.DeserializeObject<List<string>>(v));
            });

            #region 序列号
            //序列号
            builder.Entity<SerialNumbers>(ent =>
            {
                ent.ToTable("t_wms_serialnumbers");
                ent.HasKey(x => x.Id);
            });
            //序列号
            builder.Entity<SerialNumbers_Ops>(ent =>
            {
                ent.ToTable("t_wms_serialnumbers_ops");
                ent.HasKey(x => x.Id);
            });
            //序列号操作记录
            builder.Entity<SerialNumberOperate>(ent =>
            {
                ent.ToTable("t_wms_serialnumberoperate");
                ent.HasKey(x => x.Id);
            });
            #endregion

            //定时任务时间记录表
            builder.Entity<ErpOpsSyncDate>(ent =>
            {
                ent.ToTable("t_wms_sync_date");
                ent.HasKey(x => x.Id);
            });
            builder.Entity<FileDownManager>(ent =>
            {
                ent.ToTable("t_wms_file_down_manager");
                ent.HasKey(x => x.Id);
            });


            #region 出库单
            builder.Entity<OutStock>(ent =>
            {
                ent.ToTable("t_wms_outstock");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.Details)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<OutStockDetails>(ent =>
            {
                ent.ToTable("t_wms_outstock_details");
                ent.HasKey(x => x.Id);

                ent.Property(f => f.SerialNumbers).HasConversion(
         v => JsonConvert.SerializeObject(v),
         v => JsonConvert.DeserializeObject<List<string>>(v));

                ent.HasMany(p => p.ErpDetails)
                 .WithOne()
                 .HasForeignKey(p => p.DetailId)
                 .OnDelete(DeleteBehavior.Cascade);

                ent.HasMany(p => p.BoxsDetails)
                 .WithOne()
                 .HasForeignKey(p => p.DetailId)
                 .OnDelete(DeleteBehavior.Cascade);
            });

            builder.Entity<OutStockErpDetails>(ent =>
            {
                ent.ToTable("t_wms_outstock_erp_details");
                ent.HasKey(x => x.Id);
            });

            builder.Entity<OutStockBoxsDetails>(ent =>
            {
                ent.ToTable("t_wms_outstock_boxs_details");
                ent.HasKey(x => x.Id);

                ent.Property(f => f.SerialNumbers).HasConversion(
         v => JsonConvert.SerializeObject(v),
         v => JsonConvert.DeserializeObject<List<string>>(v));
            });
            #endregion

            #region 出库任务单
            builder.Entity<OutStockTask>(ent =>
            {
                ent.ToTable("t_erp_outstock_task");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.Details)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<OutStockTaskDetails>(ent =>
            {
                ent.ToTable("t_erp_outstock_task_details");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.ErpDetails)
                 .WithOne()
                 .HasForeignKey(p => p.DetailId)
                 .OnDelete(DeleteBehavior.Cascade);
            });

            builder.Entity<OutStockTaskErpDetails>(ent =>
            {
                ent.ToTable("t_erp_outstock_task_erp_details");
                ent.HasKey(x => x.Id);
            });

            #endregion

            #region 盘点单
            builder.Entity<TakeStock>(ent =>
            {
                ent.ToTable("t_wms_takestock");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.Details)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<TakeStockDetails>(ent =>
            {
                ent.ToTable("t_wms_takestock_details");
                ent.HasKey(x => x.Id);

                ent.Property(f => f.SerialNumbers).HasConversion(
         v => JsonConvert.SerializeObject(v),
         v => JsonConvert.DeserializeObject<List<string>>(v));
            });
            #endregion

            #region 入库单
            builder.Entity<InStock>(ent =>
            {
                ent.ToTable("t_wms_instock");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.Details)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);

                ent.HasMany(p => p.ErpDetails)
                .WithOne()
                .HasForeignKey(p => p.Fid)
                .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<InStockDetails>(ent =>
            {
                ent.ToTable("t_wms_instock_details");
                ent.HasKey(x => x.Id);
                ent.Property(f => f.SerialNumbers).HasConversion(
                    v => JsonConvert.SerializeObject(v),
                    v => JsonConvert.DeserializeObject<List<string>>(v),
                    new ValueComparer<List<string>>(
                        (c1, c2) => c1.SequenceEqual(c2),
                        c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
                        c => (List<string>)c.ToList()));

                ent.Property(f => f.TwoSerialNumbers).HasConversion(
                  v => JsonConvert.SerializeObject(v),
                  v => JsonConvert.DeserializeObject<List<string>>(v),
                  new ValueComparer<List<string>>(
                      (c1, c2) => c1.SequenceEqual(c2),
                      c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
                      c => (List<string>)c.ToList()));

            });
            builder.Entity<InStockErpDetails>(ent =>
            {
                ent.ToTable("t_wms_instock_erp_details");
                ent.HasKey(x => x.Id);
            });
            builder.Entity<InStockTotalDetails>(ent =>
            {
                ent.ToTable("t_wms_instock_total_details");
                ent.HasKey(x => x.Id);
                ent.Property(f => f.SerialNumbers).HasConversion(
                    v => JsonConvert.SerializeObject(v),
                    v => JsonConvert.DeserializeObject<List<string>>(v),
                    new ValueComparer<List<string>>(
                        (c1, c2) => c1.SequenceEqual(c2),
                        c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
                        c => (List<string>)c.ToList()));
            });
            # endregion

            #region 入库任务单
            builder.Entity<InStockTask>(ent =>
            {
                ent.ToTable("t_erp_instock_task");
                ent.HasKey(x => x.Id);
                ent.HasMany(p => p.Details)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<InStockTaskDetails>(ent =>
            {
                ent.ToTable("t_erp_instock_task_details");
                ent.HasKey(x => x.Id);
            });
            builder.Entity<InStockTaskBox>(ent =>
            {
                ent.ToTable("t_erp_instock_task_box");
                ent.HasKey(x => x.Id);
                ent.HasMany(p => p.Details)
                .WithOne()
                .HasForeignKey(p => p.Fid)
                .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<InStockTaskBoxDetails>(ent =>
            {
                ent.ToTable("t_erp_instock_task_box_details");
                ent.HasKey(x => x.Id);
                ent.Property(f => f.SerialNumbers).HasConversion(
                    v => JsonConvert.SerializeObject(v),
                    v => JsonConvert.DeserializeObject<List<string>>(v),
                    new ValueComparer<List<string>>(
                        (c1, c2) => c1.SequenceEqual(c2),
                        c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
                        c => (List<string>)c.ToList()));
            });
            #endregion

            #region 出入库回退记录
            builder.Entity<BackRecord>(ent =>
            {
                ent.ToTable("t_wms_back_record");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.Details)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<BackRecordDetails>(ent =>
            {
                ent.ToTable("t_wms_back_record_details");
                ent.HasKey(x => x.Id);
                ent.Property(f => f.SerialNumbers).HasConversion(
                    v => JsonConvert.SerializeObject(v),
                    v => JsonConvert.DeserializeObject<List<string>>(v),
                    new ValueComparer<List<string>>(
                        (c1, c2) => c1.SequenceEqual(c2),
                        c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
                        c => (List<string>)c.ToList()));
            });
            #endregion

            #region 箱库存
            builder.Entity<BoxInventory>(ent =>
            {
                ent.ToTable("t_wms_box_inventory");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.Details)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<BoxInventoryDetails>(ent =>
            {
                ent.ToTable("t_wms_box_inventory_details");
                ent.HasKey(x => x.Id);
                ent.Property(f => f.SerialNumbers).HasConversion(
                    v => JsonConvert.SerializeObject(v),
                    v => JsonConvert.DeserializeObject<List<string>>(v),
                    new ValueComparer<List<string>>(
                        (c1, c2) => c1.SequenceEqual(c2),
                        c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
                        c => (List<string>)c.ToList()));
            });
            # endregion

            #region 即时库存相关
            builder.Entity<InventoryDetails>(ent =>
            {
                ent.ToTable("t_wms_inventory_details");
                ent.HasKey(x => x.Id);
            });
            builder.Entity<InventoryInOutDetails>(ent =>
            {
                ent.ToTable("t_wms_inventory_inout_details");
                ent.HasKey(x => x.Id);
            });
            #endregion

            #region 箱信息
            builder.Entity<Box>(ent =>
            {
                ent.ToTable("t_ops_box");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.Details)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);
            });
            builder.Entity<BoxDetails>(ent =>
            {
                ent.ToTable("t_ops_box_details");
                ent.HasKey(x => x.Id);
            });
            #endregion

            //箱唛表
            builder.Entity<BoxMark>(ent =>
            {
                ent.ToTable("t_wms_box_mark");
                ent.HasKey(x => x.Id);

                ent.HasMany(p => p.BillNos)
                 .WithOne()
                 .HasForeignKey(p => p.Fid)
                 .OnDelete(DeleteBehavior.Cascade);
            });

            //箱唛表-编号表
            builder.Entity<BoxMarkBillNo>(ent =>
            {
                ent.ToTable("t_wms_box_mark_billno");
                ent.HasKey(x => x.Id);
            });
            //物料
            builder.Entity<Materials>(ent =>
            {
                ent.ToTable("t_wms_materials");
                ent.HasKey(x => x.Id);
            });
            //订阅通知
            builder.Entity<SubscribeNotification>(ent =>
            {
                ent.ToTable("t_wms_subscribe_notification");
                ent.HasKey(x => x.Id);

                var valueComparer = new ValueComparer<List<string>>(
    (c1, c2) => c1.SequenceEqual(c2),
    c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
    c => c.ToList());

                ent.Property(f => f.Telephones).HasConversion(
         v => JsonConvert.SerializeObject(v),
         v => JsonConvert.DeserializeObject<List<string>>(v))
                .Metadata
                .SetValueComparer(valueComparer);

                ent.Property(f => f.Emails).HasConversion(
        v => JsonConvert.SerializeObject(v),
        v => JsonConvert.DeserializeObject<List<string>>(v))
                .Metadata
                .SetValueComparer(valueComparer); ;
            });

            //成品即时库存
            builder.Entity<ProductInventory>(ent =>
            {
                ent.ToTable("t_wms_product_inventory");
                ent.HasKey(x => x.Id);
            });

            base.OnModelCreating(builder);
        }
        public DbSet<ProductInventory> ProductInventory { get; set; }
        public DbSet<Materials> Materials { get; set; }
        public DbSet<BoxMarkBillNo> BoxMarkBillNo { get; set; }
        public DbSet<BoxMark> BoxMark { get; set; }
        public DbSet<FileDownManager> FileDownManager { get; set; }
        public DbSet<SerialNumbers> SerialNumbers { get; set; }
        public DbSet<SerialNumbers_Ops> SerialNumbers_Ops { get; set; }
        public DbSet<ErpOpsSyncDate> ErpOpsSyncDate { get; set; }
        public DbSet<SerialNumberOperate> SerialNumberOperate { get; set; }
        public DbSet<ChangeBoxRecord> ChangeBoxRecord { get; set; }
        public DbSet<MoveBoxRecord> MoveBoxRecord { get; set; }
        public DbSet<OutStock> OutStock { get; set; }
        public DbSet<OutStockTask> OutStockTask { get; set; }
        public DbSet<TakeStock> TakeStock { get; set; }
        public DbSet<OutStockDetails> OutStockDetails { get; set; }
        public DbSet<OutStockErpDetails> OutStockErpDetails { get; set; }
        public DbSet<OutStockTaskDetails> OutStockTaskDetails { get; set; }
        public DbSet<OutStockTaskErpDetails> OutStockTaskErpDetails { get; set; }
        public DbSet<TakeStockDetails> TakeStockDetails { get; set; }
        public DbSet<InStock> Instock { get; set; }
        public DbSet<InStockDetails> InStockDetails { get; set; }
        public DbSet<InStockTotalDetails> InStockTotalDetails { get; set; }

        public DbSet<InStockTask> InStockTask { get; set; }

        public DbSet<InStockErpDetails> InStockErpDetails { get; set; }

        public DbSet<InStockTaskBox> InstockTaskBox { get; set; }
        public DbSet<InStockTaskBoxDetails> InStockTaskBoxDetails { get; set; }
        public DbSet<InStockTaskDetails> InStockTaskDetails { get; set; }
        public DbSet<BackRecord> BackRecord { get; set; }
        public DbSet<BackRecordDetails> BackRecordDetails { get; set; }
        public DbSet<BoxInventory> BoxInventory { get; set; }
        public DbSet<BoxInventoryDetails> BoxInventoryDetails { get; set; }
        public DbSet<InventoryDetails> InventoryDetails { get; set; }
        public DbSet<InventoryInOutDetails> InventoryInOutDetails { get; set; }

        public DbSet<Box> Box { get; set; }
        public DbSet<BoxDetails> BoxDetails { get; set; }
        public DbSet<SubscribeNotification> SubscribeNotification { get; set; }
    }
}