using Newtonsoft.Json;
using Rhea.Common;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Tiger.Business.SqlSugarHepler;
using Tiger.Business.WMS.Transaction;
using Tiger.IBusiness;
using Tiger.Model;
using Tiger.Model.DTO;
using Tiger.Model.Entitys.MES;
using Tiger.Model.Entitys.WMS.DTOS;

namespace Tiger.Business.WMS
{
    /// <summary>
    ///
    /// </summary>
    public class ProductInputBusiness : IProductInputBusiness
    {
        /// <summary>
        /// T100接口URL
        /// </summary>
        public string t100Url { get; set; } = @"http://172.18.8.11/wstopprd/ws/r/awsp920";

        /// <summary>
        ///
        /// </summary>
        public readonly ITrasferInfoBusiness _transferBus;

        /// <summary>
        ///
        /// </summary>
        /// <param name="transferBus"></param>
        public ProductInputBusiness(ITrasferInfoBusiness transferBus)
        {
            _transferBus = transferBus;
        }

        /// <summary>
        /// SMT退料对接MES接口
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int SMTReturnFormMES(SMTReturnDTO input)
        {
            //var db = Biz.Db;
            var db = Biz.DataSource["WMS57"].Client;

            Logger.Scheduler.Info($"单号{input.BillCode}开始退料！");

            var snList = input.BarCodes.Select(i => i.SN).Distinct().ToList();
            var snData = db.Queryable<WMS_ITEM>().Where(i => snList.Contains(i.SN)).ToList();
            var oldsnData = snData.Select(i => i.SN).Distinct().ToList();
            var exceptData = snList.Except(oldsnData).ToList();// 传入的数据中有，item表中没有的条码
            if (exceptData.Any())
            {
                Logger.Scheduler.Info($"条码{string.Join(",", exceptData)}未能查询到对应的库存信息，拒绝退料，请确认！");
                throw new Exception($"条码{string.Join(",", exceptData)}未能查询到对应的库存信息，拒绝退料，请确认！");
            }

            var warehouse = CheckData(input, db);// 数据检查

            #region 主表实体构建

            var masterModel = new BIZ_ERP_PROD_RETURN()
            {
                AUTH_ORG = warehouse.OrgCode,
                BILLCODE = input.BillCode,
                WAREHOUSECODE = warehouse.data.WH_CODE,
                STATUS = 0
            };

            #endregion 主表实体构建

            #region 明细表实体构建

            var dicitemcode = new Dictionary<string, string>();
            var itemcodeLst = snData.Select(i => i.ITEM_CODE).Distinct().ToList();
            int sqn = 0;
            foreach (var itemcode in itemcodeLst)
            {
                if (!dicitemcode.ContainsKey(itemcode))
                {
                    sqn++;
                    dicitemcode.Add(itemcode, sqn.ToString());
                }
            }

            var snModel = new List<BIZ_ERP_PROD_RETURN_SN>();
            var snLst = new List<BIZ_WMS_TRANSFER_SN>();
            if (!input.BarCodes.IsNullOrEmpty())
            {
                foreach (var item in input.BarCodes)
                {
                    snModel.Add(new BIZ_ERP_PROD_RETURN_SN()
                    {
                        AUTH_ORG = warehouse.OrgCode,
                        BUSINESSCODE = input.BillCode,
                        SN = item.SN,
                        STATUS = WMS_ITEM.STATUSs.WaitIn.GetValue(),
                        ITEM_CODE = snData.Where(i => i.SN == item.SN).FirstOrDefault()?.ITEM_CODE,
                        QTY = item.Qty
                    });

                    snLst.Add(new BIZ_WMS_TRANSFER_SN()
                    {
                        AUTH_ORG = warehouse.OrgCode,
                        BILLCODE = input.BillCode,
                        SN = item.SN,
                        STATUS = WMS_ITEM.STATUSs.WaitIn.GetValue(),
                        ITEM_CODE = snData.Where(i => i.SN == item.SN).FirstOrDefault()?.ITEM_CODE,
                        QTY = item.Qty,
                        BILLLINE = dicitemcode[item.ItemCode]
                    });
                }
            }

            #endregion 明细表实体构建

            #region DTL表数据实体构建

            var dtlModel = new List<BIZ_ERP_PROD_RETURN_DTL>();
            if (!input.BarCodes.IsNullOrEmpty())
            {
                foreach (var itemcode in itemcodeLst)
                {
                    var prqty = input.BarCodes.Where(i => i.ItemCode == itemcode).Sum(i => i.Qty);// 获取当前物料编号的总数量
                    dtlModel.Add(new BIZ_ERP_PROD_RETURN_DTL()
                    {
                        AUTH_ORG = warehouse.OrgCode,
                        BILLCODE = input.BillCode,
                        LINESTATUS = 0,
                        ITEM_CODE = itemcode,
                        WAREHOUSECODE = warehouse.data.WH_CODE,
                        BILLLINE = dicitemcode[itemcode],
                        PRQTY = prqty
                    });
                }
            }

            #endregion DTL表数据实体构建

            int res = 0;
            try
            {
                BizSqlsugar.CreateTran(() =>
                {
                    if (!masterModel.IsNullOrEmpty())
                    {
                        res = db.Insertable(masterModel).ExecuteCommand();
                    }
                    if (!snModel.IsNullOrEmpty())
                    {
                        res += db.Insertable(snModel).ExecuteCommand();
                    }
                    if (!dtlModel.IsNullOrEmpty())
                    {
                        res += db.Insertable(dtlModel).ExecuteCommand();
                    }
                }, db);
            }
            catch (Exception)
            {
            }

            var inputdto = new List<TrasferInfoDTO>();

            #region 请求实体构建

            var detaildatas = dtlModel.Where(i => i.BILLCODE == masterModel.BILLCODE).ToList();
            var detaildto = new List<TrasferInfoDetailDTO>();
            foreach (var detailitem in detaildatas)
            {
                detaildto.Add(new TrasferInfoDetailDTO()
                {
                    BILLCODE = detailitem.BILLCODE,
                    AUTH_ORG = warehouse.OrgCode,
                    BILLLINE = Convert.ToInt32(detailitem.BILLLINE),
                    LINESTATUS = detailitem.LINESTATUS.ToString(),
                    OUTQTY = detailitem.PRQTY,
                    ITEM_CODE = detailitem.ITEM_CODE,
                    UNITCODE = detailitem.UNITCODE,
                    PRQTY = detailitem.PRQTY,
                    OUTWAREHOUSECODE = warehouse.data.TRANSFER_WH,
                    INWAREHOUSECODE = warehouse.data.WH_CODE,
                    CREATE_TIME = DateTime.Now
                });
            }
            inputdto.Add(new TrasferInfoDTO()
            {
                AUTH_ORG = warehouse.OrgCode,
                BILLCODE = masterModel.BILLCODE,
                BILLDATE = masterModel.BILLDATE,
                OUTWAREHOUSECODE = warehouse.data.TRANSFER_WH,
                INWAREHOUSECODE = warehouse.data.WH_CODE,
                CREATE_TIME = masterModel.CREATE_TIME,
                details = detaildto
            });

            #endregion 请求实体构建

            #region 添加调拨单信息

            _transferBus.SaveTrasferInfo(inputdto, "2");

            if (snLst.Any())
            {
                var history = db.Queryable<BIZ_WMS_TRANSFER_SN>().Where(i => i.BILLCODE == input.BillCode).ToList();
                if (history.Any())
                {
                    db.Deleteable(history).ExecuteCommand();
                }
                db.Insertable(snLst).ExecuteCommand();
            }

            #endregion 添加调拨单信息

            return res;
        }

