using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Numerics;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Aliyun.OSS;
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using Mapster;
using Microsoft.AspNetCore.Http.HttpResults;
using SqlSugar;
using ZR.Model;
using ZR.Model.MES.wms;
using ZR.Model.MES.wms.Dto;
using ZR.Repository;
using ZR.Service.mes.wms.IService;
using ZR.Service.mes.wms_u8;
using ZR.Service.Utils;

namespace ZR.Service.mes.wms
{
    /// <summary>
    /// 出货单（物料+客户）Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IWmOutOrderService), ServiceLifetime = LifeTime.Transient)]
    public class WmOutOrderService : BaseService<WmOutOrder>, IWmOutOrderService
    {
        private NLog.Logger logger;

        public WmOutOrderService()
        {
            logger = NLog.LogManager.GetCurrentClassLogger();
        }

        /// <summary>
        /// 查询出货单（物料+客户）列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<WmOutOrderDto> GetList(WmOutOrderQueryDto parm)
        {
            var predicate = Expressionable
                .Create<WmOutOrder>()
                .AndIF(
                    !string.IsNullOrEmpty(parm.ShipmentNum),
                    it => it.ShipmentNum.Contains(parm.ShipmentNum)
                )
                .AndIF(
                    !string.IsNullOrEmpty(parm.CustomNo),
                    it => it.CustomNo.Contains(parm.CustomNo)
                )
                .AndIF(parm.Type > 0, it => it.Type == parm.Type)
                .AndIF(parm.Status > -1, it => it.Status == parm.Status)
                .AndIF(parm.Year > 0, it => it.Year == parm.Year)
                .AndIF(parm.Week > 0, it => it.Year == parm.Week)
                .AndIF(parm.Date > 0, it => it.Year == parm.Date);
            var response = Queryable()
                .Where(predicate.ToExpression())
                .OrderByDescending(it => it.CreatedTime)
                .ToPage<WmOutOrder, WmOutOrderDto>(parm);

            return response;
        }

        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="ShipmentNum"></param>
        /// <returns></returns>
        public WmOutOrder_material_num GetInfo(string ShipmentNum)
        {
            WmOutOrder WmOutOrderList = Context
                .Queryable<WmOutOrder>()
                .Where(it => it.ShipmentNum == ShipmentNum)
                .First();

            WmOutOrder_material_num wmOutOrderItem = null;

            if (WmOutOrderList != null)
            {
                wmOutOrderItem = WmOutOrderList.Adapt<WmOutOrder_material_num>();

                List<WmMaterialOutorder> moList = Context
                    .Queryable<WmMaterialOutorder>()
                    .Where(it => it.FkOutorderId == WmOutOrderList.ShipmentNum)
                    .ToList();

                if (moList != null && moList.Count > 0)
                {
                    List<WmMaterialQuery_stockQuantityDto2> Material_stock =
                        new List<WmMaterialQuery_stockQuantityDto2>();

                    foreach (var moItem in moList)
                    {
                        WmMaterial material = Context
                            .Queryable<WmMaterial>()
                            .Where(it => it.Id == moItem.FkMaterialId)
                            .First();
                        if (material != null)
                        {
                            WmMaterialQuery_stockQuantityDto2 dto2 =
                                material.Adapt<WmMaterialQuery_stockQuantityDto2>();
                            dto2.requireOutNum = moItem.OuthouseNum;
                            Material_stock.Add(dto2);
                        }
                    }
                    wmOutOrderItem.MaterialList = Material_stock;
                }
            }

            return wmOutOrderItem;
        }

        /// <summary>
        /// 获取出库单基础信息
        /// </summary>
        /// <param name="ShipmentNum"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WmOutOrderDto GetOutOrderInfo(string ShipmentNum)
        {
            throw new NotImplementedException();
        }
        /// <summary>
        /// 获取出库单物料信息
        /// </summary>
        /// <param name="ShipmentNum"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public PagedInfo<WmOutOrderMaterialDto> GetOutOrderMaterialList(string ShipmentNum)
        {
            throw new NotImplementedException();
        }
        /// <summary>
        /// 添加出货单（物料+客户）
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WmOutOrder AddOneOutOrder(WmOutOrder_materialDto parm)
        {
            throw new NotImplementedException();
        }
        /// <summary>
        /// 修改出货单（物料+客户）
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WmOutOrder UpdateOneOutOrder(WmOutOrder_materialDto parm)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 添加出货单（物料+客户）
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public WmOutOrder AddWmOutOrder(WmOutOrder_materialDto model)
        {
            try
            {
                Context.Ado.BeginTran();
                string today_id = "EG" + DateTime.Now.ToString("yyMMdd");
                string last_outorder_ShipmentNum = Context
                    .Queryable<WmOutOrder>()
                    .Where(it => it.ShipmentNum.StartsWith(today_id))
                    .Max(it => it.ShipmentNum);
                if (string.IsNullOrEmpty(last_outorder_ShipmentNum))
                {
                    model.ShipmentNum = today_id + "001";
                }
                else
                {
                    int flow =
                        int.Parse(
                            last_outorder_ShipmentNum.Substring(
                                last_outorder_ShipmentNum.Length - 3,
                                3
                            )
                        ) + 1;
                    model.ShipmentNum = today_id + flow.ToString("000");
                }
                WmOutOrder wmOutOrder = model.Adapt<WmOutOrder>();

                // 关联表也要新增
                if (model.MaterialList != null)
                {
                    if (model.MaterialList.Count > 0)
                    {
                        //TODO 新表插入
                        List<WmMaterialOutorder> materialOutorderList =
                            new List<WmMaterialOutorder>();
                        List<WmOutOrderMaterialRel> wmOutOrderMaterialRelList =
                            new List<WmOutOrderMaterialRel>();
                        foreach (var item in model.MaterialList)
                        {
                            WmMaterialOutorder materialOutorder = new WmMaterialOutorder();

                            materialOutorder.FkMaterialId = item.Id;
                            materialOutorder.FkOutorderId = model.ShipmentNum;
                            materialOutorder.OuthouseNum = item.requireOutNum;
                            materialOutorder.CreatedBy = model.CreatedBy;
                            materialOutorder.CreatedTime = DateTime.Now;
                            materialOutorderList.Add(materialOutorder);

                            WmOutOrderMaterialRel wmOutOrderMaterial = new WmOutOrderMaterialRel();
                            wmOutOrderMaterial.FkShipmentNum = model.ShipmentNum;
                            wmOutOrderMaterial.FkMaterialCode = item.Partnumber;
                            wmOutOrderMaterial.Number = item.requireOutNum;
                            wmOutOrderMaterialRelList.Add(wmOutOrderMaterial);
                        }
                        ;
                        int result = Context.Insertable(materialOutorderList).ExecuteCommand();
                        int result2 = Context
                            .Insertable(wmOutOrderMaterialRelList)
                            .ExecuteCommand();
                    }
                }
                Context.Ado.CommitTran();
                return Context.Insertable(wmOutOrder).ExecuteReturnEntity();
            }
            catch (Exception)
            {
                Context.Ado.RollbackTran();
                return null;
            }
        }

