using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.Enums;
using WIDESEA_Core;
using WIDESEA_Model.Models;
using WIDESEA_Core.Helper;
using Microsoft.Extensions.Logging;
using MailKit.Search;
using System.Reflection.Metadata;
using static WIDESEA_ITaskInfoService.ITaskService;
using static WIDESEA_Common.HouseInventoryIn;
using WIDESEA_Common;
using Parameter = WIDESEA_Common.Parameter;
using WIDESEA_Core.LogHelper;
using WIDESEA_DTO.Task;
using WIDESEA_Core.TaskEnum;

namespace WIDESEA_TaskInfoService
{
    public partial class TaskService
    {


        /// <summary>
        /// 立库入库指令上传
        /// </summary>
        /// <param name="stationCode">起始地址</param>
        /// <param name="palletCode">托盘编号</param>
        /// <returns>返回处理结果</returns>
        public WebResponseContent InboundRequest(string stationCode, string roadwayNo, string palletCode)
        {
            // 输入验证
            if (string.IsNullOrWhiteSpace(palletCode))
                return WebResponseContent.Instance.Error("请输入正确托盘号");

            try
            {
                Dt_Task task = Repository.QueryFirst(x => x.PalletCode == palletCode);
                if (task != null)
                {
                    PushTasksToWCS(new List<Dt_Task> { task });
                    return WebResponseContent.Instance.OK($"该托盘已生成任务", _mapper.Map<WMSTaskDTO>(task));
                }
                // 获取入库单明细
                var inboundOrderDet = GetInboundOrderDetail(palletCode);
                if (inboundOrderDet == null)
                    return WebResponseContent.Instance.Error($"未找到托盘号 {palletCode} 对应的入库单明细");

                // 获取入库单
                var inboundOrder = GetInboundOrder(inboundOrderDet.OrderId);
                if (inboundOrder == null)
                    return WebResponseContent.Instance.Error($"未找到入库单信息");

                // 验证入库单明细
                if (inboundOrder.Details == null || inboundOrder.Details.Count == 0)
                    return WebResponseContent.Instance.Error($"入库单 {inboundOrder.OrderNo} 没有明细信息");

                // 获取仓库和巷道信息
                var warehouse = GetWarehouse(inboundOrder.WarehouseId);
                var roadwayInfo = GetRoadwayInfo(warehouse.WarehouseCode);

                // 处理库存信息
                //var stockInfo = GetOrCreateStockInfo(palletCode, inboundOrder, inboundOrderDet, warehouse);
                var dt_StockInfoDetail = new Dt_StockInfoDetail
                {
                    //StockId = stockInfo.Id,
                    MaterielCode = inboundOrderDet.MaterielCode,
                    MaterielName = inboundOrderDet.MaterielName,
                    OrderNo = inboundOrder.OrderNo,
                    BatchNo = inboundOrderDet.BatchNo,
                    LinId = inboundOrderDet.LinId,
                    StockQuantity = inboundOrderDet.OrderQuantity,
                    Status = (int)StockStatusEmun.组盘暂存,
                    Creater = "WMS",
                    CreateDate = DateTime.Now,
                    Id = inboundOrderDet.LinId.ObjToInt(),
                };

                var dt_Stock = new Dt_StockInfo
                {
                    BatchNo = inboundOrderDet.BatchNo,
                    PalletCode = palletCode,
                    PalletType = GetPalletType(warehouse, palletCode),
                    IsFull = true,
                    StockStatus = (int)StockStatusEmun.组盘暂存,
                    Creater = "WMS",
                    CreateDate = DateTime.Now,
                    MaterialType = (int)InventoryMaterialType.成品,
                    Materialweight = 0,
                    Wlstatus = (int)InventoryMaterialStatus.合格,
                    Mgeneratetime = DateTime.Now,
                    WarehouseId = warehouse.WarehouseId,
                    Details = new List<Dt_StockInfoDetail> { dt_StockInfoDetail }
                };

                // 检查入库请求
                var checkResult = CheckRequestInbound(roadwayInfo.InSCStationCode, palletCode, true, dt_Stock);
                if (!checkResult.Item1)
                    return WebResponseContent.Instance.Error(checkResult.Item2);

                // 分配库位并更新数据
                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayNo, dt_Stock.PalletType, dt_Stock.WarehouseId);
                //Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(stationCode, TaskTypeEnum.Inbound.ObjToInt());
                if (locationInfo == null)
                {
                    return WebResponseContent.Instance.Error($"货位分配失败,未找到可分配货位");
                }

                Dt_Task newTask = new Dt_Task()
                {
                    CurrentAddress = stationCode,
                    Grade = 0,
                    NextAddress = locationInfo.LocationCode,
                    PalletCode = palletCode,
                    Roadway = roadwayNo,
                    SourceAddress = stationCode,
                    TargetAddress = locationInfo.LocationCode,
                    TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
                    WarehouseId = dt_Stock.WarehouseId,
                    PalletType = dt_Stock.PalletType,
                    Creater = "WMS",
                    CreateDate = DateTime.Now,
                };

                LocationStatusEnum lastStatus = (LocationStatusEnum)locationInfo.LocationStatus;
                _unitOfWorkManage.BeginTran();
                Db.InsertNav(dt_Stock).Include(x => x.Details).ExecuteCommand();
                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, lastStatus.ObjToInt(), LocationStatusEnum.Lock.ObjToInt(), LocationChangeType.InboundAssignLocation.ObjToInt());
                //_basicService.LocationInfoService.UpdateLocationStatus(locationInfo, newTask.PalletType, LocationStatusEnum.Lock, newTask.WarehouseId);
                int taskId = BaseDal.AddData(newTask);
                newTask.TaskId = taskId;
                _stockRepository.StockInfoRepository.UpdateData(dt_Stock);
                _unitOfWorkManage.CommitTran();
                WMSTaskDTO wMSTaskDTO = _mapper.Map<WMSTaskDTO>(newTask);