        /// <summary>
        /// 数据检查
        /// </summary>
        /// <param name="input"></param>
        /// <param name="db"></param>
        /// <exception cref="Exception"></exception>
        public OrgDataDTO CheckData(SMTReturnDTO input, DbClient db)
        {
            var olddata = db.Queryable<BIZ_ERP_PROD_RETURN>().Where(i => i.BILLCODE == input.BillCode).ToList();
            if (olddata.Any())
            {
                throw new Exception($"当前单据：{input.BillCode}  已存在退料信息数据，请确认！");
            }
            var snList = input.BarCodes.Select(i => i.SN).Distinct().ToList();
            var itemData = db.Queryable<WMS_ITEM>().Where(i => snList.Contains(i.SN)).ToList();
            var orgLst = itemData.Select(i => i.AUTH_ORG).Distinct().ToList();
            if (orgLst is { Count: > 1 })
            {
                throw new Exception($"违规操作！当前SN明细数据对应多个据点{string.Join(",", orgLst)}，拒绝退料！");
            }
            var whcodes = itemData.Select(i => i.ERP_WH).Distinct().ToList();
            if (whcodes is { Count: > 1 })
            {
                throw new Exception($"违规操作！当前SN明细数据对应多个仓库{string.Join(",", whcodes)}，拒绝退料！");
            }
            var snSource = itemData.Where(i => i.STATUS != 60).Select(i => i.SN).Distinct().ToList();
            if (snSource.Any())
            {
                throw new Exception($"SN条码：{string.Join(",", snSource)}，对应库存状态不为【已发料】状态，拒绝退货！");
            }
            var oldSNLst = itemData.Select(i => i.SN).Distinct().ToList();
            var noSnList = snList.Except(oldSNLst).ToList();
            if (noSnList.Any())
            {
                throw new Exception($"SN条码：{string.Join(",", noSnList)}不存在库存信息，拒绝退货！");
            }
            var warehouse = db.Queryable<WMS_WAREHOUSE>().Where(i => i.WH_CODE == whcodes[0]).First();// 获取仓库信息
            if (warehouse == null)
            {
                throw new Exception($"未能查询到当前仓库{whcodes[0]}信息，退料失败，请确认！");
            }

            var sns = input.BarCodes.GroupBy(i => i.SN).Where(i => i.Count() > 1).Select(i => i.Key).Distinct().ToList();// 查询重复的条码
            if (sns.Any())
            {
                throw new Exception($"条码明细中有重复的SN条码：{string.Join(",", sns)}，拒绝退货！");
            }

            var barSns = input.BarCodes.Select(i => i.SN).Distinct().ToList();// 条码明细
            var data = db.Queryable<BIZ_ERP_PROD_RETURN, BIZ_ERP_PROD_RETURN_SN>((a, b) => new object[]
            {
                JoinType.Left,a.BILLCODE == b.BUSINESSCODE
            }).Where((a, b) => barSns.Contains(b.SN))
            .Select((a, b) => new { b.SN, a.ERP_BILL_CODE }).Distinct().ToList();
            var nullerp = data.Where(i => string.IsNullOrWhiteSpace(i.ERP_BILL_CODE)).Select(i => i.SN).Distinct().ToList();// 获取所有erpbillcode为空的条码数据
            if (nullerp.Any())
            {
                throw new Exception($"传入的条码/t{string.Join(",", nullerp)}/t存在已退料未过账的数据，请勿重复退料！");
            }

            var model = new OrgDataDTO()
            {
                data = warehouse,
                OrgCode = orgLst[0]
            };
            return model;
        }