        /// <summary>
        /// 删除出货单关联的物料出货单
        /// </summary>
        /// <param name="primarys"></param>
        /// <returns></returns>
        public int Delete_fk_matrial(string[] primarys)
        {
            if (primarys.Count() > 0)
            {
                for (int i = 0; i < primarys.Length; i++)
                {
                    Context
                        .Deleteable<WmMaterialOutorder>()
                        .Where(it => it.FkOutorderId == primarys[i])
                        .ExecuteCommand();
                }
            }
            return 1;
        }

        /// <summary>
        /// 修改出货单（物料+客户）
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateWmOutOrder(WmOutOrder model)
        {
            //var response = Update(w => w.ShipmentNum == model.ShipmentNum, it => new WmOutOrder()
            //{
            //    CustomNo = model.CustomNo,
            //    CustomName = model.CustomName,
            //    CustomAddress = model.CustomAddress,
            //    Remarks = model.Remarks,
            //    Type = model.Type,
            //    Status = model.Status,
            //    Year = model.Year,
            //    Week = model.Week,
            //    Date = model.Date,
            //    CreatedBy = model.CreatedBy,
            //    CreatedTime = model.CreatedTime,
            //    UpdatedBy = model.UpdatedBy,
            //    UpdatedTime = model.UpdatedTime,
            //});
            //return response;
            return Update(model, true);
        }

        /// <summary>
        /// 获取用户信息
        /// </summary>
        /// <returns></returns>
        public List<WmCustom> GetCustominfo()
        {
            return Context.Queryable<WmCustom>().ToList();
        }

        /// <summary>
        /// 查询物料记录表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public (List<WmMaterialQuery_stockQuantityDto>, int) GetmaterialList(
            WmMaterialQueryDto parm
        )
        {
            int total = 0;
            var predicate = Expressionable
                .Create<WmMaterial>()
                .AndIF(parm.Partnumber != null, it => it.Partnumber.Contains(parm.Partnumber))
                .AndIF(
                    parm.U8InventoryCode != null,
                    it => it.U8InventoryCode.Contains(parm.U8InventoryCode)
                )
                .AndIF(parm.ProductName != null, it => it.ProductName.Contains(parm.ProductName))
                .AndIF(parm.Color != null, it => it.Color.Contains(parm.Color))
                .AndIF(
                    parm.Specification != null,
                    it => it.Specification.Contains(parm.Specification)
                )
                .AndIF(parm.Description != null, it => it.Description.Contains(parm.Description))
                .AndIF(
                    parm.Search1 != null,
                    it => it.Search1.Contains(parm.Search1) || it.Search2.Contains(parm.Search1)
                )
                .AndIF(parm.Status > -1, it => it.Status == parm.Status);

            List<WmMaterial> materialList = Context
                .Queryable<WmMaterial>()
                .Where(predicate.ToExpression())
                .OrderByDescending(it => it.CreatedTime)
                .ToPageList(parm.PageNum, parm.PageSize, ref total);

            List<WmMaterialQuery_stockQuantityDto> material_stockQuantity_list =
                new List<WmMaterialQuery_stockQuantityDto>();

            if (materialList.Count > 0)
            {
                foreach (WmMaterial item in materialList)
                {
                    WmMaterialQuery_stockQuantityDto wmMaterialQuery_Stock_item =
                        item.Adapt<WmMaterialQuery_stockQuantityDto>();

                    int material_num = 0;
                    List<WmGoodsNowProduction> productioList = Context
                        .Queryable<WmGoodsNowProduction>()
                        .Where(it => it.Partnumber == item.Partnumber)
                        .ToList();

                    if (productioList.Count > 0)
                    {
                        foreach (var product in productioList)
                        {
                            int num = product.GoodsNumAction ?? 0;
                            material_num += num;
                        }
                    }

                    wmMaterialQuery_Stock_item.stockQuantity = material_num;
                    material_stockQuantity_list.Add(wmMaterialQuery_Stock_item);
                }
            }
            return (material_stockQuantity_list, total);
        }

        /// <summary>
        /// 查询出货单的物料信息
        /// </summary>
        /// <param name="shipment_num"></param>
        /// <returns></returns>
        public List<WmMaterialQuery_print> Queryoutoder_matrials(string shipment_num)
        {
            List<WmMaterialQuery_print> stockList = Context
                .Queryable<WmMaterialOutorder>()
                .LeftJoin<WmMaterial>((mo, m) => mo.FkMaterialId == m.Id)
                .Where(mo => mo.FkOutorderId == shipment_num)
                .Select(
                    (mo, m) =>
                        new WmMaterialQuery_print()
                        {
                            //物料号
                            Partnumber = m.Partnumber,
                            // 描述
                            ProductName = m.ProductName,
                            //需求零件数
                            RequireOutNum = mo.OuthouseNum
                        }
                )
                .ToList();

            if (stockList != null && stockList.Count > 0)
            {
                foreach (var stock in stockList)
                {
                    //库存箱数
                    stock.PackageNum = Context
                        .Queryable<WmGoodsNowProduction>()
                        .Where(it => it.Partnumber == stock.Partnumber)
                        .Count();

                    //库存零件数
                    int? num = Context
                        .Queryable<WmGoodsNowProduction>()
                        .Where(it => it.Partnumber == stock.Partnumber)
                        .Sum(it => it.GoodsNumAction);
                    stock.ItemNum = num ?? 0;

                    // 需求箱数
                    List<WmGoodsNowProduction> list = Context
                        .Queryable<WmGoodsNowProduction>()
                        .Where(it => it.Partnumber == stock.Partnumber)
                        .OrderByDescending(it => it.PackageCodeClient)
                        .ToList();

                    int sum = 0;
                    foreach (var item in list)
                    {
                        sum = sum + item.GoodsNumLogic ?? 0;
                        if (sum >= stock.RequireOutNum)
                        {
                            stock.Require_pack_num = list.IndexOf(item) + 1;
                            break;
                        }
                    }
                }
            }

            return stockList;
        }