                PushTasksToWCS(new List<Dt_Task> { newTask });
                if (newTask.WarehouseId == 5) PutFinish(stationCode);
                return WebResponseContent.Instance.OK(data: wMSTaskDTO);
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        private Dt_InboundOrderDetail GetInboundOrderDetail(string palletCode)
        {
            return BaseDal.Db.Queryable<Dt_InboundOrderDetail>()
                .Where(x => x.LPNNo == palletCode)
                .First();
        }

        private Dt_InboundOrder GetInboundOrder(int orderId)
        {
            return BaseDal.Db.Queryable<Dt_InboundOrder>()
                .Where(x => x.Id == orderId)
                .Includes(x => x.Details)
                .First();
        }

        private Dt_Warehouse GetWarehouse(int warehouseId)
        {
            return _basicService.WarehouseService.Repository
                .QueryFirst(x => x.WarehouseId == warehouseId);
        }

        private Dt_RoadwayInfo GetRoadwayInfo(string warehouseCode)
        {
            return _basicService.RoadwayInfoService.Repository
                .QueryFirst(x => x.RoadwayNo == warehouseCode);
        }

        private Dt_StockInfo GetOrCreateStockInfo(string palletCode, Dt_InboundOrder inboundOrder, Dt_InboundOrderDetail inboundOrderDet, Dt_Warehouse warehouse)
        {
            var stockInfo = BaseDal.Db.Queryable<Dt_StockInfo>()
                .Where(x => x.PalletCode == palletCode)
                .Includes(x => x.Details)
                .First();
            decimal beforeQuantity = 0;
            if (stockInfo == null)
            {
                stockInfo = CreateNewStockInfo(palletCode, inboundOrder, inboundOrderDet, warehouse);
                //CreateStockInfoDetail(stockInfo, inboundOrder, inboundOrderDet);
            }
            else
            {
                if (stockInfo.StockStatus != StockStatusEmun.组盘暂存.ObjToInt())
                {
                    return null;
                }
                beforeQuantity = stockInfo.Details.Sum(x => x.StockQuantity);
            }

            return stockInfo;
        }

        private Dt_StockInfo CreateNewStockInfo(string palletCode, Dt_InboundOrder inboundOrder, Dt_InboundOrderDetail inboundOrderDet, Dt_Warehouse warehouse)
        {
            var dt_StockInfoDetail = new Dt_StockInfoDetail
            {
                //StockId = stockInfo.Id,
                MaterielCode = inboundOrderDet.MaterielCode,
                MaterielName = inboundOrderDet.MaterielName,
                OrderNo = inboundOrder.OrderNo,
                BatchNo = inboundOrderDet.BatchNo,
                LinId = inboundOrderDet.LinId,
                StockQuantity = inboundOrderDet.OrderQuantity,
                Status = (int)StockStatusEmun.组盘暂存,
                Creater = "WMS",
                CreateDate = DateTime.Now,
                Id = inboundOrderDet.LinId.ObjToInt(),
            };

            var dt_Stock = new Dt_StockInfo
            {
                BatchNo = inboundOrderDet.BatchNo,
                PalletCode = palletCode,
                PalletType = GetPalletType(warehouse, palletCode),
                IsFull = true,
                StockStatus = (int)StockStatusEmun.组盘暂存,
                Creater = "WMS",
                CreateDate = DateTime.Now,
                MaterialType = (int)InventoryMaterialType.成品,
                Materialweight = 0,
                Wlstatus = (int)InventoryMaterialStatus.合格,
                Mgeneratetime = DateTime.Now,
                WarehouseId = warehouse.WarehouseId,
                Details = new List<Dt_StockInfoDetail> { dt_StockInfoDetail }
            };

            //_stockService.StockInfoService.Repository.AddData(dt_Stock);
            Db.InsertNav(dt_Stock).Include(x => x.Details).ExecuteCommand();
            return _stockService.StockInfoService.Repository.GetStockInfo(palletCode);
        }

        private void CreateStockInfoDetail(Dt_StockInfo stockInfo, Dt_InboundOrder inboundOrder, Dt_InboundOrderDetail inboundOrderDet)
        {
            var dt_StockInfoDetail = new Dt_StockInfoDetail
            {
                StockId = stockInfo.Id,
                MaterielCode = inboundOrderDet.MaterielCode,
                MaterielName = inboundOrderDet.MaterielName,
                OrderNo = inboundOrder.OrderNo,
                BatchNo = inboundOrderDet.BatchNo,
                LinId = inboundOrderDet.LinId,
                StockQuantity = inboundOrderDet.OrderQuantity,
                Status = (int)StockStatusEmun.组盘暂存,
                Creater = "WMS",
                CreateDate = DateTime.Now,
                Id = inboundOrderDet.LinId.ObjToInt(),
            };

            _stockService.StockInfoDetailService.Repository.AddData(dt_StockInfoDetail);
        }