        /// <summary>
        /// 成品入库
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int GetProductInputInfoFromT100(ProduceInputDataDTO input)
        {
            //var db = Biz.Db;
            var db = Biz.DataSource["WMS57"].Client;
            //var db1 = Biz.DataSource["Test"].Client;

            var olddata = db.Queryable<BIZ_ERP_PROD_IN>().Where(i => i.BILLCODE == input.sfeadocno).ToList();
            //if (olddata.Any())
            //{
            //    throw new Exception($"当前单号：{input.sfeadocno}  已存在库存信息数据，不允许重复入库！");
            //}

            var warehouseLst = input.Details.Select(i => i.sfeb013).Distinct().ToList();
            if (warehouseLst is { Count: > 1 })
            {
                throw new Exception($"同一批明细数据中不允许存在多个库位号，请确认！");
            }

            var models = input.Details.Where(i => i.sfeb004.StartsWith("10")).Select(i => i.sfebud001).Distinct().ToList();// T100 推送过来的机型
            if (models is { Count: > 1 })
            {
                throw new Exception($"同一批明细数据中不允许存在多个机型，请确认！");
            }

            #region 主表实体构建

            var masterModel = new BIZ_ERP_PROD_IN()
            {
                AUTH_ORG = input.sfeasite,
                BILLCODE = input.sfeadocno,
                WAREHOUSECODE = input.Details.FirstOrDefault()?.sfeb013,
                CREATE_USER = input.sfea002,
                ITEM_MODEL = models.Count() == 0 ? null : models[0],
                STATUS = 0
            };

            var hostoryMasterData = db.Queryable<BIZ_ERP_PROD_IN>().Where(i => i.BILLCODE == masterModel.BILLCODE).ToList();// 获取历史数据

            #endregion 主表实体构建

            #region 明细表实体构建

            var dtlModel = new List<BIZ_ERP_PROD_IN_DTL>();
            foreach (var item in input.Details)
            {
                dtlModel.Add(new BIZ_ERP_PROD_IN_DTL()
                {
                    AUTH_ORG = input.sfeasite,
                    BILLCODE = input.sfeadocno,
                    ITEM_CODE = item.sfeb004,
                    PRQTY = item.sfeb008,
                    WAREHOUSECODE = item.sfeb013,
                    CREATE_USER = input.sfea002,
                    LINESTATUS = 0,
                    UNITCODE = item.sfeb007,
                    BILLLINE = item.sfebseq.ToString(),
                    REMARK = item.sfeb003
                });
            }

            var hostoryDtlData = db.Queryable<BIZ_ERP_PROD_IN_DTL>().Where(i => i.BILLCODE == masterModel.BILLCODE).ToList();

            #endregion 明细表实体构建

            int res = 0;
            try
            {
                BizSqlsugar.CreateTran(() =>
                {
                    #region 成品入库表

                    if (hostoryMasterData.Any())
                    {
                        db.Deleteable(hostoryMasterData).ExecuteCommand();
                    }
                    if (!masterModel.IsNullOrEmpty())
                    {
                        res = db.Insertable(masterModel).ExecuteCommand();
                        //res = db1.Insertable(masterModel).ExecuteCommand();
                    }
                    if (hostoryDtlData.Any())
                    {
                        db.Deleteable(hostoryDtlData).ExecuteCommand();
                    }
                    if (!dtlModel.IsNullOrEmpty())
                    {
                        res += db.Insertable(dtlModel).ExecuteCommand();
                        //res += db1.Insertable(dtlModel).ExecuteCommand();
                    }

                    #endregion 成品入库表
                }, db);
            }
            catch (Exception)
            {
            }

            //DataToT100(input, authOrg);

            return res;
        }