        /// <summary>
        /// 生成出库单的出货计划
        /// </summary>
        /// <param name="shipment_num">出货单号</param>
        /// <returns></returns>
        public List<WmOutOrderPlan> Generate_outorderplan(string shipment_num)
        {
            // 最终结果
            List<WmOutOrderPlan> planList = new List<WmOutOrderPlan>();
            // 获取当前出货单下的物料信息
            List<WmMaterialQuery_print> materialQuery_Prints = this.Queryoutoder_matrials(
                shipment_num
            );
            if (materialQuery_Prints != null && materialQuery_Prints.Count > 0)
            {
                // 物料解析
                foreach (var material in materialQuery_Prints)
                {
                    //1. 物料需求量
                    int require_num = material.RequireOutNum;
                    // 物料号
                    string partnumber = material.Partnumber;
                    // 该物料下 ，现有货物列表，零件号相同，根据批次号从小到大排序
                    List<WmGoodsNowProduction> wmGoodsNowsList = Context
                        .Queryable<WmGoodsNowProduction>()
                        .Where(it => it.Partnumber == partnumber)
                        .Where(it => it.LocationCode != "Z1-01")
                        .OrderBy(it => it.PackageCodeClient)
                        .ToList();

                    // 判断要出多少批次的货
                    List<WmOutOrderPlan> wmOutOrderPlans = new List<WmOutOrderPlan>();
                    // 当前累计批次货物总数
                    int accumulation_num = 0;
                    foreach (var witem in wmGoodsNowsList)
                    {
                        //TODO 修改>= 为 > 查看情况
                        if (require_num > accumulation_num)
                        {
                            WmOutOrderPlan orderPlan = new WmOutOrderPlan();
                            orderPlan.FkOutOrderId = shipment_num;
                            orderPlan.Patchcode = witem.PackageCodeClient;
                            orderPlan.Patchcode_short = witem.PackageCodeClient.Split("_")[0];
                            orderPlan.MaterialCode = witem.Partnumber;
                            orderPlan.WarehouseCode = witem.LocationCode;
                            orderPlan.PackageNum = material.PackageNum;
                            // 获得批次的总零件数
                            orderPlan.PartnumberNum = witem.GoodsNumLogic;
                            orderPlan.RequireNum = require_num;
                            orderPlan.ReceivedPackNum = 0;
                            orderPlan.Patchtime = Resolution_bath(witem.PackageCodeOriginal);
                            wmOutOrderPlans.Add(orderPlan);
                            // 实际值计算
                            accumulation_num = accumulation_num + witem.GoodsNumLogic ?? 0;
                        }
                    }
                    // 进行聚合
                    if (wmOutOrderPlans.Count > 0)
                    {
                        // 根据批次号下划线前进行聚合
                        List<WmOutOrderPlan> material_plan_item = wmOutOrderPlans
                            .GroupBy(it => it.Patchcode_short)
                            .Select(g => new WmOutOrderPlan
                            {
                                FkOutOrderId = g.Max(p => p.FkOutOrderId),
                                Patchcode = g.Max(p => p.Patchcode_short),
                                Patchcode_short = g.Max(p => p.Patchcode_short),
                                WarehouseCode = g.Max(p => p.WarehouseCode),
                                MaterialCode = g.Max(p => p.MaterialCode),
                                PackageNum = g.Count(),
                                PartnumberNum = g.Sum(p => p.PartnumberNum),
                                RequireNum = g.Max(p => p.RequireNum),
                                ReceivedPackNum = 0,
                                Patchtime = g.Max(p => p.Patchtime),
                            })
                            .ToList();

                        planList = planList.Concat(material_plan_item).ToList();
                    }
                }
            }
            // 添加序号
            int count = 1;
            foreach (var witem in planList)
            {
                witem.Id = count;
                witem.Outorder = count;

                count++;
                witem.Inventory_pack_num = Context
                    .Queryable<WmGoodsNowProduction>()
                    .Where(it => it.PackageCodeClient.Contains(witem.Patchcode))
                    .Count();
                witem.Inventory_num =
                    Context
                        .Queryable<WmGoodsNowProduction>()
                        .Where(it => it.PackageCodeClient.Contains(witem.Patchcode))
                        .Sum(it => it.GoodsNumLogic) ?? 0;
            }

            return planList;
        }