        //查询仓库托盘货物类型
        public int GetPalletType(Dt_Warehouse warehouse, string palletCode)
        {
            if (warehouse.WarehouseCode == WarehouseEnum.SC01_BC.ToString())
            {
                if (palletCode.Substring(0, 1) == "6")
                {
                    return PalletTypeEnum.MediumPallet.ObjToInt();
                }
                else
                {
                    return PalletTypeEnum.LargestPallet.ObjToInt();
                }
            }
            else if (warehouse.WarehouseCode == WarehouseEnum.SC01_BC.ObjToString())
            {
                Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 1));
                if (palletTypeInfo == null)
                {
                    throw new Exception($"托盘号错误");
                }
                return palletTypeInfo.PalletType;
            }
            //else if (warehouse.WarehouseCode == WarehouseEnum.HA152.ObjToString())
            //{
            //    Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 2));
            //    if (palletTypeInfo == null)
            //    {
            //        throw new Exception($"托盘号错误");
            //    }
            //    return palletTypeInfo.PalletType;
            //}
            //else if (warehouse.WarehouseCode == WarehouseEnum.HA57.ObjToString())
            //{
            //    Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 3));
            //    if (palletTypeInfo == null)
            //    {
            //        throw new Exception($"托盘号错误");
            //    }
            //    return palletTypeInfo.PalletType;
            //}
            return -1;
        }




        #region
        //public WebResponseContent InboundRequest(SaveModel saveModel)
        //{
        //    string palletCode = saveModel.palletCode;
        //    if (saveModel.palletCode == null) return WebResponseContent.Instance.Error($"请输入正确托盘号");
        //    WebResponseContent content = new WebResponseContent();
        //    try
        //    {
        //        Dt_InboundOrderDetail inboundOrderDet = BaseDal.Db.Queryable<Dt_InboundOrderDetail>().Where(x => x.LPNNo == palletCode).First();
        //        Dt_InboundOrder inboundOrder = BaseDal.Db.Queryable<Dt_InboundOrder>().Where(x => x.Id == inboundOrderDet.OrderId).Includes(x => x.Details).First();
        //        if (inboundOrder == null)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到入库单信息");
        //        }
        //        Dt_Warehouse warehouse = _basicService.WarehouseService.Repository.QueryFirst(x => x.WarehouseId == inboundOrder.WarehouseId);
        //        Dt_RoadwayInfo roadwayInfo = _basicService.RoadwayInfoService.Repository.QueryFirst(x => x.RoadwayNo == warehouse.WarehouseCode);
        //        if (roadwayInfo != null) { }

        //        if (inboundOrder.Details == null || inboundOrder.Details.Count <= 0)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到入库单明细信息");
        //        }
        //        Dt_StockInfo stockInfo1 = BaseDal.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();
        //        if (stockInfo1 == null)
        //        {
        //            Dt_StockInfo dt_Stock = new()
        //            {
        //                BatchNo = inboundOrderDet.BatchNo,
        //                PalletCode = palletCode,
        //                IsFull = true,
        //                StockStatus = (int)StockStatusEmun.组盘暂存,
        //                Creater = "WMS",
        //                CreateDate = DateTime.Now,
        //                MaterialType = (int)InventoryMaterialType.成品,
        //                Materialweight = 0,
        //                Wlstatus = (int)InventoryMaterialStatus.合格,
        //                Mgeneratetime = DateTime.Now,
        //            };
        //            _stockService.StockInfoService.Repository.AddData(dt_Stock);

        //            Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.GetStockInfo(palletCode);
        //            Dt_StockInfoDetail dt_StockInfoDetail = new()
        //            {
        //                StockId = dt_StockInfo.Id,
        //                MaterielCode = inboundOrderDet.MaterielCode,    //物料号
        //                MaterielName = inboundOrderDet.MaterielName,    //物料名称
        //                OrderNo = inboundOrder.OrderNo,        //物料详情
        //                BatchNo = inboundOrderDet.BatchNo,         //物料批次
        //                LinId = inboundOrderDet.LinId,                    //SerialNumber = targetCodes[2].ToString(),    //包号
        //                                                                  //BatchNoName = dt_Int.OrderNo,
        //                StockQuantity = inboundOrderDet.OrderQuantity,    //重量
        //                                                                  //OutboundQuantity = 1,    //序列号
        //                Status = (int)StockStatusEmun.组盘暂存,
        //                Creater = "WMS",
        //                CreateDate = DateTime.Now,
        //                Id = inboundOrderDet.LinId.ObjToInt(),
        //            };
        //            _stockService.StockInfoDetailService.Repository.AddData(dt_StockInfoDetail);
        //        }
        //        Dt_StockInfo stockInfo = BaseDal.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();
        //        (bool, string) result = CheckRequestInbound(roadwayInfo.InSCStationCode, palletCode, true, stockInfo);
        //        if (!result.Item1) return content = WebResponseContent.Instance.Error(result.Item2);
        //        content = AssignLocUpdateData(roadwayInfo.InSCStationCode, TaskTypeEnum.Inbound.ObjToInt(), palletCode, true, stockInfo, inboundOrder.OrderNo);
        //    }
        //    catch (Exception ex)
        //    {
        //        content = WebResponseContent.Instance.Error(ex.Message);
        //    }
        //    return content;
        //}
        #endregion
        public string ReceiveWMSInventoryIn = WIDESEA_Core.Helper.AppSettings.Configuration["ReceiveWMSInventoryIn"];
        /// <summary>
        /// 盘点差异数量回传
        /// </summary>
        /// <returns></returns>
        public WebResponseContent InventoryIn(string name, int qty)
        {
            WebResponseContent content = new();
            try
            {
                Dt_StockInfo stockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == name);
                Dt_StockInfoDetail stockInfoDetail = _stockService.StockInfoDetailService.Repository.QueryFirst(x => x.StockId == stockInfo.Id);
                Dt_OutboundOrderDetail outboundOrderDetail = _outboundService.OutboundOrderDetailService.Repository.QueryFirst(x => x.LPNNo == stockInfo.PalletCode);
                Dt_OutboundOrder outboundOrder = _outboundService.OutboundOrderService.Repository.QueryFirst(x => x.Id == outboundOrderDetail.OrderId);
                HouseInventoryIn houseInboundPassBack = new HouseInventoryIn();
                houseInboundPassBack.ApiType = "StockCountController";
                houseInboundPassBack.Method = "AsrsFinishedStockCount";

                data data = new data();
                data.InventoryIn data1 = new data.InventoryIn();
                data1.No = outboundOrder.OrderNo;
                data.InventoryIn.Inbound inbound = new data.InventoryIn.Inbound();
                inbound.LinId = outboundOrderDetail.LinId;
                inbound.LPN_No = outboundOrderDetail.LPNNo;
                inbound.MaterielCode = outboundOrderDetail.MaterielCode;
                inbound.OrderQuantity = outboundOrderDetail.OrderQuantity;
                inbound.BatchNo = outboundOrderDetail.BatchNo;
                inbound.FinishQty = qty;
                inbound.WarehouseCode = outboundOrderDetail.WarehouseCode;
                inbound.StorageAreaCode = outboundOrderDetail.StorageAreaCode;
                inbound.StorageLocationCode = outboundOrderDetail.StorageLocationCode;
                data1.DetailList.Add(inbound);
                data.Value.Add(data1);
                houseInboundPassBack.Parameters.Add(data);
                Authentication authentication = new Authentication()
                {
                    ApiType = "AuthenticationController",
                    Parameters = new List<Parameter>
                {
                     new Parameter { Value = "LKAdmin"},
                     new Parameter { Value = "LKAdmin"},
                },
                    Method = "Login",
                };
                var responses1 = HttpHelper.Post<WebResponseContent>(ReceiveWMSTaskAUT, authentication, "登录WMS账号");
                var Ticket = responses1.Context["Ticket"].ToString();
                var InvOrgId = responses1.Context["InvOrgId"].ToString();
                if (Ticket != null)
                {
                    houseInboundPassBack.Context = new Dictionary<string, string>();
                    houseInboundPassBack.Context.Add("Ticket", Ticket);
                    houseInboundPassBack.Context.Add("InvOrgId", InvOrgId);
                    var responses = HttpHelper.Post<WebResponseContent>(ReceiveWMSInventoryIn, houseInboundPassBack, "立库入库数量回传WMS");
                }
                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            finally
            {

            }
            return content;
        }

        /// <summary>
        /// 入库分配货位及处理数据
        /// </summary>
        /// <param name="stationCode">起始地址</param>
        /// <param name="taskType">任务类型</param>
        /// <param name="palletCode">托盘编号</param>
        /// <param name="isUpdateStock">是否更新组盘信息--区分物料入库和空托入库</param>
        /// <param name="stockInfo">组盘信息--可空</param>
        /// <param name="orderNo">订单号--可空</param>
        /// <returns>返回处理结果</returns>
        private WebResponseContent AssignLocUpdateData(string stationCode, int taskType, string palletCode, bool isUpdateStock = true, Dt_StockInfo? stockInfo = null,
            string orderNo = "")
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_InboundOrder dt_Int = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.OrderNo == orderNo);
                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(stationCode, taskType);
                //Dt_LocationInfo dt_LocationInfo = null;
                if (locationInfo != null)
                {
                    Dt_Task task = new()
                    {
                        CurrentAddress = "0",
                        Grade = 0,
                        PalletCode = palletCode,
                        NextAddress = "0",
                        Roadway = locationInfo.RoadwayNo,
                        SourceAddress = stationCode,
                        TargetAddress = locationInfo.LocationCode,
                        TaskStatus = InTaskStatusEnum.InNew.ObjToInt(),
                        TaskType = taskType,
                        OrderNo = orderNo,
                        CreateDate = DateTime.Now,
                        Creater = "WMS"
                    };
                    BaseDal.AddData(task);
                    int beforeStatus = locationInfo.LocationStatus;
                    if (isUpdateStock)
                    {
                        locationInfo.LocationStatus = LocationStatusEnum.Lock.ObjToInt();
                        _basicService.LocationInfoService.UpdateLocationLock(locationInfo, task.TaskNum, StockChangeType.Inbound.ObjToInt(), false);

                        if (stockInfo != null && stockInfo.Details != null && stockInfo.Details.Count > 0)
                        {
                            orderNo = stockInfo.Details.FirstOrDefault()?.OrderNo ?? "";

                            stockInfo.StockStatus = StockStatusEmun.入库确认.ObjToInt();
                            //stockInfo.LocationCode = task.TargetAddress;
                            _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                        }
                        else
                        {
                            return content = WebResponseContent.Instance.Error("未找到库存信息");
                        }
                    }
                    else
                    {
                        locationInfo.LocationStatus = LocationStatusEnum.Lock.ObjToInt();
                        _basicService.LocationInfoService.UpdateLocationLock(locationInfo, task.TaskNum, StockChangeType.Inbound.ObjToInt(), false);
                    }
                    //下发入库任务至WCS
                    //var responses = HttpHelper.Post<WebResponseContent>(ReceiveWMSTask, task, "下发任务入库");
                    dt_Int.OrderStatus = InboundStatusEnum.入库中.ObjToInt();
                    _inboundService.InbounOrderService.Repository.UpdateData(dt_Int);
                    _basicService.LocationInfoService.Repository.UpdateData(locationInfo);
                    _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, beforeStatus, StockChangeType.Inbound.ObjToInt(), orderNo, task.TaskNum);
                    return content = WebResponseContent.Instance.OK(data: task);
                }
                return content = WebResponseContent.Instance.Error("未找到可分配货位");
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }

        /// <summary>
        /// 验证数据
        /// </summary>
        /// <param name="stationCode">起始地址</param>
        /// <param name="palletCode">托盘编号</param>
        /// <param name="isCheckStock">是否检查组盘信息--区分物料入库和空托入库</param>
        /// <param name="stockInfo">组盘信息--可空</param>
        /// <returns>返回处理结果</returns>
        private (bool, string) CheckRequestInbound(string stationCode, string palletCode, bool isCheckStock = true, Dt_StockInfo? stockInfo = null)
        {
            if (BaseDal.QueryFirst(x => x.PalletCode == palletCode) != null)
            {
                return (false, "该托盘号已有任务");
            }
            if (BaseDal.QueryFirst(x => (x.SourceAddress == stationCode || x.CurrentAddress == stationCode) && x.TaskStatus == InTaskStatusEnum.InNew.ObjToInt()) != null)
            {
                return (false, "当前入库站台已有一条新建任务");
            }
            if (isCheckStock)
            {
                if (stockInfo == null)
                {
                    return (false, "未找到组盘信息");
                }
                if (stockInfo.StockStatus != StockStatusEmun.组盘暂存.ObjToInt())
                {
                    return (false, "该组盘状态不可入库");
                }
                if (!string.IsNullOrEmpty(stockInfo.LocationCode))
                {
                    return (false, "该托盘已绑定货位");
                }
                if (stockInfo.Details == null || stockInfo.Details.Count == 0)
                {
                    return (false, "没有库存明细信息");
                }
            }
            else
            {
                if (_stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == palletCode) != null)
                {
                    return (false, "该托盘已存在库内");
                }
            }

            return (true, "成功");
        }


        /// <summary>
        /// 根据托盘条码，起点位置，生成入库信息
        /// </summary>
        /// <param name="PalletCode"></param>
        /// <returns></returns>
        //public WebResponseContent GenerateInventoryInformation(GenerateInv generate)
        //{

        //    WebResponseContent content = new WebResponseContent();
        //    try
        //    {
        //        Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //        if (task != null)
        //        {
        //            return content = WebResponseContent.Instance.Error($"已有该托盘的入库任务，托盘号：{task.PalletCode}");
        //        }
        //        else
        //        {

        //            //if ((generate.SourceAddress == "R01-003-041-011-01" || generate.SourceAddress == "R01-002-043-001-01" || generate.SourceAddress == "R02-003-027-011-01"))
        //            //{
        //            Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //            if (dt_StockInfo2 == null)
        //            {
        //                Dt_StockInfo dt_Stock = new()
        //                {
        //                    PalletCode = generate.PalletCode,
        //                    IsFull = true,
        //                    StockStatus = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                    MaterialType = (int)InventoryMaterialType.空托,
        //                    Materialweight = 0,
        //                    Wlstatus = (int)InventoryMaterialStatus.空托,
        //                    Mgeneratetime = DateTime.Now,
        //                };
        //                _stockService.StockInfoService.Repository.AddData(dt_Stock);
        //            }
        //            //}
        //            Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode && x.StockStatus == (int)StockStatusEmun.组盘暂存);
        //            if (dt_StockInfo != null)
        //            {
        //                Dt_LocationInfo newLocation;
        //                Dt_LocationInfo newSourceAddress;
        //                newSourceAddress = _basicService.LocationInfoService.GetLocationplatform(generate.SourceAddress);
        //                int Locationtype = 1;   //默认为9
        //                if (dt_StockInfo.MaterialType == (int)InventoryMaterialType.成品 || (generate.SourceAddress == "R01-003-041-001-01" && dt_StockInfo.MaterialType == (int)InventoryMaterialType.原材料))
        //                {
        //                    Locationtype = 11;

        //                }
        //                else if (dt_StockInfo.MaterialType == (int)InventoryMaterialType.原材料)
        //                {
        //                    Locationtype = 10;
        //                }

        //                if (dt_StockInfo.MaterialType == (int)InventoryMaterialType.成品)
        //                {
        //                    string[] targetCodes = dt_StockInfo.PalletCode.Split("*");
        //                    Dt_InboundOrder dt_Inbound = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.OrderName == targetCodes[0]);
        //                    if (dt_Inbound.Startingcolumn != 0 || dt_Inbound.Terminationcolumn != 0)
        //                    {
        //                        newLocation = _basicService.LocationInfoService.GetLocation2(newSourceAddress.RoadwayNo, Locationtype, dt_Inbound.Startingcolumn, dt_Inbound.Terminationcolumn);
        //                    }
        //                    else
        //                    {
        //                        newLocation = _basicService.LocationInfoService.GetLocation(newSourceAddress.RoadwayNo, Locationtype);
        //                    }

        //                }
        //                else
        //                {
        //                    newLocation = _basicService.LocationInfoService.GetLocation(newSourceAddress.RoadwayNo, Locationtype);
        //                }


        //                //string[] Pallet = PalletCode.Split("-");
        //                if (newLocation != null && newSourceAddress != null)
        //                {
        //                    //生成入库任务
        //                    Dt_Task dt_Task = new()
        //                    {
        //                        PalletCode = generate.PalletCode,
        //                        TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
        //                        Roadway = newLocation.RoadwayNo,
        //                        TaskType = TaskTypeEnum.Inbound.ObjToInt(),
        //                        TaskStatus = InTaskStatusEnum.InNew.ObjToInt(),
        //                        SourceAddress = newSourceAddress.LocationCode,
        //                        TargetAddress = newLocation.LocationCode,
        //                        CurrentAddress = newSourceAddress.LocationCode,
        //                        NextAddress = newLocation.LocationCode,
        //                        Grade = 1,
        //                        Creater = "WMS",
        //                        Depth = newLocation.Depth,
        //                        CreateDate = DateTime.Now,
        //                        MaterialType = dt_StockInfo.MaterialType
        //                    };
        //                    _unitOfWorkManage.BeginTran();
        //                    if (newLocation.LocationStatus == LocationStatusEnum.Free.ObjToInt())
        //                    {
        //                        newLocation.LocationStatus = newSourceAddress.LocationType == (int)LocationTypeEnum.EmptyOut ? LocationStatusEnum.PalletLock.ObjToInt() : LocationStatusEnum.Lock.ObjToInt();
        //                    }
        //                    BaseDal.AddData(dt_Task);
        //                    _basicService.LocationInfoService.UpdateData(newLocation);

        //                    _unitOfWorkManage.CommitTran();

        //                    return content = WebResponseContent.Instance.OK(data: dt_Task);
        //                }
        //                else
        //                {
        //                    return content = WebResponseContent.Instance.Error($"未找到对应的起点:{generate.SourceAddress},或终点{newSourceAddress.RoadwayNo}，信息");
        //                }

        //            }
        //            else
        //            {
        //                //Queryinventory(generate.PalletCode);
        //                return content = WebResponseContent.Instance.Error($"组盘，请核对托盘号:{generate.PalletCode}");
        //            }

        //        }

        //    }
        //    catch (Exception ex)
        //    {
        //        return content = WebResponseContent.Instance.Error($"生成入库任务出错，出错信息:{ex.Message}");
        //        throw;
        //    }
        //}

        ///// <summary>
        ///// 查询1巷道库存，是否运行进行入库  //带后续重新拼接
        ///// </summary>
        ///// <returns></returns>
        //public WebResponseContent Queryinventory3(GenerateInv generate)
        //{
        //    try
        //    {
        //        WebResponseContent content = new WebResponseContent();
        //        string result = generate.PalletCode.Substring(0, 2);
        //        Dt_InboundOrder dt_Inbound = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.UpperOrderNo == result);
        //        Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //        if (dt_Inbound != null)
        //        {
        //            if (dt_StockInfo == null)
        //            {
        //                Dt_StockInfo dt_Stock = new()
        //                {
        //                    PalletCode = generate.PalletCode,
        //                    IsFull = true,
        //                    StockStatus = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                    MaterialType = (int)InventoryMaterialType.原材料,
        //                    Materialweight = 0,
        //                };
        //                _unitOfWorkManage.BeginTran();
        //                _stockService.StockInfoService.Repository.AddData(dt_Stock);

        //                string part2 = generate.PalletCode.Substring(2, 8);

        //                string part3 = generate.PalletCode.Split('#')[1];
        //                Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                {
        //                    StockId = dt_StockInfo2.Id,
        //                    MaterielCode = result,    //物料编号
        //                    MaterielName = dt_Inbound.OrderNo,    //材质
        //                    OrderNo = generate.PalletCode,        //单据（托盘条码）
        //                    BatchNo = part2,         //批次号
        //                    SerialNumber = part3,    //序列号
        //                    StockQuantity = 1,    //序列号
        //                    OutboundQuantity = 1,    //序列号
        //                    Status = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                };
        //                _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);

        //                _unitOfWorkManage.CommitTran();
        //                return content = WebResponseContent.Instance.OK();
        //            }
        //            else
        //            {
        //                return content = WebResponseContent.Instance.OK();
        //            }

        //        }
        //        else
        //        {
        //            return content = WebResponseContent.Instance.Error("未找到该类型的解析");
        //        }

        //    }
        //    catch (Exception ex)
        //    {

        //        throw;
        //    }
        //}

        ///// <summary>
        ///// 解析库存
        ///// </summary>
        ///// <returns></returns>
        //public WebResponseContent Queryinventory(GenerateInv generate)
        //{
        //    WebResponseContent content = new WebResponseContent();
        //    try
        //    {

        //        string[] targetCodes = generate.PalletCode.Split("*");
        //        if (targetCodes.Length == 4)
        //        {
        //            Dt_InboundOrder dt_Inbound = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.OrderName == targetCodes[0]);

        //            if (dt_Inbound != null)
        //            {
        //                Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                if (dt_Inbound.OrderType == (int)InventoryMaterialType.原材料)   //0为原材料编码
        //                {
        //                    List<Dt_LocationInfo> locationInfos = _basicService.LocationInfoService.Repository.QueryData(x => x.RoadwayNo == "2" && x.LocationStatus == (int)LocationStatusEnum.Free && x.Depth == 1 && x.EnableStatus == (int)EnableStatusEnum.Normal && x.LocationType == (int)LocationTypeEnum.MaterialsCube);

        //                    if (dt_StockInfo == null)
        //                    {
        //                        Dt_StockInfo dt_Stock = new()
        //                        {
        //                            PalletCode = generate.PalletCode,
        //                            IsFull = true,
        //                            StockStatus = (int)StockStatusEmun.组盘暂存,
        //                            Creater = "WMS",
        //                            CreateDate = DateTime.Now,
        //                            MaterialType = (int)InventoryMaterialType.原材料,
        //                            Materialweight = decimal.Parse(targetCodes[3]),
        //                            Wlstatus = (int)InventoryMaterialStatus.待检,
        //                            Mgeneratetime = DateTime.Now,
        //                        };
        //                        _unitOfWorkManage.BeginTran();
        //                        _stockService.StockInfoService.Repository.AddData(dt_Stock);
        //                        Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                        string part2 = targetCodes[1].Substring(0, 2);  //解析物料批次找详情
        //                        Dt_InboundOrder dt_Int = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.UpperOrderNo == part2);

        //                        Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                        {
        //                            StockId = dt_StockInfo2.Id,
        //                            MaterielCode = dt_Inbound.OrderName,    //物料号
        //                            MaterielName = dt_Inbound.UpperOrderNo,    //物料名称
        //                            OrderNo = dt_Inbound.OrderNo,        //物料详情
        //                            BatchNo = targetCodes[1].ToString(),         //物料批次
        //                            SerialNumber = targetCodes[2].ToString(),    //包号
        //                            BatchNoName = dt_Int.OrderNo,
        //                            //StockQuantity = decimal.Parse(targetCodes[3].ToString()),    //重量
        //                            OutboundQuantity = 1,    //序列号
        //                            Status = (int)StockStatusEmun.组盘暂存,
        //                            Creater = "WMS",
        //                            CreateDate = DateTime.Now,

        //                        };
        //                        _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);
        //                        _unitOfWorkManage.CommitTran();
        //                        if (locationInfos.Count < 50)
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 1);
        //                        }
        //                        else
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 3);
        //                        }
        //                    }
        //                    else
        //                    {
        //                        if (dt_StockInfo.StockStatus == (int)StockStatusEmun.组盘暂存)
        //                        {
        //                            if (locationInfos.Count < 50)
        //                            {
        //                                return content = WebResponseContent.Instance.OK(data: 1);
        //                            }
        //                            else
        //                            {
        //                                return content = WebResponseContent.Instance.OK(data: 3);
        //                            }
        //                        }
        //                        else
        //                        {
        //                            return content = WebResponseContent.Instance.Error($"库存已有该条码，条码信息：{generate.PalletCode}");
        //                        }

        //                    }
        //                }
        //                else if (dt_Inbound.OrderType == (int)InventoryMaterialType.成品)
        //                {
        //                    if (dt_StockInfo == null)
        //                    {
        //                        Dt_StockInfo dt_Stock = new()
        //                        {
        //                            PalletCode = generate.PalletCode,
        //                            IsFull = true,
        //                            StockStatus = (int)StockStatusEmun.组盘暂存,
        //                            Creater = "WMS",
        //                            CreateDate = DateTime.Now,
        //                            MaterialType = (int)InventoryMaterialType.成品,
        //                            Materialweight = decimal.Parse(targetCodes[3]),
        //                            Wlstatus = (int)InventoryMaterialStatus.待检,
        //                            Mgeneratetime = DateTime.Now,
        //                        };
        //                        _unitOfWorkManage.BeginTran();
        //                        _stockService.StockInfoService.Repository.AddData(dt_Stock);
        //                        Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                        Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                        {
        //                            StockId = dt_StockInfo2.Id,
        //                            MaterielCode = dt_Inbound.OrderName,    //物料号
        //                            MaterielName = dt_Inbound.UpperOrderNo,    //物料名称
        //                            OrderNo = dt_Inbound.OrderNo,        //物料详情
        //                            BatchNo = targetCodes[1].ToString(),         //物料批次
        //                            BatchNoName = "",
        //                            SerialNumber = targetCodes[2],    //包号
        //                            //StockQuantity = decimal.Parse(targetCodes[3]),    //重量
        //                            OutboundQuantity = 1,    //序列号
        //                            Status = (int)StockStatusEmun.组盘暂存,
        //                            Creater = "WMS",
        //                            CreateDate = DateTime.Now,
        //                        };
        //                        _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);
        //                        _unitOfWorkManage.CommitTran();
        //                        return content = WebResponseContent.Instance.OK(data: 1);
        //                    }
        //                    else
        //                    {
        //                        if (dt_StockInfo.StockStatus == (int)StockStatusEmun.组盘暂存)
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 1);
        //                        }
        //                        else
        //                        {
        //                            return content = WebResponseContent.Instance.Error($"库存已有该条码，条码信息：{generate.PalletCode}");
        //                        }
        //                    }
        //                }
        //                else
        //                {
        //                    return content = WebResponseContent.Instance.Error($"未找到条码解析，条码信息：{generate.PalletCode}");
        //                }
        //            }
        //            else
        //            {
        //                return content = WebResponseContent.Instance.Error($"未找到入库单，条码信息：{generate.PalletCode}");
        //            }

        //        }
        //        else
        //        {
        //            return content = WebResponseContent.Instance.Error($"解析的托盘条码长度不足4,条码信息：{generate.PalletCode}");
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        return content = WebResponseContent.Instance.Error($"系统巷道入库接口解析错误：错误：{ex.Message}");
        //        throw;
        //    }
        //}

        //public WebResponseContent Queryinventory2(GenerateInv generate)
        //{
        //    try
        //    {
        //        WebResponseContent content = new WebResponseContent();
        //        string result = generate.PalletCode.Substring(0, 2);
        //        if (result == "B-")
        //        {
        //            Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //            if (dt_StockInfo == null)
        //            {
        //                Dt_StockInfo dt_Stock = new()
        //                {
        //                    PalletCode = generate.PalletCode,
        //                    IsFull = true,
        //                    StockStatus = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                    MaterialType = (int)InventoryMaterialType.成品,
        //                    Materialweight = 0,
        //                };
        //                _unitOfWorkManage.BeginTran();
        //                _stockService.StockInfoService.Repository.AddData(dt_Stock);

        //                //string part2 = generate.PalletCode.Substring(2, 8);

        //                //string part3 = generate.PalletCode.Split('#')[1];
        //                Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                {
        //                    StockId = dt_StockInfo2.Id,
        //                    MaterielCode = dt_StockInfo2.PalletCode,    //物料编号
        //                    MaterielName = dt_StockInfo2.PalletCode,    //材质
        //                    OrderNo = dt_StockInfo2.PalletCode,        //单据（托盘条码）
        //                    BatchNo = dt_StockInfo2.PalletCode,         //批次号
        //                    SerialNumber = dt_StockInfo2.PalletCode,    //序列号
        //                    StockQuantity = 1,    //序列号
        //                    OutboundQuantity = 1,    //序列号
        //                    Status = (int)StockStatusEmun.组盘暂存,
        //                    Creater = "WMS",
        //                    CreateDate = DateTime.Now,
        //                };
        //                _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);

        //                _unitOfWorkManage.CommitTran();
        //                return content = WebResponseContent.Instance.OK(data: 1);
        //            }
        //            else
        //            {
        //                if (dt_StockInfo.StockStatus == (int)StockStatusEmun.组盘暂存)
        //                {
        //                    return content = WebResponseContent.Instance.OK(data: 1);
        //                }
        //                else
        //                {
        //                    return content = WebResponseContent.Instance.Error($"库存已有该条码，条码信息：{generate.PalletCode}");
        //                }
        //            }
        //        }
        //        else
        //        {
        //            Dt_InboundOrder dt_Inbound = _inboundService.InbounOrderService.Repository.QueryFirst(x => x.UpperOrderNo == result);
        //            Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //            List<Dt_LocationInfo> locationinfoData = _basicService.LocationInfoService.Repository.QueryData(x => x.RoadwayNo == "2" && x.LocationStatus == LocationStatusEnum.Free.ObjToInt()
        //                    && x.LocationType == (int)LocationTypeEnum.MaterialsCube);
        //            if (dt_Inbound != null)
        //            {
        //                if (dt_StockInfo == null)
        //                {
        //                    Dt_StockInfo dt_Stock = new()
        //                    {
        //                        PalletCode = generate.PalletCode,
        //                        IsFull = true,
        //                        StockStatus = (int)StockStatusEmun.组盘暂存,
        //                        Creater = "WMS",
        //                        CreateDate = DateTime.Now,
        //                        MaterialType = (int)InventoryMaterialType.原材料,
        //                        Materialweight = 0,
        //                    };
        //                    _unitOfWorkManage.BeginTran();
        //                    _stockService.StockInfoService.Repository.AddData(dt_Stock);

        //                    string part2 = generate.PalletCode.Substring(2, 8);

        //                    string part3 = generate.PalletCode.Split('#')[1];
        //                    Dt_StockInfo dt_StockInfo2 = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == generate.PalletCode);
        //                    Dt_StockInfoDetail dt_StockInfoDetail = new()
        //                    {
        //                        StockId = dt_StockInfo2.Id,
        //                        MaterielCode = result,    //物料编号
        //                        MaterielName = dt_Inbound.OrderNo,    //材质
        //                        OrderNo = generate.PalletCode,        //单据（托盘条码）
        //                        BatchNo = part2,         //批次号
        //                        SerialNumber = part3,    //序列号
        //                        StockQuantity = 1,    //序列号
        //                        OutboundQuantity = 1,    //序列号
        //                        Status = (int)StockStatusEmun.组盘暂存,
        //                        Creater = "WMS",
        //                        CreateDate = DateTime.Now,
        //                    };
        //                    _stockService.StockInfoDetailService.AddData(dt_StockInfoDetail);

        //                    _unitOfWorkManage.CommitTran();


        //                    if (locationinfoData.Count > 40)
        //                    {
        //                        return content = WebResponseContent.Instance.OK(data: 3);
        //                    }
        //                    else
        //                    {
        //                        return content = WebResponseContent.Instance.OK(data: 1);
        //                    }

        //                }
        //                else
        //                {
        //                    if (dt_StockInfo.StockStatus == (int)StockStatusEmun.组盘暂存)
        //                    {
        //                        if (locationinfoData.Count > 40)
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 3);
        //                        }
        //                        else
        //                        {
        //                            return content = WebResponseContent.Instance.OK(data: 1);
        //                        }
        //                    }
        //                    else
        //                    {
        //                        return content = WebResponseContent.Instance.Error($"库存已有该条码，条码信息：{generate.PalletCode}");
        //                    }
        //                }

        //            }
        //            else
        //            {
        //                return content = WebResponseContent.Instance.Error("未找到该类型的解析");
        //            }

        //        }
        //    }
        //    catch (Exception ex)
        //    {

        //        throw;
        //    }
        //}
    }
}