        /// <summary>
        /// 成品入库
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public string GetProductInputInfo(ProductInputDTO input)
        {
            //var db = Biz.Db;
            var db = Biz.DataSource["WMS57"].Client;
            //var db = Biz.DataSource["Test"].Client;

            var sndataList = input.details.Select(i => i.SN).Distinct().ToList();// 新的条码
            var oldsnList = db.Queryable<BIZ_ERP_PROD_IN_SN>().Where(i => i.BUSINESSCODE == input.WorkOrder).Select(i => i.SN).Distinct().ToList();// 已入库的SN条码
            var needinsertSNList = sndataList.Except(oldsnList).ToList();
            var detail = input.details.Where(i => needinsertSNList.Contains(i.SN)).ToList();// 需要处理的新SN条码数据

            if (!detail.Any())
            {
                return null;
            }

            var inData = db.Queryable<BIZ_ERP_PROD_IN>().Where(i => i.BILLCODE == input.WorkOrder).First();
            var inDtlData = db.Queryable<BIZ_ERP_PROD_IN_DTL>().Where(i => i.BILLCODE == input.WorkOrder).ToList();
            var sumprqty = inDtlData.Sum(i => i.PRQTY);// 需求总数量
            var suminputqty = inDtlData.Sum(i => i.INSTOCKQTY);// 已入库数量
            if (detail.Count() + suminputqty > sumprqty)
            {
                Logger.Scheduler.Info($"当前工单：{input.WorkOrder}  当前数量：{detail.Count()}与已入库数量：{suminputqty}之和超过需求数量：{sumprqty}，拒绝入库，请确认！");
                throw new Exception($"当前工单：{input.WorkOrder}  当前数量：{detail.Count()}与已入库数量：{suminputqty}之和超过需求数量：{sumprqty}，拒绝入库，请确认！");
            }
            // 2023年10月25日11:11:07 by 杨浩
            //if (!string.IsNullOrEmpty(inData.ITEM_MODEL) && input.ITEM_MODEL != inData.ITEM_MODEL)
            //{
            //    Logger.Scheduler.Info($"当前工单：{input.WorkOrder}  机型：{input.ITEM_MODEL}与T100机型：{inData.ITEM_MODEL}不一致，拒绝入库，请确认！");
            //    throw new Exception($"当前工单：{input.WorkOrder}  机型：{input.ITEM_MODEL}与T100机型：{inData.ITEM_MODEL}不一致，拒绝入库，请确认！");
            //}

            var detailModel = new List<BIZ_ERP_PROD_IN_SN>();// 条码表实体构建
            var itemModel = new List<WMS_ITEM>(); // 库存信息实体构建
            var hisModel = new List<WMS_ITEM_HIS>();// 库存历史实体构造
            var pkgModel = new List<WMS_ITEM_PKG>();// 包装信息实体构建

            #region 实体构建

            #region 给现有成品料号进行编号

            var dtlsumData = inDtlData.Where(i => i.PRQTY != i.INSTOCKQTY).OrderBy(i => i.BILLLINE).Select(i => new { i.ITEM_CODE, i.PRQTY, i.INSTOCKQTY }).ToList();
            var dic = new Dictionary<decimal, string>();
            var count = 0M;
            foreach (var item in dtlsumData)
            {
                var sum = item.PRQTY - item.INSTOCKQTY;
                for (var i = 1; i <= sum; i++)
                {
                    count++;
                    if (!dic.ContainsKey(count))
                    {
                        dic.Add(count, item.ITEM_CODE);
                    }
                }
            }

            #endregion 给现有成品料号进行编号

            var whUnits = db.Queryable<V_WH_UNIT>().Where(q => detail.Select(d => input.WarehouseCode + "@" + d.Location).Contains(q.WH_CODE + "@" + q.LOCATION_CODE)).ToList();
            var sqn = 0M;

            #region 数据填充

            var bol = false;
            var palletno = input.details.Select(i => i.Pallet).Distinct().First();
            var newData = db.Queryable<BIZ_ERP_PROD_IN_DTL>().Where(i => i.BILLCODE == input.WorkOrder).ToList();
            var itemlist = newData.Where(i => i.ITEM_CODE.StartsWith("5405") || i.ITEM_CODE.StartsWith("5402") || i.ITEM_CODE.StartsWith("1060")).Select(i => i.ITEM_CODE).Distinct().ToList();
            var mesData = new List<MESDTO>();
            if (newData.FirstOrDefault()?.AUTH_ORG == "YTXC" && itemlist.Count() == newData.Count())
            {
                var ytdb = Biz.DataSource["YTMES"].Client;
                mesData = ytdb.Queryable<R_Wip_Tracking_T>().Where(i => i.STOCK_NO == input.WorkOrder)
                .Select(i => new MESDTO()
                {
                    Stock_No = i.STOCK_NO,
                    SO_NUMBER = i.SO_NUMBER,
                    SHIPPING_SN = i.SHIPPING_SN,
                    SERIAL_NUMBER = i.SERIAL_NUMBER,
                    CARTON_NO = i.CARTON_NO,
                    PALLET_NO = i.PALLET_NO,
                    IN_STATION_TIME = i.IN_STATION_TIME,
                    Model_Name = i.MODEL_NAME
                }).ToList();
                bol = true;
            }
            foreach (var item in detail)
            {
                sqn++;
                var itemcode = dic[sqn];
                var whUnit = whUnits.FirstOrDefault(q => q.WH_CODE + "@" + q.LOCATION_CODE == input.WarehouseCode + "@" + item.Location);
                var mesCount = mesData.Count != 0 ? (mesData.FirstOrDefault(i => i.SHIPPING_SN == item.SN).SO_NUMBER).ToDecimal() : 0;
                if (whUnit.IsNullOrEmpty())
                {
                    Logger.Scheduler.Info($"当前工单：{input.WorkOrder} 未能查询到当前库位/储位{input.WarehouseCode}/{item.Location}信息，请确认该库位/储位是否存在！");
                    throw new Exception($"当前工单：{input.WorkOrder} 未能查询到当前库位/储位{input.WarehouseCode}/{item.Location}信息，请确认该库位/储位是否存在！");
                }
                detailModel.Add(new BIZ_ERP_PROD_IN_SN()
                {
                    AUTH_ORG = inData?.AUTH_ORG,
                    SN = item.SN,
                    ITEM_MODEL = input.ITEM_MODEL,
                    STATUS = WMS_ITEM.STATUSs.WaitIn.GetValue(),
                    Qty = bol ? mesCount : 1,
                    META_SN = "",
                    BUSINESSCODE = input.WorkOrder,
                    CARTONNO = item.Carton,
                    ITEM_CODE = itemcode,
                    PALLETNO = item.Pallet,
                    DATECODE = item.ProdDate.HasValue ? item.ProdDate.Value : DateTime.Now,
                    CREATE_USER = input.UserCode
                });

                itemModel.Add(new WMS_ITEM()
                {
                    AUTH_ORG = inData?.AUTH_ORG,
                    SN = item.SN,
                    ITEM_MODEL = input.ITEM_MODEL,
                    STATUS = WMS_ITEM.STATUSs.WaitIn.GetValue(),
                    ITEM_CODE = itemcode,
                    QTY = bol ? mesCount : 1,
                    UNIT = item.Unit,
                    PROD_DATE = item.ProdDate.HasValue ? detail[0].ProdDate.Value : DateTime.Now,
                    TRANS_NO = input.WorkOrder,
                    CARTON_NO = item.Carton,
                    PALLET_NO = item.Pallet,
                    ERP_WH = inData.WAREHOUSECODE,
                    WH_ID = whUnit?.WH_ID,
                    REGION_ID = whUnit?.REGION_ID,
                    SHELF_ID = whUnit?.SHELF_ID,
                    LOCATION_ID = whUnit?.LOCATION_ID,
                    CREATE_USER = input.UserCode,
                    FIRST_IN_DATE = DateTime.Now
                });

                hisModel.Add(new WMS_ITEM_HIS()
                {
                    AUTH_ORG = inData?.AUTH_ORG,
                    SN = item.SN,
                    TRANS_NO = input.WorkOrder,
                    STATUS = WMS_ITEM.STATUSs.WaitIn.GetValue(),
                    ITEM_CODE = itemcode,
                    QTY = detail.Count(),
                    UNIT = item.Unit,
                    PROD_DATE = item.ProdDate.HasValue ? item.ProdDate.Value : DateTime.Now,
                    CARTON_NO = item.Carton,
                    PALLET_NO = item.Pallet,
                    ERP_WH = inData.WAREHOUSECODE,
                    WH_ID = whUnit?.WH_ID,
                    REGION_ID = whUnit?.REGION_ID,
                    SHELF_ID = whUnit?.SHELF_ID,
                    LOCATION_ID = whUnit?.LOCATION_ID,
                    CREATE_USER = input.UserCode,
                    TRACE_INFO = "WMS成品入库，待入库"
                });
            }

            #endregion 数据填充

            var palletLst = detail.Select(i => i.Pallet).Distinct().ToList(); // 获取所有的栈板号
            foreach (var pallet in palletLst)
            {
                var boxLst = detail.Where(i => i.Pallet == pallet).Select(i => i.Carton).Distinct().ToList();// 获取所有的箱号
                var m = 0M;
                foreach (var box in boxLst)
                {
                    var sndata = detail.Where(i => i.Pallet == pallet && i.Carton == box).ToList();// 当前栈板号/箱号下的所有SN数据
                    foreach (var item in sndata)
                    {
                        m++;
                        var itemcode = dic[m];

                        #region 添加 SN-Box数据

                        var whUnit = whUnits.FirstOrDefault(q => q.WH_CODE + "@" + q.LOCATION_CODE == input.WarehouseCode + "@" + item.Location);
                        var mesCount = mesData.Count != 0 ? (mesData.FirstOrDefault(i => i.SHIPPING_SN == item.SN).SO_NUMBER).ToDecimal() : 0;
                        pkgModel.Add(new WMS_ITEM_PKG()
                        {
                            AUTH_ORG = inData?.AUTH_ORG,
                            TRANS_NO = input.WorkOrder,
                            SN = item.SN,
                            PARENT_SN = box,
                            ITEM_CODE = itemcode,
                            QTY = bol ? mesCount : 1,
                            UNIT = item.Unit,
                            ERP_WH = inData.WAREHOUSECODE,
                            WH_ID = whUnit?.WH_ID,
                            REGION_ID = whUnit?.REGION_ID,
                            SHELF_ID = whUnit?.SHELF_ID,
                            LOCATION_ID = whUnit?.LOCATION_ID,
                            CREATE_USER = input.UserCode
                        });

                        #endregion 添加 SN-Box数据
                    }

                    #region 添加Box-Pallet对应关系

                    pkgModel.Add(new WMS_ITEM_PKG()
                    {
                        AUTH_ORG = inData?.AUTH_ORG,
                        TRANS_NO = input.WorkOrder,
                        SN = box,
                        PARENT_SN = pallet,
                        //ITEM_CODE = itemcode,
                        QTY = sndata.Count(),
                        ERP_WH = inData.WAREHOUSECODE,
                        CREATE_USER = input.UserCode
                    });

                    #endregion 添加Box-Pallet对应关系
                }

                #region 添加Pallet-Null对应关系

                var Count = detail.Where(i => i.Pallet == pallet).Count();
                pkgModel.Add(new WMS_ITEM_PKG()
                {
                    AUTH_ORG = inData?.AUTH_ORG,
                    TRANS_NO = input.WorkOrder,
                    SN = pallet,
                    ITEM_CODE = input.ItemCode,
                    QTY = Count,
                    ERP_WH = inData.WAREHOUSECODE,
                    CREATE_USER = input.UserCode
                });

                #endregion 添加Pallet-Null对应关系
            }

            //var snList = input.details.Select(i => i.SN).Distinct().ToList();
            var dataList = pkgModel.Where(i => i.SN == i.PARENT_SN).ToList();
            var pkgData = pkgModel.Except(dataList).ToList();// 剔除掉箱号=栈板号的数据
            //var hostoryDetailData = db.Queryable<BIZ_ERP_PROD_IN_SN>().Where(i => i.BUSINESSCODE == input.WorkOrder).ToList();

            #endregion 实体构建

            #region 筛选 增——删——改数据——已删除

            #region 库存信息

            //var oldItemData = db.Queryable<WMS_ITEM>().Where(i => i.TRANS_NO == input.WorkOrder).ToList();// 获取当前工单的历史数据
            //var oldSnLst = oldItemData.Select(i => i.SN).Distinct().ToList();// 获取旧的SN码
            //var needDeleteSns = oldSnLst.Except(snList).ToList();// 需要删除的SN码
            //var deletedData = oldItemData.Where(i => needDeleteSns.Contains(i.SN)).ToList();// 需要删除的数据

            //var needInsertSns = snList.Except(oldSnLst).ToList();// 需要新增的数据
            //var insertData = itemModel.Where(i => needInsertSns.Contains(i.SN)).ToList();// 需要新增的数据

            //var needUpdateSn = oldSnLst.Intersect(snList).ToList();// 需要更新的数据
            //var updateData = oldItemData.Where(i => needUpdateSn.Contains(i.SN)).ToList();
            //foreach (var item in updateData)
            //{
            //    item.ITEM_CODE = input.ItemCode;
            //    item.QTY = input.details.Count();
            //    item.UNIT = itemModel.Where(i => i.SN == item.SN).FirstOrDefault()?.UNIT;
            //    item.PROD_DATE = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().PROD_DATE;
            //    item.TRANS_NO = input.WorkOrder;
            //    item.CARTON_NO = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().CARTON_NO;
            //    item.PALLET_NO = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().PALLET_NO;
            //    item.ERP_WH = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().ERP_WH;
            //    item.WH_ID = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().WH_ID;
            //    item.REGION_ID = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().REGION_ID;
            //    item.SHELF_ID = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().SHELF_ID;
            //    item.LOCATION_ID = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().LOCATION_ID;
            //    item.CREATE_USER = input.UserCode;
            //}

            #endregion 库存信息

            #region 库存历史

            //var oldhisData = db.Queryable<WMS_ITEM_HIS>().Where(i => i.TRANS_NO == input.WorkOrder).ToList();// 获取当前工单的历史数据
            //var oldhisSnLst = oldhisData.Select(i => i.SN).Distinct().ToList();// 获取旧的SN码
            //var needDeletehisSns = oldhisSnLst.Except(snList).ToList();// 需要删除的SN码
            //var deletedhisData = oldhisData.Where(i => needDeletehisSns.Contains(i.SN)).ToList();// 需要删除的数据

            //var hisneedInsertSns = snList.Except(oldhisSnLst).ToList();// 需要新增的数据
            //var hisinsertData = hisModel.Where(i => hisneedInsertSns.Contains(i.SN)).ToList();// 需要新增的数据

            //var hisneedUpdateSn = oldhisSnLst.Intersect(snList).ToList();// 需要更新的数据
            //var hisupdateData = oldhisData.Where(i => hisneedUpdateSn.Contains(i.SN)).ToList();
            //foreach (var item in hisupdateData)
            //{
            //    item.ITEM_CODE = input.ItemCode;
            //    item.QTY = input.details.Count();
            //    item.UNIT = itemModel.Where(i => i.SN == item.SN).FirstOrDefault()?.UNIT;
            //    item.PROD_DATE = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().PROD_DATE;
            //    item.TRANS_NO = input.WorkOrder;
            //    item.CARTON_NO = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().CARTON_NO;
            //    item.PALLET_NO = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().PALLET_NO;
            //    item.ERP_WH = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().ERP_WH;
            //    item.WH_ID = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().WH_ID;
            //    item.REGION_ID = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().REGION_ID;
            //    item.SHELF_ID = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().SHELF_ID;
            //    item.LOCATION_ID = itemModel.Where(i => i.SN == item.SN).FirstOrDefault().LOCATION_ID;
            //}

            #endregion 库存历史

            #endregion 筛选 增——删——改数据——已删除

            foreach (var item in inDtlData)
            {
                item.LINESTATUS = 1;
            }
            inData.STATUS = 1;

            int res = 0;
            try
            {
                BizSqlsugar.CreateTran(() =>
                {
                    #region 成品入库表

                    if (detailModel.Any())
                    {
                        res += BizSqlsugar.InsertDataTable(detailModel, db);
                    }

                    #endregion 成品入库表

                    #region 库存信息表

                    if (itemModel.Any())
                    {
                        BizSqlsugar.InsertDataTable(itemModel, db);
                    }

                    #endregion 库存信息表

                    #region 库存历史

                    if (hisModel.Any())
                    {
                        BizSqlsugar.InsertDataTable(hisModel, db);
                    }

                    #endregion 库存历史

                    #region 包装信息

                    if (pkgData.Any())
                    {
                        BizSqlsugar.InsertDataTable(pkgData, db);
                    }

                    #endregion 包装信息

                    #region 成品入库头表

                    db.Updateable(inDtlData).ExecuteCommand();

                    #endregion 成品入库头表

                    #region 成品入库DTL表

                    BizSqlsugar.UpdateDataTable(inDtlData, db);

                    #endregion 成品入库DTL表
                }, db);
            }
            catch (Exception ex)
            {
                Logger.Scheduler.Info($"工单：{input.WorkOrder} 成品入库对接MES存储数据失败，失败原因: {ex.Message}");
                throw new Exception($"工单：{input.WorkOrder} 成品入库对接MES存储数据失败，失败原因: {ex.Message}");
            }
            Logger.Scheduler.Info($"数据存储成功！");

            //DataToT100(input, authOrg);

            #region 明细数据入库数量更新

            int SNCount = detail.Count();
            //var itemlist = newData.Where(i => i.ITEM_CODE.StartsWith("5405") || i.ITEM_CODE.StartsWith("5402") || i.ITEM_CODE.StartsWith("1060")).Select(i => i.ITEM_CODE).Distinct().ToList();
            if (newData.FirstOrDefault()?.AUTH_ORG == "YTXC" && itemlist.Count() == newData.Count())
            {
                var ytdb = Biz.DataSource["YTMES"].Client;
                var ytsourceData2 = ytdb.Queryable<R_Wip_Tracking_T>().Where(i => i.STOCK_NO == input.WorkOrder && i.PALLET_NO == palletno).ToList();
                var mescount = ytsourceData2.Sum(i => i.SO_NUMBER.ToInt32());
                SNCount = mescount;
                if (SNCount + suminputqty > sumprqty)
                {
                    Logger.Scheduler.Info($"当前工单：{input.WorkOrder}  当前数量：{detail.Count()}与已入库数量：{suminputqty}之和超过需求数量：{sumprqty}，拒绝入库，请确认！");
                    throw new Exception($"当前工单：{input.WorkOrder}  当前数量：{detail.Count()}与已入库数量：{suminputqty}之和超过需求数量：{sumprqty}，拒绝入库，请确认！");
                }
            }
            var Data = ChangeDTL(newData, SNCount);

            #region 更新明细数据入库数量

            if (Data.Any())
            {
                BizSqlsugar.UpdateDataTable(Data, db);
            }

            #endregion 更新明细数据入库数量

            #endregion 明细数据入库数量更新

            #region 调用T100过账

            var msg = string.Empty;

            var prqtySum = newData.Sum(i => i.PRQTY);
            var inSum = newData.Sum(i => i.INSTOCKQTY);
            if (prqtySum == inSum)
            {
                try
                {
                    msg = GetProductInputPostingToT100(input);// 当需求数量与入库数量一致时，调用T100过账接口进行过账
                }
                catch (Exception)
                {
                    Logger.Scheduler.Info($"单号：{input.WorkOrder}\t推送T100过账失败，失败原因：{msg}");
                    //throw new Exception($"当前单号：{input.WorkOrder}\t推送T100过账失败，失败原因：{msg}");
                }

                Logger.Scheduler.Info($"单号：{input.WorkOrder}状态及时间开始更新！");
                var wmsitemData = db.Queryable<WMS_ITEM>().Where(i => i.TRANS_NO == input.WorkOrder).ToList();
                foreach (var item in wmsitemData)
                {
                    item.STATUS = WMS_ITEM.STATUSs.InStore.GetValue();
                    item.UPDATE_TIME = DateTime.Now;
                }

                var hisData = new WMS_ITEM_HIS()
                {
                    CREATE_TIME = DateTime.Now,
                    TRANS_NO = input.WorkOrder,
                    SN = "固定条码",
                    TRACE_INFO = "成品入库单已推送T100过账"
                };

                var inSource = db.Queryable<BIZ_ERP_PROD_IN>().Where(i => i.BILLCODE == input.WorkOrder).ToList();
                foreach (var item in inSource)
                {
                    item.STATUS = 3;
                }
                var dtlSource = db.Queryable<BIZ_ERP_PROD_IN_DTL>().Where(i => i.BILLCODE == input.WorkOrder).ToList();// 获取单身表数据
                foreach (var item in dtlSource)
                {
                    item.LINESTATUS = 3;
                }
                var snSource = db.Queryable<BIZ_ERP_PROD_IN_SN>().Where(i => i.BUSINESSCODE == input.WorkOrder).ToList();// 获取单身表数据
                foreach (var item in snSource)
                {
                    item.STATUS = WMS_ITEM.STATUSs.InStore.GetValue();
                }
                BizSqlsugar.UpdateDataTable(inSource, db);
                BizSqlsugar.UpdateDataTable(dtlSource, db);
                BizSqlsugar.UpdateDataTable(snSource, db);
                BizSqlsugar.UpdateDataTable(wmsitemData, db);
                //db.Updateable(wmsitemData).ExecuteCommand();
                //db.Updateable(wmsitemData).ExecuteCommand();
                db.Insertable(hisData).ExecuteCommand();
                Logger.Scheduler.Info($"单号：{input.WorkOrder}状态及时间更新完成！");
            }

            #endregion 调用T100过账

            Logger.Scheduler.Info($"单号：{input.WorkOrder}/t {string.Join(",", palletLst)}过账成功！过账数量：{input.details.Count()}");

            return msg;
        }