        /// <summary>
        /// 货物出库处理：添加出库记录 + 删除成品库数据
        /// </summary>
        /// <param name="doMaterialOut">出库请求DTO</param>
        /// <param name="createBy">操作人</param>
        /// <returns>(删除的成品库条数, 插入的出库记录条数)</returns>
        public (int, int) DoMaterialOut(WmDoMaterialOut_Dto doMaterialOut, string createBy)
        {
            Console.WriteLine("开始执行货物出库处理" + DateTime.Now.ToString());
            if (doMaterialOut == null)
                throw new ArgumentNullException(nameof(doMaterialOut), "出库请求数据不能为空");
            createBy = createBy?? "填充出库人";

            string shipmentNum = doMaterialOut.ShipmentNum;
            string[] originalPatchCodes = doMaterialOut.PatchCode ?? Array.Empty<string>();

            // 基础校验
            if (originalPatchCodes.Length == 0)
                throw new Exception("批次号列表为空，无法执行出库操作");

            // 批次号去重（避免重复处理）
            HashSet<string> uniquePatchSet = new HashSet<string>(originalPatchCodes);
            string[] uniquePatchCodes = uniquePatchSet.ToArray();
            if (uniquePatchCodes.Length != originalPatchCodes.Length)
            {
                string duplicates = string.Join(",", originalPatchCodes.Except(uniquePatchCodes));
                logger.Warn($"出库批次号存在重复，已去重：{duplicates}");
            }

            #region 1. 批量查询（修复字典报错）
            // 1.1 查询成品库数据（避免重复键和null键）
            List<WmGoodsNowProduction> goodsList = Context
                .Queryable<WmGoodsNowProduction>()
                .Where(g => uniquePatchCodes.Contains(g.PackageCodeClient)
                         && !string.IsNullOrEmpty(g.PackageCodeClient)) // 过滤null键
                .ToList();

            // 处理重复的PackageCodeClient（保留第一条）
            Dictionary<string, WmGoodsNowProduction> goodsDict = goodsList
                .GroupBy(g => g.PackageCodeClient)
                .ToDictionary(
                    group => group.Key,
                    group => group.First() // 重复时取第一条
                );

            // 1.2 校验不存在的批次号
            List<string> notExistsCodes = uniquePatchCodes
                .Where(code => !goodsDict.ContainsKey(code))
                .ToList();
            if (notExistsCodes.Any())
                throw new Exception($"成品库未查询到以下批次号：{string.Join(",", notExistsCodes)}");

            // 1.3 暂不批量更新出库计划

            // 1.4 查询客户编号
            string customerCode = Context
                .Queryable<WmOutOrder>()
                .Where(order => order.ShipmentNum == shipmentNum)
                .Select(order => order.CustomNo)
                .First() ?? "无客户代码";
            #endregion

            #region 2. 构建出库数据（内存操作）
            List<WmGoodsOutRecord> outRecordList = new List<WmGoodsOutRecord>();
            List<string> goodsToDeleteIds = new List<string>();
            HashSet<string> partNumbers = new HashSet<string>();
            int totalPackage = 0;
            int totalPartCount = 0;
            List<string> packageRemarkList = new List<string>();

            foreach (string patchCode in uniquePatchCodes)
            {
                if (!goodsDict.TryGetValue(patchCode, out WmGoodsNowProduction goods))
                    continue; // 已校验，理论上不会进入

                // 构建出库记录
                var outRecord = new WmGoodsOutRecord
                {
                    Id = SnowFlakeSingle.Instance.NextId().ToString(),
                    FkNowProductionId = goods.Id,
                    PackageCodeClient = goods.PackageCodeClient,
                    PackageCode = goods.PackageCode,
                    PackageCodeOriginal = goods.PackageCodeOriginal,
                    LocationCode = goods.LocationCode,
                    Partnumber = goods.Partnumber,
                    GoodsNumLogic = goods.GoodsNumLogic,
                    GoodsNumAction = goods.GoodsNumAction ?? 0,
                    EntryWarehouseTime = goods.EntryWarehouseTime,
                    OutTime = DateTime.Now,
                    CreatedBy = createBy,
                    CreatedTime = DateTime.Now,
                    FkOutOrderId = shipmentNum
                };

                // 统计信息
                outRecordList.Add(outRecord);
                goodsToDeleteIds.Add(goods.Id);
                totalPackage++;
                partNumbers.Add(goods.Partnumber);
                totalPartCount += outRecord.GoodsNumAction.Value;
                packageRemarkList.Add(patchCode);
            }
            packageRemarkList.Sort();
            #endregion

            #region 3. 事务内核心操作（修复返回结果不一致）
            int finalDeleteCount = 0;
            int finalInsertCount = 0;

            Context.Ado.BeginTran();
            try
            {
                // 3.1 批量插入出库记录
                finalInsertCount = Context.Insertable(outRecordList).ExecuteCommand();
                if (finalInsertCount != outRecordList.Count)
                    throw new Exception($"出库记录插入异常：预期{outRecordList.Count}条，实际{finalInsertCount}条");

                // 3.2 批量删除成品库数据
                finalDeleteCount = Context
                    .Deleteable<WmGoodsNowProduction>()
                    .In(goodsToDeleteIds)
                    .ExecuteCommand();
                if (finalDeleteCount != goodsToDeleteIds.Count)
                    throw new Exception($"成品库删除异常：预期{goodsToDeleteIds.Count}条，实际{finalDeleteCount}条");

                // 3.3 插入操作日志
                var operationLog = new WmGoodsRecord
                {
                    Id = SnowFlakeSingle.Instance.NextId().ToString(),
                    FkInventoryId = SnowFlakeSingle.Instance.NextId().ToString(),
                    Code = "DoMaterialOut",
                    Partnumber = partNumbers.FirstOrDefault() ?? "无零件号",
                    ChangeType = 2,
                    ChangePackage = totalPackage,
                    ChangeQuantity = totalPartCount,
                    ActionTime = DateTime.Now,
                    Status = 1,
                    Remark =
                    "货物出库"
                    + "\n出库单:"
                    + shipmentNum
                    + "\n零件号:"
                    + string.Join(',', partNumbers)
                    + "\n总箱数:"
                    + totalPackage
                    + "\n总零件数:"
                    + totalPartCount
                    + "\n涉及批次号:\n"
                    + string.Join(',', uniquePatchCodes)
                    + $"\n处理：插入{ finalInsertCount }条，删除{ finalDeleteCount }条",
                    CreatedBy = createBy,
                    CreatedTime = DateTime.Now
                };
                int logResult = Context.Insertable(operationLog).ExecuteCommand();
                if (logResult == 0)
                    throw new Exception("操作日志插入失败");

                Context.Ado.CommitTran();
                Console.WriteLine($"出库成功：删除{finalDeleteCount}条，插入{finalInsertCount}条");
                logger.Info($"出库成功：删除{finalDeleteCount}条，插入{finalInsertCount}条");
            }
            catch (Exception ex)
            {
                Context.Ado.RollbackTran();
                logger.Error($"出库事务回滚：{ex.Message}", ex);
                throw;
            }
            finally
            {
                Context.Ado.Dispose();
            }
            #endregion

            #region 4. 异步发送U8
            _ = Task.Run(async () =>
            {
                try
                {
                    // U8发送逻辑（保持不变）
                    var u8Data = outRecordList.Select(record => new ERP_WMS_interactiveModelQuery
                    {
                        customerCode = customerCode,
                        materialCode = record.Partnumber,
                        location = record.LocationCode,
                        Qty = record.GoodsNumLogic.ToString(),
                        LotNo = DateTime.Now.ToString("yyyyMMdd"), // 简化日期处理
                        userID = createBy,
                        lineno = "涂装生产线",
                        guid = Guid.NewGuid().ToString(),
                        createTime = DateTime.Now
                    }).ToList();

                    var result = await new ERP_WMS_interactiveService()
                        .OutboundedAsync("http://gam.com.cn:8053/", u8Data);
                    logger.Info($"U8同步结果：{result}");
                }
                catch (Exception ex)
                {
                    logger.Error($"U8同步失败：{ex.Message}", ex);
                }
            });
            #endregion

            return (finalDeleteCount, finalInsertCount);
        }

