using AutoMapper;
using Microsoft.EntityFrameworkCore.Storage;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WMS.Web.Core;
using WMS.Web.Core.Dto;
using WMS.Web.Core.Dto.Erp;
using WMS.Web.Core.Dto.Erp.OutStock;
using WMS.Web.Core.Dto.InStockTask;
using WMS.Web.Core.Dto.Login;
using WMS.Web.Core.Internal.Results;
using WMS.Web.Domain.Entitys;
using WMS.Web.Domain.Infrastructure;
using WMS.Web.Domain.IService;
using WMS.Web.Domain.IService.Public;
using WMS.Web.Domain.Services.Public;
using WMS.Web.Domain.Values;
using static StackExchange.Redis.Role;

namespace WMS.Web.Domain.Services
{
    /// <summary>
    /// 入库任务单-服务
    /// </summary>
    public class InStockTaskService : IInStockTaskService
    {
        private readonly IMapper _mapper;
        private ILogger<InStockTaskService> _logger;
        private readonly IErpService _erpService;
        private readonly ILoginService _loginService;
        private readonly IBasicsRepositories _basicsRepositories;
        private readonly IInStockRepositories _inStockRepositories;
        private readonly IInStockTaskRepositories _inStockTaskRepositories;
        private readonly RedisClientService _redisClientService;
        public InStockTaskService(IMapper mapper, IErpService erpService, ILoginService loginService,
             IBasicsRepositories basicsRepositories, ILogger<InStockTaskService> logger, RedisClientService redisClientService,
            IInStockRepositories inStockRepositories, IInStockTaskRepositories inStockTaskRepositories)
        {
            this._logger = logger;
            _mapper = mapper;
            _redisClientService = redisClientService;
            _erpService = erpService;
            _loginService = loginService;
            _basicsRepositories = basicsRepositories;
            _inStockRepositories = inStockRepositories;
            _inStockTaskRepositories = inStockTaskRepositories;
        }