        /// <summary>
        /// 更新明细数据的入库数量
        /// </summary>
        /// <param name="input"></param>
        /// <param name="Count"></param>
        /// <returns></returns>
        public List<BIZ_ERP_PROD_IN_DTL> ChangeDTL(List<BIZ_ERP_PROD_IN_DTL> input, decimal Count)
        {
            var model = new List<BIZ_ERP_PROD_IN_DTL>();
            var data = input.Where(i => i.INSTOCKQTY < i.PRQTY).OrderBy(i => i.BILLLINE).ToList();
            var sumprqty = input.Sum(i => i.PRQTY);// 需求总数量
            var suminputqty = input.Sum(i => i.INSTOCKQTY);// 已入库数量
            if (Count + suminputqty > sumprqty)
            {
                Logger.Scheduler.Info($"工单：{input[0].BILLCODE}  当前数量：{Count}与已入库数量：{suminputqty}之和超过需求数量：{sumprqty}，拒绝入库，请确认！");
                throw new Exception($"工单：{input[0].BILLCODE}  当前数量：{Count}与已入库数量：{suminputqty}之和超过需求数量：{sumprqty}，拒绝入库，请确认！");
            }
            foreach (var item in data)
            {
                var prqty = item.PRQTY;
                if (prqty >= Count + item.INSTOCKQTY)
                {
                    item.INSTOCKQTY = Count + item.INSTOCKQTY;
                    if (prqty == Count + item.INSTOCKQTY)
                    {
                        item.LINESTATUS = 2;
                    }
                    model.Add(item);
                    return model;// 如果当前传入数量小于当前需求数量，则直接更新
                }
                else
                {
                    Count = Count - (item.PRQTY - item.INSTOCKQTY);
                    item.INSTOCKQTY = prqty;
                    item.LINESTATUS = 2;
                    model.Add(item);// 否则循环更新多条数量
                }
            }
            return model;
        }