        public bool OverOutorderplan(string shipment_num)
        {
            int reult = Context
                .Updateable<WmOutOrder>()
                .Where(it => it.ShipmentNum == shipment_num)
                .SetColumns(it => it.Type == 2)
                .ExecuteCommand();
            if (reult > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 传入批次号 解析出时间   BNW240318007_105
        /// </summary>
        /// <param name="production_packcode">原始编码</param>
        /// <returns></returns>
        private string Resolution_bath(string production_packcode)
        {
            MaterialUtils materialToos = new MaterialUtils();
            ResultionPackageCodeDto resultionPackage = materialToos.ResolutionPackage(
                production_packcode
            );
            if (resultionPackage == null)
            {
                return "时间解析异常";
            }
            return resultionPackage.ProductionTime;
        }

        /// <summary>
        ///  8.5 PDA端 获取出库单的持久化存储出库计划并计算计划批次当前已出库数量
        /// </summary>
        /// <param name="shipment_num">出库单号</param>
        /// <returns></returns>
        public List<WmOutPlanAndGoodsOutProductionNumDto> GetOutOrderPlanAndOutProductionNum(
            string shipment_num,
            string partnumber
        )
        {
            try
            {
                List<WmOutPlanAndGoodsOutProductionNumDto> result = new();
                // 当前工单出库计划
                var exp = Expressionable
                    .Create<WmOutOrderPlan>()
                    .And(it => it.FkOutOrderId == shipment_num)
                    .AndIF(!string.IsNullOrEmpty(partnumber), it => it.MaterialCode == partnumber)
                    .ToExpression();
                List<WmOutOrderPlan> wmOutOrderPlan = Context
                    .Queryable<WmOutOrderPlan>()
                    .Where(exp)
                    .OrderBy(it => it.Outorder)
                    .ToList();
                // 查询每个计划具体出库数据
                foreach (WmOutOrderPlan item in wmOutOrderPlan)
                {
                    // 库存记录
                    List<WmGoodsNowProduction> nowProductionList = Context
                        .Queryable<WmGoodsNowProduction>()
                        .Where(it => it.PackageCodeClient.Contains(item.Patchcode))
                        .ToList();
                    int nowPackageNum = 0;
                    int nowPartnumberNum = 0;
                    foreach (WmGoodsNowProduction outItem in nowProductionList)
                    {
                        nowPackageNum += 1;
                        nowPartnumberNum += (int)outItem.GoodsNumAction;
                    }
                    // 出库记录
                    List<WmGoodsOutRecord> outPackageList = Context
                        .Queryable<WmGoodsOutRecord>()
                        .Where(it => it.PackageCodeClient.Contains(item.Patchcode))
                        .Where(it => it.FkOutOrderId == shipment_num)
                        .ToList();
                    int outPackageNum = 0;
                    int outPartnumberNum = 0;
                    foreach (WmGoodsOutRecord outItem in outPackageList)
                    {
                        outPackageNum += 1;
                        outPartnumberNum += (int)outItem.GoodsNumAction;
                    }
                    WmMaterial material = Context
                        .Queryable<WmMaterial>()
                        .Where(it => it.Partnumber.Contains(item.MaterialCode))
                        .First();
                    WmOutPlanAndGoodsOutProductionNumDto newItem =
                        new()
                        {
                            OutOrder = (int)item.Outorder,
                            PackageCode = item.Patchcode,
                            Partnumber = item.MaterialCode,
                            Description = !string.IsNullOrEmpty(material.Description)
                                ? material.Description
                                : material.ProductName,
                            WarehouseCode = item.WarehouseCode,
                            RequireNum = (int)item.RequireNum,
                            PackageNum = (int)nowPackageNum,
                            PartnumberNum = (int)nowPartnumberNum,
                            PackagePlanNum = (int)item.PackageNum,
                            PartnumberPlanNum = (int)item.PartnumberNum,
                            OutPackageNum = outPackageNum,
                            OutPartnumberNum = outPartnumberNum,
                            IsError = (nowPartnumberNum + outPartnumberNum) != item.PartnumberNum,
                            IsOver = outPartnumberNum > item.PartnumberNum
                        };
                    result.Add(newItem);
                }
                return result;
            }
            catch (Exception)
            {
                return null;
            }
        }

        /// <summary>
        /// 检查是否可出库
        /// </summary>
        /// <param name="production_packcode"></param>
        /// <param name="shipment_num"></param>
        /// <returns></returns>
        public string CheckProductionOut(
            string parnumber,
            string production_packcode,
            string shipment_num
        )
        {
            try
            {
                if (shipment_num == "" || production_packcode == "")
                {
                    return "传入数据为空！请检查参数";
                }

                // 1.判断工单是否处于已完成状态
                bool isOutOrderCanUse = Context
                    .Queryable<WmOutOrder>()
                    .Where(it => it.ShipmentNum == shipment_num)
                    .Where(it => it.Type == 1)
                    .Any();
                if (!isOutOrderCanUse)
                {
                    return "出库单已完成或已弃用！请检查出库单";
                }

                MaterialUtils materialToos = new MaterialUtils();
                // 2.解析标签编码
                ResultionPackageCodeDto resultionPackage = materialToos.ResolutionPackage(
                    production_packcode
                );
                if (resultionPackage == null)
                {
                    return "标签解析异常！请检查标签";
                }
                //3 判断箱子是否配置零件号
                string checkPartnumber = resultionPackage.PartNumner;
                // 使用正则表达式匹配并移除特殊后缀
                string processedPartnumber = Regex.Replace(
                    checkPartnumber,
                    @"-(FL|FR|RR|RL)$",
                    "",
                    RegexOptions.IgnoreCase
                );

                if (parnumber != processedPartnumber)
                {
                    return "此箱子不是选择的物料号";
                }

                // 3.1判断是否已入库
                bool isExistedWarehouse = Context
                    .Queryable<WmGoodsNowProduction>()
                    .Where(it => it.PackageCodeClient == resultionPackage.PatchCode)
                    .Any();
                if (!isExistedWarehouse)
                {
                    return "该箱号未入库！请先入库";
                }
                // 3.2 判断是否是计划中的物料(大概率不执行)
                bool flag1 = false;
                List<WmMaterial> materialOutorders = Context
                    .Queryable<WmMaterialOutorder>()
                    .LeftJoin<WmMaterial>((wmo, wm) => wmo.FkMaterialId == wm.Id)
                    .Where(wmo => wmo.FkOutorderId == shipment_num)
                    .Select((wmo, wm) => new WmMaterial { Partnumber = wm.Partnumber })
                    .ToList();
                foreach (WmMaterial materialOption in materialOutorders)
                {
                    if (
                        materialOption.Partnumber == processedPartnumber
                        || materialOption.Partnumber == checkPartnumber
                    )
                    {
                        flag1 = true;
                    }
                }
                if (!flag1)
                {
                    return "该箱标签物料号不在出库单物料清单内！";
                }
                // 4. 判断出库单是否启用出库规则
                var shipment = Context
                    .Queryable<WmOutOrder>()
                    .Where(it => it.ShipmentNum == shipment_num)
                    .First();
                if (shipment.Status == 0)
                {
                    return "ok";
                }
                // 5.  确保出最早批次
                string short_path = resultionPackage.PatchCode.Split('_')[0];
                // 严格规则(出库规则判断)
                return CheckRuleJudgmentFirstInFirstOut(shipment_num, short_path, parnumber);
                /*WmOutOrderPlan plan_item = Context.Queryable<WmOutOrderPlan>()
                         .Where(it => it.FkOutOrderId == shipment_num)
                         .Where(it => it.Patchcode == short_path)
                         .OrderBy(it => it.Outorder)
                         .First();

                if (plan_item != null)
                {
                    // 查看此批次号在此工单下已出库箱子数量
                    int patchInNum = Context.Queryable<WmGoodsOutRecord>()
                         .Where(it => it.PackageCodeClient.Contains(short_path))
                         .Where(it => it.FkOutOrderId == shipment_num)
                         .Count();
                    var plan_earliest = Context.Queryable<WmOutOrderPlan>()
                    .Where(it => it.FkOutOrderId == shipment_num)
                    .Where(it => it.MaterialCode == plan_item.MaterialCode)
                    .Where(it => it.PackageNum > patchInNum)
                    .OrderBy(it => it.Outorder)
                    .First();
                    //已经出库完成，没有可以出库的了
                    if (plan_earliest == null)
                    {
                        return "此物料在计划中已经全部出库完成,无法继续出库";
                    }
                    // 批次号是最早批次
                    */
                /*if (plan_earliest.Id == plan_item.Id)
                                    {
                                        return "ok";
                                    }*/
                /*
                                    if (plan_earliest.Patchcode == short_path)
                                    {
                                        return "ok";
                                    }
                                    else
                                    {
                                        return "不是此物料最早批次，无法出库";
                                    }
                                }*/
                //  6 .还差一个  数量超过要出库的箱子
                return "此箱标签不可出库，批次号不在出库单计划内！请检查出库单计划！";
            }
            catch (Exception)
            {
                return "此箱标签存在异常不可出库！";
            }
        }

        /// <summary>
        /// 持久化存储
        /// </summary>
        /// <param name="shipment_num"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public int PersistenceOutorderplan(string shipment_num)
        {
            List<WmOutOrderPlan> orderPlans = Generate_outorderplan(shipment_num);

            var x = Context
                .Storageable(orderPlans)
                .WhereColumns(it => it.FkOutOrderId)
                .WhereColumns(it => it.MaterialCode)
                .WhereColumns(it => it.Patchcode)
                .ToStorage();
            int result = x.AsInsertable.ExecuteCommand(); //执行插入
            x.AsUpdateable.ExecuteCommand(); //执行更新　
            return result;
        }

        /// <summary>
        /// 出库单先进先出规则判断(严格复杂版)
        /// </summary>
        /// <param name="shipment_num">工单号</param>
        /// <param name="shortPackageCode">短批次号</param>
        /// <returns> "ok" 代表通过，其余返回错误提示</returns>
        /// <exception cref="NotImplementedException"></exception>
        public string CheckRuleJudgmentFirstInFirstOut(
            string shipment_num,
            string shortPackageCode,
            string parnumber
        )
        {
            // 1.检查是否有记录
            var exp1 = Expressionable
                .Create<WmOutOrderPlan>()
                .And(it => it.FkOutOrderId == shipment_num)
                .And(it => it.Patchcode == shortPackageCode)
                .ToExpression();
            bool hasRecord = Context.Queryable<WmOutOrderPlan>().Where(exp1).Any();
            if (!hasRecord)
            {
                return "此批次号不在出库单计划中！";
            }

            // 1.取出出库单计划
            List<WmOutOrderPlan> plans = Context
                .Queryable<WmOutOrderPlan>()
                .Where(it => it.FkOutOrderId == shipment_num)
                .OrderBy(it => it.Outorder)
                .ToList();
            foreach (WmOutOrderPlan plan in plans)
            {
                // 不是同零件号的跳过
                if (plan.MaterialCode != parnumber)
                {
                    continue;
                }
                // 2.此出库单下的批次号的已出库记录
                var exp2 = Expressionable
                    .Create<WmGoodsOutRecord>()
                    .And(it => it.PackageCodeClient.Contains(plan.Patchcode))
                    .And(it => it.Partnumber == plan.MaterialCode)
                    .And(it => it.FkOutOrderId == shipment_num)
                    .ToExpression();
                List<WmGoodsOutRecord> outPackageList = Context
                    .Queryable<WmGoodsOutRecord>()
                    .Where(exp2)
                    .ToList();
                int outPackageNum = 0;
                int outPartnumberNum = 0;
                foreach (WmGoodsOutRecord outItem in outPackageList)
                {
                    outPackageNum += 1;
                    outPartnumberNum += (int)outItem.GoodsNumAction;
                }
                // 按顺序检查是否出完
                if (plan.Patchcode != shortPackageCode)
                {
                    // 此批次是否还有库存
                    bool hasAny = Context
                        .Queryable<WmGoodsNowProduction>()
                        .Where(it => it.PackageCodeClient.Contains(plan.Patchcode))
                        .Where(it => it.Partnumber == plan.MaterialCode)
                        .Any();
                    // 检查此批次是否出完
                    if (outPartnumberNum >= plan.RequireNum || !hasAny)
                    {
                        // 出完了或仓库里没了
                        continue;
                    }
                    else
                    {
                        return "不是出库单计划中此物料的最早批次，无法出库! 计划中批次:" + plan.Patchcode + "未出完！";
                    }
                }
                else
                {
                    // 检查此批次是否出完
                    if (outPartnumberNum < plan.RequireNum)
                    {
                        return "ok";
                    }
                    else
                    {
                        // 出完了
                        return "此批次已在出库计划中出完! 当前已出库:" + outPartnumberNum + "个零件！";
                    }
                }
            }
            return "经检查，此批次号不在出库单计划中！";
        }

        public PagedInfo<WmPDAOutOrderListDto> GetPdaOutOrderPageList(
            WmPDAOutOrderPageQueryDto parm
        )
        {
            // 根据type和shipmentNum查询出库单列表
            var query = Context
                .Queryable<WmOutOrder>()
                .WhereIF(!string.IsNullOrEmpty(parm.Type), it => it.Type == int.Parse(parm.Type))
                .WhereIF(
                    !string.IsNullOrEmpty(parm.ShipmentNum),
                    it => it.ShipmentNum.Contains(parm.ShipmentNum)
                );

            // 查询结果并映射到WmPDAOutOrderListDto
            var result = query
                .Select(it => new WmPDAOutOrderListDto
                {
                    ShipmentNum = it.ShipmentNum,
                    CustomName = it.CustomName,
                    Type = it.Type,
                    Status = it.Status
                })
                .OrderByDescending(it => it.ShipmentNum)
                .ToPage(parm);

            return result;
        }

        public PagedInfo<WmPDAOutPlanListDto> GetPdaOutOrderPlanPageList(
            WmPDAOutOrderPlanPageQueryDto parm
        )
        {
            // 当前工单出库计划
            var exp = Expressionable
                .Create<WmOutOrderPlan>()
                .And(it => it.FkOutOrderId == parm.ShipmentNum)
                .AndIF(
                    !string.IsNullOrEmpty(parm.MaterialCode),
                    it => it.MaterialCode == parm.MaterialCode
                )
                .ToExpression();

            // 查询出库计划，并关联物料、库存和出库记录
            // 使用子查询选择每个零件号的最新记录的描述
            var query = Context
                .Queryable<WmOutOrderPlan>()
                .Where(exp)
                .Select(plan => new WmPDAOutPlanListDto
                {
                    ShipmentNum = plan.FkOutOrderId,
                    MaterialCode = plan.MaterialCode,
                    BatchCode = plan.Patchtime,
                    WarehouseCode = plan.WarehouseCode,
                    PlanOutNumber = plan.PartnumberNum.Value,
                    PlanOutPackage = plan.PackageNum.Value,
                    Description = ""
                });
            // 分页查询
            var result = query
                .OrderBy(dto => dto.BatchCode) // 根据需要调整排序
                .ToPage(parm);
            foreach (var item in result.Result)
            {
                WmPDAOutOnePlanActualDataDto actualData = GetPdaOutOrderPlanActualData(
                    item.ShipmentNum,
                    item.MaterialCode,
                    item.BatchCode
                );
                var material = Context
                    .Queryable<WmMaterial>()
                    .Where(m => m.Partnumber == item.MaterialCode && m.Status == 1 && m.Type == 1)
                    .First();
                if(material == null)
                {
                    item.Description = "无描述";
                }
                else
                {
                    item.Description = material.Description;
                }
                item.InventoryNumber = actualData.InventoryNumber;
                item.ActualOutNumber = actualData.ActualOutNumber;
                item.InventoryPackage = actualData.InventoryPackage;
                item.ActualOutPackage = actualData.ActualOutPackage;
            }

            return result;
        }

        /// <summary>
        /// 处理BatchCode，去除前两位多余字符
        /// </summary>
        /// <param name="batchCode">原始BatchCode</param>
        /// <returns>处理后的BatchCode</returns>
        private string ProcessBatchCode(string batchCode)
        {
            if (string.IsNullOrEmpty(batchCode) || batchCode.Length <= 2)
            {
                return batchCode;
            }
            return batchCode.Substring(2);
        }

        public WmPDAOutOnePlanActualDataDto GetPdaOutOrderPlanActualData(
            string shipmentNum,
            string materialCode,
            string batchCode
        )
        {
            // 处理BatchCode，去除前两位多余字符
            string processedBatchCode = ProcessBatchCode(batchCode);

            // 零件该批次库存箱数和库存零件数
            var nowProductionQuery = Context
                .Queryable<WmGoodsNowProduction>()
                .Where(it =>
                    it.Partnumber == materialCode && it.PackageCodeClient.Contains(processedBatchCode)
                );

            var nowProductionData = new {
                PackageCount = nowProductionQuery.Count(),
                PartNumberSum = nowProductionQuery.Sum(it => it.GoodsNumAction) ?? 0
            };

            // 该零件出库箱数和出库数量
            var outRecordQuery = Context
                .Queryable<WmGoodsOutRecord>()
                .Where(it =>
                    it.FkOutOrderId == shipmentNum
                    && it.Partnumber == materialCode
                    && it.PackageCodeClient.Contains(processedBatchCode)
                );

            var outRecordData = new {
                PackageCount = outRecordQuery.Count(),
                PartNumberSum = outRecordQuery.Sum(it => it.GoodsNumAction) ?? 0
            };

            WmPDAOutOnePlanActualDataDto result =
                new()
                {
                    ShipmentNum = shipmentNum,
                    MaterialCode = materialCode,
                    BatchCode = batchCode,
                    InventoryNumber = nowProductionData.PartNumberSum,
                    ActualOutNumber = outRecordData.PartNumberSum,
                    InventoryPackage = nowProductionData.PackageCount,
                    ActualOutPackage = outRecordData.PackageCount
                };
            return result;
        }

        public List<string> GetPdaOutOrderPlanOptions(string shipmentNum)
        {
            // 当前工单出库计划
            var exp = Expressionable
                .Create<WmOutOrderPlan>()
                .And(it => it.FkOutOrderId == shipmentNum)
                .ToExpression();

            // 查询出库计划，并关联物料、库存和出库记录
            // 使用子查询选择每个零件号的最新记录的描述
            var result = Context
                .Queryable<WmOutOrderPlan>()
                .Where(exp)
                .OrderBy(it => it.Outorder)
                .Select(it => it.MaterialCode)
                .Distinct()
                .ToList();
            return result;
        }

        public bool UpdatePdaOutOrderPlan(string shipmentNum)
        {
            return PersistenceOutorderplan(shipmentNum) > 0;
        }

        /// <summary>
        /// 高性能PDA出库方法
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public string PdaOutboundByOutOrderPlan(WmPDAOutboundDto parm)
        {
            // 输入验证
            if (parm == null)
            {
                throw new ArgumentNullException(nameof(parm), "参数不能为空");
            }

            if (string.IsNullOrEmpty(parm.Operator))
            {
                throw new ArgumentException("操作员不能为空", nameof(parm.Operator));
            }

            if (string.IsNullOrEmpty(parm.ShipmentNum))
            {
                throw new ArgumentException("出库单号不能为空", nameof(parm.ShipmentNum));
            }

            if (string.IsNullOrEmpty(parm.MaterialCode))
            {
                throw new ArgumentException("物料编码不能为空", nameof(parm.MaterialCode));
            }

            if (parm.PackageCodeList == null || parm.PackageCodeList.Count() == 0)
            {
                return "无出库箱";
            }

            bool IsStrict = parm.IsStrict;
            string CreatedBy = parm.Operator;
            string shipnumber = parm.ShipmentNum;

            try
            {
                // 使用单次查询获取所有需要的数据
                var nowProductionList = Context
                    .Queryable<WmGoodsNowProduction>()
                    .Where(it => parm.PackageCodeList.Contains(it.PackageCodeClient))
                    .ToList();

                if (nowProductionList.Count != parm.CurrentOutPackage && IsStrict)
                {
                    return $"提醒:当前成品库数与出库箱数对不上,成品库箱数:{nowProductionList.Count}";
                }

                // 处理BatchCode，去除前两位多余字符
                string processedBatchCode = ProcessBatchCode(parm.BatchCode);

                // 批量获取已出库统计数据
                var outRecordData = Context
                    .Queryable<WmGoodsOutRecord>()
                    .Where(it =>
                        it.FkOutOrderId == shipnumber
                        && it.Partnumber == parm.MaterialCode
                        && it.PackageCodeClient.Contains(processedBatchCode)
                    )
                    .Select(g => new { PackageCodeClient = g.PackageCodeClient, GoodsNumAction = g.GoodsNumAction })
                    .ToList()
                    .Aggregate(new { PackageCount = 0, PartNumberSum = 0.0 }, (acc, x) => new { PackageCount = acc.PackageCount + 1, PartNumberSum = acc.PartNumberSum + (x.GoodsNumAction ?? 0) });

                if (
                    parm.PlanOutPackage < parm.CurrentOutPackage + outRecordData.PackageCount
                    && IsStrict
                )
                {
                    return "提醒:总出库箱超出计划";
                }
                if (
                    parm.PlanOutNumber < parm.CurrentOutNumber + outRecordData.PartNumberSum
                    && IsStrict
                )
                {
                    return "提醒:总出库零件数超出计划";
                }

                Context.Ado.BeginTran();

                // 批量构建出库记录
                var outRecords = nowProductionList
                    .Select(wmGoods => new WmGoodsOutRecord
                    {
                        Id = SnowFlakeSingle.Instance.NextId().ToString(),
                        FkNowProductionId = wmGoods.Id,
                        PackageCodeClient = wmGoods.PackageCodeClient,
                        PackageCode = wmGoods.PackageCode,
                        PackageCodeOriginal = wmGoods.PackageCodeOriginal,
                        LocationCode = wmGoods.LocationCode,
                        Partnumber = wmGoods.Partnumber,
                        GoodsNumLogic = wmGoods.GoodsNumLogic,
                        GoodsNumAction = wmGoods.GoodsNumAction,
                        EntryWarehouseTime = wmGoods.EntryWarehouseTime,
                        OutTime = DateTime.Now,
                        CreatedTime = DateTime.Now,
                        CreatedBy = CreatedBy,
                        FkOutOrderId = shipnumber
                    })
                    .ToList();

                // 批量插入出库记录
                int sum_insert = Context.Insertable(outRecords).ExecuteCommand();

                // 批量删除成品库记录
                var deleteIds = nowProductionList.Select(x => x.Id).ToArray();
                int sum_delete = Context
                    .Deleteable<WmGoodsNowProduction>()
                    .In(deleteIds)
                    .ExecuteCommand();

                if (sum_insert != sum_delete && IsStrict)
                {
                    Context.Ado.RollbackTran();
                    throw new Exception(
                        "出库操作出现异常！失败原因记录不一致:添加数据" + sum_insert + "删除数据:" + sum_delete
                    );
                }

                // 构建统计信息
                var partnumbers = nowProductionList.Select(x => x.Partnumber).Distinct().ToList();
                int totalPackage = nowProductionList.Count;
                int totalPartnumber = nowProductionList.Sum(x => x.GoodsNumAction ?? 0);
                var packageCodeRemark = nowProductionList
                    .Select(x => x.PackageCodeClient)
                    .OrderBy(x => x)
                    .ToList();

                // 插入操作记录
                WmGoodsRecord wmGoodsRecord =
                    new()
                    {
                        Id = SnowFlakeSingle.Instance.NextId().ToString(),
                        FkInventoryId = SnowFlakeSingle.Instance.NextId().ToString(),
                        Code = "PdaOutboundByOutOrderPlan",
                        Partnumber = partnumbers.FirstOrDefault() ?? "无零件号",
                        BlankNum = "",
                        ChangeType = 2,
                        ChangePackage = totalPackage,
                        ChangeQuantity = totalPartnumber,
                        ActionTime = DateTime.Now,
                        Status = 1,
                        Remark =
                            "货物出库"
                            + "\n出库单:"
                            + shipnumber
                            + "\n零件号:"
                            + string.Join(',', partnumbers)
                            + "\n数据库变动:插入成功"
                            + sum_insert
                            + "删除成功"
                            + sum_delete
                            + "\n总箱数:"
                            + totalPackage
                            + "\n总零件数:"
                            + totalPartnumber
                            + "\n涉及批次号:\n"
                            + string.Join(',', packageCodeRemark),
                        CreatedBy = CreatedBy ?? "系统操作",
                        CreatedTime = DateTime.Now,
                    };
                int recordNum = Context.Insertable(wmGoodsRecord).ExecuteCommand();
                if (recordNum == 0)
                {
                    Context.Ado.RollbackTran();
                    throw new Exception("记录插入失败");
                }
                // 获取客户代码
                string _customerCode =
                    Context
                        .Queryable<WmOutOrder>()
                        .Where(x => x.ShipmentNum == shipnumber)
                        .Select(x => x.CustomNo)
                        .First() ?? "无客户代码";
                // 异步处理U8系统交互
                _ = Task.Run(async () =>
                    {
                        try
                        {
                            string urlBase = "http://gam.com.cn:8053/";
                            ERP_WMS_interactiveService _eRP_WMS_InteractiveService = new();
                            // 构建U8包列表
                            List<ERP_WMS_interactiveModelQuery> u8PackageList = outRecords
                                .Select(item =>
                                {
                                    string dateString = DateTime.Now.ToString("yyyyMMdd");
                                    // 使用正则表达式匹配日期模式
                                    string pattern = @"(\d{2})(\d{2})(\d{2})";
                                    Match match = Regex.Match(item.PackageCodeClient, pattern);

                                    if (match.Success)
                                    {
                                        // 提取匹配的年份、月份和日期
                                        string year = match.Groups[1].Value;
                                        string month = match.Groups[2].Value;
                                        string day = match.Groups[3].Value;
                                        // 转换为四位数年份（假设2000年代）
                                        string fullYear = "20" + year;
                                        // 组合为yyyyMMdd格式
                                        dateString = fullYear + month + day;
                                    }
                                    else
                                    {
                                        logger.Warn($"未找到匹配的日期模式:{item.PackageCodeClient}");
                                    }

                                    return new ERP_WMS_interactiveModelQuery
                                    {
                                        customerCode = _customerCode,
                                        materialCode = item.Partnumber,
                                        location = item.LocationCode,
                                        Qty = item.GoodsNumAction.ToString(),
                                        LotNo = dateString,
                                        createTime = DateTime.Now,
                                        userID = parm.Operator,
                                        guid = Guid.NewGuid().ToString(),
                                        lineno = "涂装生产线"
                                    };
                                })
                                .ToList();

                            var u8ErpResult = await _eRP_WMS_InteractiveService
                                .OutboundedAsync(urlBase, u8PackageList)
                                .ConfigureAwait(false);
                            logger.Warn(u8ErpResult);
                        }
                        catch (Exception ex)
                        {
                            logger.Error($"U8系统交互异常: {ex.Message}", ex);
                        }
                    })
                    .ConfigureAwait(false);

                Context.Ado.CommitTran();
                return "ok";
            }
            catch (Exception e)
            {
                Context.Ado.RollbackTran();
                logger.Error($"出库操作异常: {e.Message}", e);
                throw new Exception($"出库操作失败: {e.Message}");
            }
        }

        public bool CompleteOutOrder(string shipmentNum)
        {
            return OverOutorderplan(shipmentNum);
        }



    }
}