        /// <summary>
        /// 来源单-金蝶校准-实时
        /// </summary>
        /// <param name="sourceBillNo"></param>
        /// <returns></returns>
        public async Task<Result> Adjust(string sourceBillNo)
        {
            //1.事务
            IDbContextTransaction _transaction = _basicsRepositories.GetTransaction();
            bool isRollback = false;
            bool isTransaction = false;

            //2.查看是否有入库任务单
            var task = await _inStockTaskRepositories.GetBySource(sourceBillNo);
            if (task == null)
                return Result.ReFailure(ResultCodes.OrderNoData);

            //3.有的话就同步一下金蝶的数据
            var billNos = new List<string>();
            billNos.Add(sourceBillNo);
            //3.1订单类型-进去金蝶交互更新
            if (task.Type == InstockType.Purchase)
            {
                var result = await this.SsynPurchaseInStock(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if(task.Type==InstockType.ProduceSotck)
            {
                var result = await this.SsynProduceSotck(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if (task.Type == InstockType.Miscellaneous)
            {
                var result = await this.SysnMiscellaneous(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if (task.Type == InstockType.Assembled)
            {
                var result = await this.SysnAssembledApp(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if (task.Type == InstockType.Stkdirecttransfers)
            {
                var result = await this.SysnTransferDirect(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if (task.Type == InstockType.StktransferInst)
            {
                var result = await this.SysnTransferin(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }

            //4.提交事务
            var isSuccess = _basicsRepositories.CommitTransaction(isRollback, _transaction);
            if (!isSuccess)
                return Result.ReFailure(ResultCodes.AdjustError);

            return Result.ReSuccess();
        }

        /// <summary>
        /// 同步：采购入库类型单据
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SsynPurchaseInStock(List<string> billNos = null, bool isTransaction = true, DateTime? beginTime = null)
        {
            //1.获取金蝶数据：采购订单数据
            var erp_result = await _erpService.BillQueryForPurchaseInStock(billNos, beginTime);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;

            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }


        /// <summary>
        /// 同步：生产入库单据
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SsynProduceSotck(List<string> billNos = null, bool isTransaction = true, DateTime? beginTime = null)
        {
            //1.获取金蝶数据：生产入库数据
            var erp_result = await _erpService.BillQueryForProduceSotckin(billNos, beginTime);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;

            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }


        /// <summary>
        /// 同步：其他入库单
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnMiscellaneous(List<string> billNos = null, bool isTransaction = true, DateTime? beginTime = null)
        {
            //1.获取金蝶数据：其他入库订单数据
            var erp_result = await _erpService.BillQueryForMiscellaneous(billNos, beginTime);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;

            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }

        /// <summary>
        /// 同步：直接调拨入库单
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnTransferDirect(List<string> billNos = null, bool isTransaction = true, DateTime? beginTime = null)
        {
            //1.获取金蝶数据：直接调拨入库订单数据
            var erp_result = await _erpService.BillQueryForTransferDirect(billNos, beginTime);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;

            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }

        /// <summary>
        /// 同步：分步式调入单
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnTransferin(List<string> billNos = null, bool isTransaction = true, DateTime? beginTime = null)
        {
            //1.获取金蝶数据：分步式入库订单数据
            var erp_result = await _erpService.BillQueryForTransferin(billNos, beginTime);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;
            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }

        /// <summary>
        /// 同步：组装拆卸单
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnAssembledApp(List<string> billNos = null, bool isTransaction = true, DateTime? beginTime = null)
        {
            var erp_list = new List<ErpInStockResultDto>();

            //1.获取金蝶数据：组装成品入库订单数据
            var erp_result_ass = await _erpService.BillQueryForAssembledApp_Assembly(billNos, beginTime);
            if (!erp_result_ass.IsSuccess)
                return Result.ReFailure(erp_result_ass.Message, erp_result_ass.Status);
            var erp_list_ass = erp_result_ass.Data;
            erp_list.AddRange(erp_list_ass);
            //1.1.获取金蝶数据：拆卸子件入库订单数据
            var erp_result_disass = await _erpService.BillQueryForAssembledApp_Disassembly(billNos, beginTime);
            if (!erp_result_disass.IsSuccess)
                return Result.ReFailure(erp_result_disass.Message, erp_result_disass.Status);
            var erp_list_disass = erp_result_disass.Data;
            erp_list.AddRange(erp_list_disass);

            return await this.SysnDataNew(erp_list, isTransaction);
        }

        /// <summary>
        /// 同步
        /// </summary>
        /// <param name="billNos"></param>
        /// <returns></returns>
        public async Task<Result> Sysn(List<string> billNos = null)
        {
            var info = _redisClientService.GetStringKey<bool>($"wms_instock_sync");
            if (info == true) return Result.ReFailure(ResultCodes.ErpSyns);
            _redisClientService.SetStringKey($"wms_instock_sync", true, TimeSpan.FromMinutes(5));
            //1.事务
            IDbContextTransaction _transaction = _basicsRepositories.GetTransaction();
            bool isRollback = false;
            bool isTransaction = false;

            //3.同步数据
            var result = await this.InStock(billNos, isTransaction);
            if (!result.IsSuccess) isRollback = true;

            //3.提交事务
            var isSuccess = _basicsRepositories.CommitTransaction(isRollback, _transaction);
            _redisClientService.SetStringKey($"wms_instock_sync", false, TimeSpan.FromMinutes(5));
            if (!isSuccess)
                return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }

        /// <summary>
        /// 同步：入库单类型的数据
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> InStock(List<string> billNos, bool isTransaction)
        {
            if (billNos == null || billNos.Count == 0)
            {
                var beginTime = DateTime.Now.AddHours(-20);//默认拉去8小时以内的数据，ALTER BY YZH
                // var beginTime = DateTime.Now.AddDays(-200);//默认拉去8小时以内的数据，ALTER BY YZH这里要改回去


                //6.同步数据:生产入库单
                var ProduceSotck_result = await this.SsynProduceSotck(null, isTransaction, beginTime);
                if (!ProduceSotck_result.IsSuccess)
                    return Result.ReFailure(ProduceSotck_result.Message, ProduceSotck_result.Status);



                //4.同步数据：分步式入库单
                var Transferin_result = await this.SysnTransferin(null, isTransaction, beginTime);
                if (!Transferin_result.IsSuccess)
                    return Result.ReFailure(Transferin_result.Message, Transferin_result.Status);


             

           



                //1.同步数据:采购订单
                var purchase_result = await this.SsynPurchaseInStock(null, isTransaction, beginTime);
                if (!purchase_result.IsSuccess)
                    return Result.ReFailure(purchase_result.Message, purchase_result.Status);

                //2.同步数据：其他入库单
                var miscellaneou_result = await this.SysnMiscellaneous(null, isTransaction, beginTime);
                if (!miscellaneou_result.IsSuccess)
                    return Result.ReFailure(miscellaneou_result.Message, miscellaneou_result.Status);

                //3.同步数据：直接调拨入库单
                var TransferDirect_result = await this.SysnTransferDirect(null, isTransaction, beginTime);
                if (!TransferDirect_result.IsSuccess)
                    return Result.ReFailure(TransferDirect_result.Message, TransferDirect_result.Status);


                //5.同步数据：组装拆卸单
                var AssembledApp_result = await this.SysnAssembledApp(null, isTransaction, beginTime);
                if (!AssembledApp_result.IsSuccess)
                    return Result.ReFailure(AssembledApp_result.Message, AssembledApp_result.Status);
            }
            else
            {
                List<string> Instock_sourceBillNos = new List<string>();
                List<string> Miscellaneous_sourceBillNos = new List<string>();
                List<string> TransferDirect_sourceBillNos = new List<string>();
                List<string> Transferin_sourceBillNos = new List<string>();
                List<string> AssembledApp_sourceBillNos = new List<string>();

                var taskList = await _inStockTaskRepositories.GetListBy(billNos);
                foreach (var entity in taskList)
                {
                    if (entity.Type == InstockType.Purchase)
                        Instock_sourceBillNos.Add(entity.SourceBillNo);
                    else if (entity.Type == InstockType.Stkdirecttransfers)
                        TransferDirect_sourceBillNos.Add(entity.SourceBillNo);
                    else if (entity.Type == InstockType.StktransferInst)
                        Transferin_sourceBillNos.Add(entity.SourceBillNo);
                    else if (entity.Type == InstockType.Assembled)
                        AssembledApp_sourceBillNos.Add(entity.SourceBillNo);
                    else if (entity.Type == InstockType.Miscellaneous)
                        Miscellaneous_sourceBillNos.Add(entity.SourceBillNo);
                }

                if (Instock_sourceBillNos.Count() > 0)
                {
                    //1.同步数据:采购订单
                    var purchase_result = await this.SsynPurchaseInStock(Instock_sourceBillNos, isTransaction);
                    if (!purchase_result.IsSuccess)
                        return Result.ReFailure(purchase_result.Message, purchase_result.Status);
                }
                if (Miscellaneous_sourceBillNos.Count() > 0)
                {
                    //2.同步数据：其他入库单
                    var miscellaneou_result = await this.SysnMiscellaneous(Miscellaneous_sourceBillNos, isTransaction);
                    if (!miscellaneou_result.IsSuccess)
                        return Result.ReFailure(miscellaneou_result.Message, miscellaneou_result.Status);
                }
                if (TransferDirect_sourceBillNos.Count() > 0)
                {
                    //3.同步数据：直接调拨入库单
                    var TransferDirect_result = await this.SysnTransferDirect(TransferDirect_sourceBillNos, isTransaction);
                    if (!TransferDirect_result.IsSuccess)
                        return Result.ReFailure(TransferDirect_result.Message, TransferDirect_result.Status);
                }
                if (Transferin_sourceBillNos.Count() > 0)
                {
                    //4.同步数据：分步式入库单
                    var Transferin_result = await this.SysnTransferin(Transferin_sourceBillNos, isTransaction);
                    if (!Transferin_result.IsSuccess)
                        return Result.ReFailure(Transferin_result.Message, Transferin_result.Status);
                }
                if (AssembledApp_sourceBillNos.Count() > 0)
                {
                    //5.同步数据：组装拆卸单
                    var AssembledApp_result = await this.SysnAssembledApp(AssembledApp_sourceBillNos, isTransaction);
                    if (!AssembledApp_result.IsSuccess)
                        return Result.ReFailure(AssembledApp_result.Message, AssembledApp_result.Status);
                }
            }
            return Result.ReSuccess();
        }

        /// <summary>
        /// ERP数据同步到WMS数据库-旧代码
        /// </summary>
        /// <param name="erp_list"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnData(List<ErpInStockResultDto> erp_list, bool isTransaction)
        {
            var type = (InstockType)erp_list.GroupBy(x => x.Type).Select(x => x.Key).FirstOrDefault();
            var totalCount = erp_list.Count;
            var totalUpdateCount = 0;
            var totalAddCount = 0;
            //1.通过单据编号找到wms系统现有的任务单；并修改
            var erp_remove_billNo = new List<string>();
            var SourceBillNo_list = erp_list.GroupBy(x => x.BillNo).Select(x => x.Key).ToList();
            var data_list = await _inStockTaskRepositories.GetListBy(SourceBillNo_list);
            if (data_list.Count != 0)
            {
                data_list.ForEach(x =>
                {
                    var erp_list_dets = erp_list.Where(t => t.BillNo == x.SourceBillNo).ToList();
                    if (erp_list_dets != null && erp_list_dets.Count != 0 && erp_list_dets.Count > x.Details.Count)
                    {
                        var xd_detids = x.Details.Select(xd => xd.ErpDetailId).ToList();
                        var task_no_materials = erp_list_dets.Where(ed => !xd_detids.Contains(ed.ErpDetailId)).ToList();
                        var Add_task_no_materials = _mapper.Map<List<InStockTaskDetails>>(task_no_materials);
                        x.Details.AddRange(Add_task_no_materials);
                    }
                });

                //2.1提取出wms任务单明细信息
                var data_list_details = data_list.SelectMany(x => x.Details).ToList();
                foreach (var item in data_list_details)
                {
                    var data = data_list.Where(x => x.Id == item.Fid).FirstOrDefault();
                    if (data == null)
                        continue;

                    //2.1.1对比erp的物料信息
                    var erp_data = erp_list.Where(x => x.ErpDetailId == item.ErpDetailId).FirstOrDefault();
                    if (erp_data != null)
                    {
                        //2.1.2修改数量
                        if (erp_data.Qty > item.AccruedQty && (erp_data.Qty > item.RealityQty && item.RealityQty != 0))
                            data.Status = InstockStatus.Part;
                        else if (erp_data.Qty <= item.AccruedQty && erp_data.Qty <= item.RealityQty)
                            data.Status = InstockStatus.Already;
                        item.Remark = erp_data.Remark;
                        item.AccruedQty = erp_data.Qty;
                        item.FactoryPrice = erp_data.FactoryPrice;
                        item.DeliveredQty = erp_data.DeliveredQty;
                        //打印日志：需要的修改条数
                        totalUpdateCount++;
                        erp_remove_billNo.Add(data.SourceBillNo);
                    }
                }

                //金蝶修改了物料：老物料，应收数量修改为0,
                var data_list_details_new = data_list.SelectMany(x => x.Details).ToList();
                data_list_details_new.ForEach(x =>
                {
                    //2.1.1对比erp的物料信息
                    var erp_data = erp_list.Where(t => t.ErpDetailId == x.ErpDetailId).FirstOrDefault();
                    if (erp_data != null)
                    {
                        if (erp_data.MaterialNumber != x.MaterialNumber)
                        {
                            //给老的物料应收数量改为0
                            x.AccruedQty = 0;
                        }
                    }
                    else if (erp_data == null)
                    {
                        x.AccruedQty = 0;
                    }
                });
                //新物料新增一条
                foreach (var item in erp_list)
                {
                    var local_data_order = data_list.Where(t => t.SourceBillNo == item.BillNo).FirstOrDefault();
                    if (local_data_order != null)
                    {
                        var local_data = data_list_details_new.Where(t => t.ErpDetailId == item.ErpDetailId).ToList();
                        if (local_data != null && local_data.Count != 0)
                        {
                            var isHaveMater_detail = local_data.Where(t => t.MaterialNumber == item.MaterialNumber).Any();
                            if (!isHaveMater_detail)
                            {
                                //明细的物料改变了：新的物料重新添加一条明细
                                var Add_task_no_materials = _mapper.Map<InStockTaskDetails>(item);
                                data_list.Where(x => x.SourceBillNo == item.BillNo).FirstOrDefault().Status = InstockStatus.Part;
                                data_list.Where(x => x.SourceBillNo == item.BillNo).FirstOrDefault()?.Details.Add(Add_task_no_materials);
                            }
                        }
                        else
                        {
                            //新增明细
                            var Add_task_det = _mapper.Map<InStockTaskDetails>(item);
                            data_list.Where(x => x.SourceBillNo == item.BillNo).FirstOrDefault().Status = InstockStatus.Part;
                            data_list.Where(x => x.SourceBillNo == item.BillNo).FirstOrDefault()?.Details.Add(Add_task_det);
                        }
                    }
                }

                //2.2.提交修改
                var isSuccess = await _inStockTaskRepositories.UpdateRange(data_list, isTransaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);


                //要剔除的来源单据编号：去重
                erp_remove_billNo = erp_remove_billNo.GroupBy(x => x).Select(x => x.Key).ToList();
                //2.3剔除:已修改的单据
                foreach (var item in erp_remove_billNo)
                {
                    erp_list.RemoveAll(x => x.BillNo == item);
                }

            }

            //打印日志
            //打印日志：需要的添加条数
            //totalAddCount = erp_list.Count;
            //this.LogInfomation( type,totalCount, totalUpdateCount, totalAddCount);

            //3.wms任务单的来源单据编号不存在于erp中，那么就新增
            if (erp_list.Count != 0)
            {
                var add_entitys = new List<InStockTask>();
                var current_billNos = erp_list.GroupBy(x => x.BillNo).Select(x => x.Key).ToList();

                foreach (var item in current_billNos)
                {
                    var current_order = erp_list.Where(x => x.BillNo == item).FirstOrDefault();
                    var dto = new InStockTask();
                    dto.Create((InstockType)current_order.Type, current_order.BillNo, current_order.CreateTime, current_order.SupplierId, current_order.OrgCode);

                    //找到当前对应来源单据编号的集合数据
                    var current_erp_details = erp_list.Where(x => x.BillNo == item).ToList();
                    //给到dto的实体明细中
                    dto.Details = _mapper.Map<List<InStockTaskDetails>>(current_erp_details);
                    add_entitys.Add(dto);
                }
                //3.1提交新增
                var isSuccess = await _inStockTaskRepositories.AddRange(add_entitys, isTransaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }

            return Result.ReSuccess();
        }

        /// <summary>
        /// ERP数据同步到WMS数据库-新代码
        /// </summary>
        /// <param name="erp_list"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnDataNew(List<ErpInStockResultDto> erp_list, bool isTransaction)
        {
            if (erp_list.Count() <= 0) return Result.ReSuccess();
            _logger.LogInformation($"获取到金蝶入库任务单数据:{JsonConvert.SerializeObject(erp_list)}");

            //1.通过单据编号找到wms系统现有的任务单；并修改
            var erp_removeList = new List<ErpInStockResultDto>();
            var SourceBillNo_list = erp_list.GroupBy(x => x.BillNo).Select(x => x.Key).ToList();
            var data_list = await _inStockTaskRepositories.GetListBy(SourceBillNo_list);

            //要新增的明细
            var erp_addDetailsList = new List<ErpInStockResultDto>();
            //2.遍历已有的任务单
            if (data_list.Count != 0)
            {

                //2.1遍历任务单明细：改变已有的值和要添加的明细
                foreach (var det in data_list.SelectMany(t => t.Details))
                {
                    var order = data_list.Where(o => o.Id == det.Fid).FirstOrDefault();
                    if (order != null)
                    {
                        var erp_data = erp_list.FirstOrDefault(a => a.ErpDetailId == det.ErpDetailId && a.BillNo == order.SourceBillNo);
                        if (erp_data != null)
                        {
                            //如果该明细作废 则不修改了
                            if (det.IsRepeal == true)
                            {
                                //操作完后剔除
                                erp_removeList.Add(erp_data);
                                continue;
                            }
                            if (erp_data.MaterialNumber == det.MaterialNumber)
                            {
                                //物料相同的，就改变数值
                                det.Remark = erp_data.Remark;
                                det.AccruedQty = erp_data.Qty;
                                det.FactoryPrice = erp_data.FactoryPrice;
                                det.DeliveredQty = erp_data.DeliveredQty;
                            }
                            else
                            {
                                //老物料，应收数量修改为0
                                det.AccruedQty = 0;
                                det.IsRepeal = true;
                            }
                            //操作完后剔除
                            erp_removeList.Add(erp_data);
                        }
                    }

                }

                //2.1.1当物料相同，仓库不同或者物料不同，就新增一条明细
                foreach (var erp_data in erp_list)
                {
                    var order = data_list.Where(x => x.SourceBillNo == erp_data.BillNo).FirstOrDefault();
                    if (order != null)
                    {
                        var IsHaveNewMaterial = order.Details.Where(x => x.ErpDetailId == erp_data.ErpDetailId && erp_data.MaterialNumber == x.MaterialNumber).Any();
                        if (!IsHaveNewMaterial)
                        {
                            //当物料相同，仓库不同或者物料不同，就新增一条明细
                            erp_addDetailsList.Add(erp_data);
                            //操作完后剔除
                            erp_removeList.Add(erp_data);
                        }
                    }


                }
                //去重
                var erp_addDetailsList_group = erp_addDetailsList.Distinct().ToList();

                //2.2遍历任务单：添加新的明细
                data_list.ForEach(order =>
                {
                    //2.1.任务单添加明细
                    var addErpDetails = erp_addDetailsList_group.Where(x => x.BillNo == order.SourceBillNo).ToList();
                    if (addErpDetails.Count != 0)
                    {
                        var addDetails = _mapper.Map<List<InStockTaskDetails>>(addErpDetails);
                        order.Details.AddRange(addDetails);
                    }
                });

                //2.4金蝶删除的明细，要把任务单里的明细应入库数量改为0
                data_list.SelectMany(x => x.Details).Where(c => !erp_list.Any(a => a.ErpDetailId == c.ErpDetailId))
                    .ToList()
                    .ForEach(x => { x.AccruedQty = 0; x.IsRepeal = true; });

                //2.3遍历任务单：改变任务单的状态
                data_list.ForEach(order =>
                {
                    //当应入库数量大于实际入库数量：状态就部分入库
                    //当应入库数量小于等于实际入库数量：状态就已入库
                    var details_Groups = order.Details.Where(x => x.AccruedQty != 0).GroupBy(x => x.MaterialNumber)
                    .Select(x => new
                    {
                        MaterialNumber = x.Key,
                        AccruedQtyTotal = x.Sum(t => t.AccruedQty),
                        ReceiveQtyTotal = x.Sum(t => t.ReceiveQty),
                        RealityQtyTotal = x.Sum(t => t.RealityQty)
                    }).ToList();

                    bool IsAny = details_Groups.Any(d => d.RealityQtyTotal != 0 && d.AccruedQtyTotal > d.RealityQtyTotal);
                    if (IsAny)
                        order.Status = InstockStatus.Part;
                    else if (details_Groups.Sum(x => x.ReceiveQtyTotal) <= 0 && order.Type == InstockType.Purchase)
                        order.Status = InstockStatus.Wait;
                    else if (details_Groups.Sum(x => x.RealityQtyTotal) <= 0)
                    {
                    //if (order.Type == InstockType.ProduceSotck)
                    //    {
                    //        order.Status = InstockStatus.Wait;
                    //    }
                    //    else
                    //    {
                            order.Status = InstockStatus.WaitInStock;
                        //}
                    }
                    else if (details_Groups.Sum(x => x.RealityQtyTotal) >= details_Groups.Sum(x => x.AccruedQtyTotal))
                        order.Status = InstockStatus.Already;

                    //明细都作废后 整个单据作废
                    if (order.Details.Count() == order.Details.Where(w => w.IsRepeal == true).Count())
                    {
                        order.Status = InstockStatus.Repeal;
                    }
                });

                //过滤掉已经作废的单据
                //data_list = data_list.Where(w => w.Status != InstockStatus.Repeal).ToList();
                //更新修改时间
                data_list.ForEach(f => f.WmsUpdateTime = DateTime.Now);
                //2.3.提交任务单的修改
                var isSuccess = await _inStockTaskRepositories.UpdateRange(data_list, isTransaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);

            }
            //2.4剔除:已修改的单据            
            foreach (var item in erp_removeList.Distinct().ToList())
                erp_list.Remove(item);

            _logger.LogInformation("拉取金蝶数据：SysnDataNew5->" + JsonConvert.SerializeObject(erp_list));

            //3.wms任务单的来源单据编号不存在于erp中，那么就新增
            if (erp_list.Count != 0)
            {
                var add_entitys = new List<InStockTask>();
                var current_billNos = erp_list.GroupBy(x => x.BillNo).Select(x => x.Key).ToList();

                foreach (var item in current_billNos)
                {
                    var current_order = erp_list.Where(x => x.BillNo == item).FirstOrDefault();
                    var dto = new InStockTask();
                    dto.Create((InstockType)current_order.Type, current_order.BillNo, current_order.CreateTime, current_order.SupplierId, current_order.OrgCode);

                    //找到当前对应来源单据编号的集合数据
                    var current_erp_details = erp_list.Where(x => x.BillNo == item).ToList();
                    //给到dto的实体明细中
                    dto.Details = _mapper.Map<List<InStockTaskDetails>>(current_erp_details);
                    add_entitys.Add(dto);
                }
                //3.1提交新增
                var isSuccess = await _inStockTaskRepositories.AddRange(add_entitys, isTransaction);
                _logger.LogInformation($"金蝶数据写入：SysnDataNew6->结果:{isSuccess}" + JsonConvert.SerializeObject(add_entitys));
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }

            return Result.ReSuccess();

        }


        /// <summary>
        /// 作废
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="loginInfo"></param>
        /// <returns></returns>
        public async Task<Result> Repeal(OperateRequest dto, LoginInDto loginInfo)
        {
            var list = await _inStockTaskRepositories.GetListByDetailIds(dto.Ids);
            foreach (var entity in list)
            {
                var det_ids = entity.Details.Select(s => s.Id).ToList();
                var change_ids = det_ids.Intersect(dto.Ids).ToList();
                //作废
                entity.Repeal(loginInfo.UserInfo.StaffId, change_ids);
            }
            var isSuccess = await _inStockTaskRepositories.UpdateRange(list, true);
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }

        /// <summary>
        /// 打印日志
        /// </summary>
        /// <param name="type"></param>
        /// <param name="totalCount"></param>
        /// <param name="updateCount"></param>
        /// <param name="addCount"></param>
        public void LogInfomation(InstockType type, int totalCount, int updateCount, int addCount)
        {
            _logger.LogInformation($"《{type.GetRemark()}总条数：" + totalCount + "，修改条数：" + updateCount + "，新增条数：" + addCount + "》");
        }
        /// <summary>
        /// 反作废
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="loginInfo"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<Result> NoRepeal(OperateRequest dto, LoginInDto loginInfo)
        {
            var list = await _inStockTaskRepositories.GetListByDetailIds(dto.Ids);
            foreach (var entity in list)
            {
                var det_ids = entity.Details.Select(s => s.Id).ToList();
                var change_ids = det_ids.Intersect(dto.Ids).ToList();
                //作废
                entity.NoRepeal(loginInfo.UserInfo.StaffId, change_ids);
            }
            var isSuccess = await _inStockTaskRepositories.UpdateRange(list, true);
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }
        /// <summary>
        /// 金蝶删单后wms单据作废
        /// </summary>
        /// <param name="begin"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<Result> ErpDel()
        {
            var list = await _inStockTaskRepositories.GetEntityListByStatus();
            var result = await GetData(list);
            if (!result.IsSuccess) return Result.ReFailure(result.Message, result.Status);
            var erp_list = result.Data;
            List<InStockTask> update_list = new List<InStockTask>();
            //处理数据 因为入库任务单和出库任务单结构不一样 没有合并的单据 所以处理不同
            foreach (var entity in list)
            {
                //判断是否在erp数据池里
                int count = erp_list.Where(w => w.BillNo.Equals(entity.SourceBillNo)).Count();
                if (count > 0) continue;
                //如果不在数据池里 被删除了 那么需要把订单作废
                entity.ErpDel();
                _logger.LogInformation($"入库任务单 金蝶未找到单据:{entity.SourceBillNo} wms订单号:{entity.BillNo} 作废来源单号:{entity.SourceBillNo}");
                if (update_list.FirstOrDefault(f => f.Id == entity.Id) == null)
                    update_list.Add(entity);

            }
            if (update_list.Count() <= 0) return Result.ReSuccess();

            var isSuccess = await _inStockTaskRepositories.UpdateRange(update_list, true);
            if (!isSuccess)
                return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }
        /// <summary>
        /// 获取金蝶数据
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public async Task<Result<List<ErpInStockResultDto>>> GetData(List<InStockTask> list)
        {
            List<ErpInStockResultDto> erp_list = new List<ErpInStockResultDto>();
            List<string> Instock_sourceBillNos = new List<string>();
            List<string> Miscellaneous_sourceBillNos = new List<string>();
            List<string> TransferDirect_sourceBillNos = new List<string>();
            List<string> Transferin_sourceBillNos = new List<string>();
            List<string> AssembledApp_sourceBillNos = new List<string>();
           // List<string> ProduceSotck_sourceBillNos = new List<string>();//生产入库

            foreach (var entity in list)
            {
                if (entity.Type == InstockType.Purchase)
                    Instock_sourceBillNos.Add(entity.SourceBillNo);
                else if (entity.Type == InstockType.Stkdirecttransfers)
                    TransferDirect_sourceBillNos.Add(entity.SourceBillNo);
                else if (entity.Type == InstockType.StktransferInst)
                    Transferin_sourceBillNos.Add(entity.SourceBillNo);
                else if (entity.Type == InstockType.Assembled)
                    AssembledApp_sourceBillNos.Add(entity.SourceBillNo);
                else if (entity.Type == InstockType.Miscellaneous)
                    Miscellaneous_sourceBillNos.Add(entity.SourceBillNo);
                //else if (entity.Type == InstockType.ProduceSotck)
                //    ProduceSotck_sourceBillNos.Add(entity.SourceBillNo);
            }

            //if (ProduceSotck_sourceBillNos.Count() > 0)//生产入库
            //{
            //    var erp_result = await _erpService.BillQueryForProduceSotckin(ProduceSotck_sourceBillNos, null);
            //    if (!erp_result.IsSuccess)
            //        return Result<List<ErpInStockResultDto>>.ReFailure(erp_result.Message, erp_result.Status);
            //    erp_list.AddRange(erp_result.Data);
            //}

            if (Instock_sourceBillNos.Count() > 0)
            {
                var erp_result = await _erpService.BillQueryForPurchaseInStock(Instock_sourceBillNos, null);
                if (!erp_result.IsSuccess)
                    return Result<List<ErpInStockResultDto>>.ReFailure(erp_result.Message, erp_result.Status);
                erp_list.AddRange(erp_result.Data);
            }
            if (Miscellaneous_sourceBillNos.Count() > 0)
            {
                var erp_result = await _erpService.BillQueryForMiscellaneous(Miscellaneous_sourceBillNos, null);
                if (!erp_result.IsSuccess)
                    return Result<List<ErpInStockResultDto>>.ReFailure(erp_result.Message, erp_result.Status);
                erp_list.AddRange(erp_result.Data);
            }
            if (TransferDirect_sourceBillNos.Count() > 0)
            {
                var erp_result = await _erpService.BillQueryForTransferDirect(TransferDirect_sourceBillNos, null);
                if (!erp_result.IsSuccess)
                    return Result<List<ErpInStockResultDto>>.ReFailure(erp_result.Message, erp_result.Status);
                erp_list.AddRange(erp_result.Data);
            }
            if (Transferin_sourceBillNos.Count() > 0)
            {
                var erp_result = await _erpService.BillQueryForTransferin(Transferin_sourceBillNos, null);
                if (!erp_result.IsSuccess)
                    return Result<List<ErpInStockResultDto>>.ReFailure(erp_result.Message, erp_result.Status);
                erp_list.AddRange(erp_result.Data);
            }
            if (AssembledApp_sourceBillNos.Count() > 0)
            {
                var erp_result_ass = await _erpService.BillQueryForAssembledApp_Assembly(AssembledApp_sourceBillNos, null);
                if (!erp_result_ass.IsSuccess)
                    return Result<List<ErpInStockResultDto>>.ReFailure(erp_result_ass.Message, erp_result_ass.Status);
                erp_list.AddRange(erp_result_ass.Data);

                //1.1.获取金蝶数据：拆卸子件入库订单数据
                var erp_result_disass = await _erpService.BillQueryForAssembledApp_Disassembly(AssembledApp_sourceBillNos, null);
                if (!erp_result_disass.IsSuccess)
                    return Result<List<ErpInStockResultDto>>.ReFailure(erp_result_disass.Message, erp_result_disass.Status);

                erp_list.AddRange(erp_result_disass.Data);
            }
            

            return Result<List<ErpInStockResultDto>>.ReSuccess(erp_list);
        }
    }
}