        /// <summary>
        /// 根据工单号获取据点名称
        /// </summary>
        /// <param name="workOrder"></param>
        /// <returns></returns>
        public string GetAuthOrg(string workOrder)
        {
            var authOrg = string.Empty;
            var org = workOrder.Substring(0, 2);
            switch (org)
            {
                #region 循环取值

                case "PH":
                    authOrg = "PHXC";
                    break;

                case "YX":
                    authOrg = "YXYY";
                    break;

                case "XP":
                    authOrg = "XCXP";
                    break;

                case "XN":
                    authOrg = "XCXN";
                    break;

                case "TH":
                    authOrg = "STTH";
                    break;

                case "XC":
                    authOrg = "XCSJ";
                    break;

                case "DG":
                    authOrg = "DGXC";
                    break;

                case "HK":
                    authOrg = "HKXC";
                    break;

                case "TX":
                    authOrg = "TXXC";
                    break;

                case "LR":
                    authOrg = "XCLR";
                    break;

                case "OM":
                    authOrg = "OMKJ";
                    break;

                case "AH":
                    authOrg = "AHXC";
                    break;

                case "YK":
                    authOrg = "XCYK";
                    break;

                case "CC":
                    authOrg = "XCCC";
                    break;

                case "TC":
                    authOrg = "XCTC";
                    break;

                case "TK":
                    authOrg = "STTK";
                    break;

                case "MM":
                    authOrg = "STMM";
                    break;

                case "YT":
                    authOrg = "YTXC";
                    break;

                default:
                    throw new Exception($"单号前两位：{org}未能找到对应的据点，请确认！");

                    #endregion 循环取值
            }
            return authOrg;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        public void DataToT100(ProductInputDTO input, string authOrg)
        {
            #region 创建请求实体

            var detail = new List<FinishProductDTO>();
            detail.Add(new FinishProductDTO()
            {
                sfeb001 = input.WorkOrder,
                sfeb008 = input.details.Count(),
                sfeb013 = input.WarehouseCode,
                sfeb014 = input.details[0].Location,
                sfeb015 = ""
            });

            var shipment = new List<ShipMent>();
            shipment.Add(new ShipMent()
            {
                sfeadocdt = DateTime.Now.ToString("yyyy-MM-dd"),
                sfeadocno = "5801",
                sfea002 = input.UserCode,
                detail1 = detail
            });

            var model = new BodyDTO<PayLoad<Std_Data<ParameterFinishProductDTO>>>()
            {
                host = new HostDTO(),
                datakey = new DataKey()
                {
                    EntId = "88",
                    CompanyId = authOrg
                },
                service = new ServiceDTO()
                {
                    name = "wms_gen_asft340"
                },
                payload = new PayLoad<Std_Data<ParameterFinishProductDTO>>()
                {
                    std_data = new Std_Data<ParameterFinishProductDTO>()
                    {
                        parameter = new ParameterFinishProductDTO()
                        {
                            shipment = shipment
                        }
                    }
                }
            };

            #endregion 创建请求实体

            #region 发起请求

            var result = new T100ActionResult<resultStd_data<ParameterFinishProductT100>>();
            try
            {
                var requestJson = JsonConvert.SerializeObject(model);
                var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_data<ParameterFinishProductT100>>>(response.Message);
                Logger.Scheduler.Info($"成品入库信息同步提交Json: {requestJson}，返回Json: {response.Message}");
            }
            catch (Exception)
            {
                Logger.Scheduler.Info($"成品入库信息同步失败");
            }

            #endregion 发起请求
        }

        /// <summary>
        /// 成品入库对接T100过账接口
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public string GetProductInputPostingToT100(ProductInputDTO input)
        {
            var authOrg = GetAuthOrg(input.WorkOrder);

            #region 创建请求实体

            var model = new BodyDTO<PayLoad<Std_Data<ParameterPostingDTO>>>()
            {
                host = new HostDTO(),
                datakey = new DataKey()
                {
                    EntId = "88",
                    CompanyId = authOrg
                },
                service = new ServiceDTO()
                {
                    name = "wms_post_asft340"
                },
                payload = new PayLoad<Std_Data<ParameterPostingDTO>>()
                {
                    std_data = new Std_Data<ParameterPostingDTO>()
                    {
                        parameter = new ParameterPostingDTO()
                        {
                            sfeadocno = input.WorkOrder,
                            sfea001 = DateTime.Now.ToString("yyyy-MM-dd")
                        }
                    }
                }
            };

            #endregion 创建请求实体

            #region 发起请求

            var result = new T100ActionResult<resultStd_inputdata>();
            try
            {
                var requestJson = JsonConvert.SerializeObject(model);
                var response = HttpHelper.PostAsync(t100Url, requestJson).Result;
                result = JsonConvert.DeserializeObject<T100ActionResult<resultStd_inputdata>>(response.Message);
                Logger.Scheduler.Info($"成品入库对接T100过账提交Json: {requestJson}，返回Json: {response.Message}");
            }
            catch (Exception ex)
            {
                Logger.Scheduler.Info($"成品入库对接T100过账失败");
                return "0";
            }

            #endregion 发起请求

            var db = Biz.DataSource["WMS57"].Client;
            var olddata = db.Queryable<BIZ_ERP_PROD_IN>().Where(i => i.BILLCODE == input.WorkOrder).ToList();

            var msg = result.payload.std_data?.execution.description.ToString();
            if (result.payload.std_data?.execution.code == "S")
            {
                //msg = result.payload.std_data?.execution.description.ToString();
                foreach (var data in olddata)
                {
                    data.ERP_BILL_CODE = "T100返回信息已过账";
                }
            }
            if (result.payload.std_data?.execution.code == "0")//msg == "1" &&
            {
                foreach (var data in olddata)
                {
                    data.ERP_BILL_CODE = input.WorkOrder;// 更新单号
                }
            }

            BizSqlsugar.CreateTran(() =>
            {
                //BizSqlsugar.UpdateDataTable(wmsitemData, db);
                BizSqlsugar.UpdateDataTable(olddata, db);
                //db.Insertable(hisData).ExecuteCommand();
            }, db);

            return msg;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<List<C_Stock_Pallet_T>> GetProductInputResultInfoAsync(ProductInputResultDTO input)
        {
            var db = Biz.DataSource["MES"].Client;
            var data = await db.Queryable<C_Stock_Pallet_T>()
                .WhereIF(!string.IsNullOrWhiteSpace(input.WorkOrder), i => i.STOCK_NO == input.WorkOrder)
                .Where(i => i.STOCK_NO.Contains("-")).ToListAsync();// 所有的成品入库单

            if (string.IsNullOrWhiteSpace(input.WorkOrder))
            {
                var data1 = data?.Where(i => i.UP_FLAG == 1).Select(i => i.STOCK_NO).Distinct().ToList();// 所有已经过账的单号
                var data2 = data?.Where(i => i.UP_FLAG == 0).Select(i => i.STOCK_NO).Distinct().ToList();// 所有未过账的单号
                var stocknoList = data2.Except(data1).ToList(); // 单号集合
                var model = data.Where(i => stocknoList.Contains(i.STOCK_NO)).ToList();

                return model;
            }
            return data;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public int ProductInputStatusRestoredAsync(ProductInputResultDTO input)
        {
            int s = 0;
            if (string.IsNullOrWhiteSpace(input.WorkOrder))
            {
                throw new Exception($"单号不允许为空！");
            }
            var db = Biz.DataSource["MES"].Client;
            var data = db.Queryable<C_Stock_Pallet_T>()
                .WhereIF(!string.IsNullOrWhiteSpace(input.WorkOrder), i => i.STOCK_NO == input.WorkOrder).ToList();// 获取MES单号信息

            foreach (var item in data)
            {
                item.UP_FLAG = 0;
            }

            var db1 = Biz.DataSource["WMS57"].Client;// WMS数据库
            var dtlData = db1.Queryable<BIZ_ERP_PROD_IN_DTL>().Where(i => i.BILLCODE == input.WorkOrder).ToList();
            foreach (var item in dtlData)
            {
                item.INSTOCKQTY = 0;
            }

            var snData = db1.Queryable<BIZ_ERP_PROD_IN_SN>().Where(i => i.BUSINESSCODE == input.WorkOrder).ToList();
            try
            {
                BizSqlsugar.CreateTran(() =>
                {
                    BizSqlsugar.UpdateDataTable(data, db);// MES数据表状态复原
                    BizSqlsugar.UpdateDataTable(dtlData, db1);// WMS的DTL表入库数量复原
                    db1.Deleteable(snData).ExecuteCommand(); // 清除SN条码明细
                }, db1);
            }
            catch (Exception ex)
            {
                throw new Exception($"状态复原失败，请联系项目管理员！");
            }
            return s++;
        }
    }
}