using HH.WCS.Mobox3.pinggao.device;
using HH.WCS.Mobox3.pinggao.dispatch;
using HH.WCS.Mobox3.pinggao.models;
using HH.WCS.Mobox3.pinggao.process;
using HH.WCS.Mobox3.pinggao.util;
using HH.WCS.Mobox3.pinggao.wms;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using static HH.WCS.Mobox3.pinggao.api.ApiModel;
using static HH.WCS.Mobox3.pinggao.api.OtherModel;
using static HH.WCS.Mobox3.pinggao.wms.WMSHelper;

namespace HH.WCS.Mobox3.pinggao.api
{
    /// <summary>
    /// api接口辅助类
    /// </summary>
    public class ApiHelper
    {
        static ApiHelper()
        {

        }


        internal static SimpleResult Putaway_Order_In(Putaway_Order_In model)
        {
            var result = new SimpleResult();
            //创建入库单主子表
            var po = WMSHelper.GetPutawayOrder(model.Data.arrival_no);
            if (po == null)
            {
                po = new PutawayOrder { S_NO = model.Data.arrival_no, S_BS_TYPE = model.Data.op_type };
                po.Details = new List<PutawayDetail>();
                if (model.Data.items.Count > 0)
                {
                    model.Data.items.ForEach(a =>
                    {
                        po.Details.Add(new PutawayDetail
                        {
                            S_PUTAWAY_NO = model.Data.arrival_no,
                            N_ROW_NO = po.Details.Count + 1,
                            S_ITEM_CODE = a.item_code,
                            F_QTY = a.qty,
                            S_BATCH_NO = a.batch_no,
                        });
                    });
                    WMSHelper.CreatePutawayOrder(po);
                }

            }
            return result;
        }




        internal static WeiLiResult AddTask(AddTaskModel model)
        {
            var result = new WeiLiResult();
            var db = new SqlHelper<object>().GetInstance();
            var cntrweight = model.cntrWeight == 1 ? 2 : model.cntrWeight == 2 ? 3 : model.cntrWeight == 3 ? 11 : model.cntrWeight == 4 ? 30 : model.cntrWeight == 5 ? 150 : 0;
            if (!string.IsNullOrEmpty(model.startBit) && !string.IsNullOrEmpty(model.endBit))
            {
                if (!string.IsNullOrEmpty(model.TaskNo))
                {
                    var taskinfo = db.Queryable<WMSTask>().Where(a => a.S_CODE == model.TaskNo).First();
                    if (taskinfo == null)
                    {
                        var startinfo = db.Queryable<Location>().Where(a => a.S_CODE == model.startBit).First();
                        var endinfo = db.Queryable<Location>().Where(a => a.S_CODE == model.endBit).First();
                        if (startinfo != null && endinfo != null)
                        {
                            if (startinfo.N_LOCK_STATE != 0 || endinfo.N_LOCK_STATE != 0)
                            {
                                result.code = 500;
                                result.msg = "起点或终点货位锁定状态异常 不予创建任务";
                                return result;
                            }

                            var startloccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == startinfo.S_CODE).First();
                            LogHelper.Info("查询起点是否绑定托盘");
                            if (startloccntr == null)
                            {
                                LogHelper.Info("起点未绑定托盘 准备绑定托盘");
                                //绑定起点托盘
                                LocationHelper.BindingLoc(model.startBit, new List<string>() { model.cntrNo });
                            }
                            else if (startloccntr.S_CNTR_CODE != model.cntrNo)
                            {
                                result.code = 500;
                                result.msg = $"起点已绑定托盘{startloccntr.S_CNTR_CODE} 与任务托盘{model.cntrNo} 不符";
                                return result;
                            }

                            LogHelper.Info("转运任务 创建作业");

                            //创建作业
                            var optask = new WMSTask
                            {
                                S_CODE = model.TaskNo,
                                S_START_LOC = startinfo.S_CODE,
                                S_END_LOC = endinfo.S_CODE,
                                S_END_AREA = endinfo.S_AREA_CODE,
                                S_START_AREA = startinfo.S_AREA_CODE,
                                S_START_WH = startinfo.S_WH_CODE,
                                S_END_WH = endinfo.S_WH_CODE,
                                S_TYPE = "转运",
                                N_TYPE = 3,
                                N_B_STATE = 0,
                                S_CNTR_CODE = model.cntrNo,
                                S_OP_DEF_NAME = "转运",
                                S_BS_NO = model.workNo,
                                N_PRIORITY = model.priority,
                                //N_TRAY_WEIGHT = cntrweight
                            };

                            var note = Settings.Tasktypes.Where(a => a.StartArea == optask.S_START_AREA && a.EndArea == optask.S_END_AREA).FirstOrDefault();
                            if (note != null)
                            {
                                optask.S_NOTE = note.TaskType;
                            }



                            db.Insertable(optask).ExecuteCommand();
                            LocationHelper.LockLoc(startinfo.S_CODE, 2);
                            LocationHelper.LockLoc(endinfo.S_CODE, 1);
                        }
                        else
                        {
                            result.code = 500;
                            result.msg = "起点或终点信息有误 查询不到站点信息";
                        }
                    }
                    else
                    {
                        result.code = 500;
                        result.msg = "任务号重复 请勿重复下发任务";
                    }
                }
                else
                {
                    result.code = 500;
                    result.msg = "任务号不能为空";
                }
            }
            else
            {
                result.code = 500;
                result.msg = "起点或终点不能为空";
            }

            return result;
        }

        internal static TaskStateresutl GetTaskState(GetTaskStateModel model)
        {
            var db = new SqlHelper<object>().GetInstance();
            TaskStateresutl result = new TaskStateresutl { success = false, code = 0 };
            if (!string.IsNullOrEmpty(model.taskNo))
            {
                var info = db.Queryable<WCSTask>().Where(a => a.S_OP_CODE == model.taskNo).First();
                if (info != null)
                {
                    var TaskStates = db.Queryable<TaskAction>().Where(a => a.S_TASK_CODE == info.S_CODE).ToList();
                    TaskStates = TaskStates.OrderBy(a => a.T_CREATE).ToList();
                    for (int i = 0; i < TaskStates.Count; i++)
                    {
                        TaskState task = new TaskState
                        {
                            state = TaskStates[i].N_ACTION_CODE.ToString(),
                            errMsg = "",
                            taskNo = model.taskNo,
                            transferTime = TaskStates[i].T_CREATE.ToString()
                        };
                        if (!string.IsNullOrEmpty(TaskStates[i].S_EQ_CODE))
                        {
                            task.agvNo = int.Parse(TaskStates[i].S_EQ_CODE);
                        }
                        result.data.Add(task);
                    }
                    result.success = true;
                }
                else
                {
                    result.code = 1;
                    result.msg = "该任务号没有状态记录!";
                }
            }
            else
            {
                result.code = 1;
                result.msg = "请求任务号不能为空!";
            }
            return result;
        }






        internal static PlcSendTaskres PlcCallbackState(PlcState model)
        {
            var db = new SqlHelper<object>().GetInstance();
            var result = new PlcSendTaskres { requestPk = model.requestPk, code = "0" };
            string message = "";
            if (model.noticeType == "0")
            {
                //称重
            }
            else
            {
                var task = WCSHelper.GetTask(model.requestPk);
                if (task != null)
                {
                    //if (!WCSHelper.CheckActionRecordExist(task.S_CODE, int.Parse(model.noticeType)))
                    //{
                    switch (model.noticeType)
                    {
                        case "3":
                            //执行状态
                            WCSHelper.Begin(task);
                            WCSHelper.UpdateStorStatus(task.S_CNTR_CODE, 3);
                            break;
                        case "2":
                            //完成状态 (出库任务生成第二段agv任务) 解绑起点终点
                            //if (task.S_B_STATE != "取消" && task.S_B_STATE != "完成" && task.S_B_STATE != "关闭" && task.S_B_STATE != "强制完成")
                            //{
                            TaskProcess.OperateStatus(task, 4);
                            TaskProcess.OperateStatus(task, 6);
                            if (task.S_TYPE.Contains("入库"))
                            {
                                WMSHelper.AddChange(task);
                            }
                            //TaskProcess.PlcSencondTask(task);
                            WCSHelper.End(task);
                            WMSHelper.End(task);
                            //}
                            break;
                        case "8":
                            //取货无货(释放货位)
                            quhuowuhuo(db, task);
                            break;
                    }
                    WCSHelper.AddActionRecord(task.S_CODE, int.Parse(model.noticeType), "", "");
                    //}
                }
                else
                {
                    result.code = "1";
                    result.msg = "该任务编号不存在";
                }
            }
            return result;
        }

        internal static SimpleResult OutboundOrderExecute(OutboundOrderCheck model)
        {
            var result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();
            var nolist = model.out_no.Split(',').ToList();
            nolist.ForEach(a =>
            {
                var OutboundOrder = db.Queryable<TN_Outbound_Order>().Where(it => it.S_NO == a && it.N_B_STATE == 0).Includes(it => it.Details).First();
                if (OutboundOrder != null)
                {
                    var res = false;
                    for (int i = 0; i < OutboundOrder.Details.Count; i++)
                    {
                        var detail = OutboundOrder.Details[i];
                        var whi = db.Queryable<WHInventory>().Where(w => w.S_ITEM_CODE == detail.S_ITEM_CODE).First();
                        if (whi != null && whi.F_QTY - whi.F_ALLOC_QTY > 0)
                        {
                            res = true;
                            Expression<Func<CntrItemRel, bool>> expression = x => x.S_ITEM_CODE == detail.S_ITEM_CODE;
                            expression.AndAlso(x => x.Cntr.C_ENABLE == "Y");
                            expression.AndAlso(x => (x.F_QTY - x.F_ALLOC_QTY) > (detail.F_QTY - detail.F_ACC_D_QTY));
                            expression.AndAlso(x => (x.F_QTY - x.F_ALLOC_QTY) / 2 < (detail.F_QTY - detail.F_ACC_D_QTY));
                            if (!string.IsNullOrEmpty(detail.S_BATCH_NO)) expression.AndAlso(x => x.S_BATCH_NO == detail.S_BATCH_NO);
                            if (!string.IsNullOrEmpty(detail.S_OWNER)) expression.AndAlso(x => x.S_OWNER == detail.S_OWNER);
                            //if (!string.IsNullOrEmpty(detail.S_ERP_WH_CODE)) expression.AndAlso(x => x.S_ERP_WH_CODE == detail.S_ERP_WH_CODE);
                            var bol = false;
                            var fjlist = db.Queryable<CntrItemRel>().Includes(c => c.Cntr)
                            .Where(expression)
                            .OrderBy(c => c.T_CREATE)
                            .ToList();
                            for (int j = 0; j < fjlist.Count; j++)
                            {
                                //检测这个托盘物料是否单一
                                var cir = fjlist[j];
                                //var isfj = db.Queryable<TN_Distribution_CNTR>().Where(c => c.S_CNTR_CODE == cir.S_CNTR_CODE && c.C_REVERSE == "Y" && c.N_B_STATE < 2).First();
                                //if (isfj == null)
                                //{
                                //    var itemlist = db.Queryable<CntrItemRel>().Where(c => c.S_CNTR_CODE == cir.S_CNTR_CODE && c.F_QTY > 0).ToList();
                                //    if (itemlist.Count == 1)
                                //    {
                                //        var dc_no = WMSHelper.GenerateDistrbutionCntrNo();
                                //        bol = true;
                                //        var dc = new TN_Distribution_CNTR
                                //        {
                                //            S_DC_NO = dc_no,
                                //            S_BS_NO = detail.S_DO_NO,
                                //            S_BS_TYPE = OutboundOrder.S_BS_TYPE,
                                //            S_CNTR_CODE = cir.S_CNTR_CODE,
                                //            S_EXIT_AREA_CODE = OutboundOrder.S_AREA_CODE,
                                //            S_OP_TYPE = OutboundOrder.S_BS_TYPE,
                                //            C_REVERSE = "Y"
                                //        };
                                //        db.Insertable(dc).ExecuteCommand();
                                //
                                //        var dc_detail = new TN_Distribution_CNTR_Detail
                                //        {
                                //            S_ITEM_CODE = detail.S_ITEM_CODE,
                                //            S_ITEM_NAME = detail.S_ITEM_NAME,
                                //            S_BATCH_NO = detail.S_BATCH_NO,
                                //            S_ERP_WH_CODE = detail.S_ERP_WH_CODE,
                                //            S_SUPPLIER_NO = detail.S_SUPPLIER_NO,
                                //            S_OWNER = detail.S_OWNER,
                                //            N_BS_ROW_NO = detail.N_ROW_NO,
                                //            S_BS_TYPE = OutboundOrder.S_BS_TYPE,
                                //            S_DC_NO = dc_no,
                                //            S_BS_NO = OutboundOrder.S_NO,
                                //            F_QTY = (itemlist[0].F_QTY - itemlist[0].F_ALLOC_QTY) - (detail.F_QTY - detail.F_ACC_D_QTY),
                                //        };
                                //        db.Insertable(dc_detail).ExecuteCommand();
                                //        //更新容器货品表分配量
                                //        cir.F_ALLOC_QTY += (float)dc_detail.F_QTY;
                                //        cir.T_MODIFY = DateTime.Now;
                                //        db.Updateable(cir).UpdateColumns(it => new { it.F_ALLOC_QTY, it.T_MODIFY }).ExecuteCommand();
                                //        //更新分拣单子表的量
                                //        detail.F_ACC_D_QTY += detail.F_QTY - detail.F_ACC_D_QTY;
                                //        detail.T_MODIFY = DateTime.Now;
                                //        db.Updateable(detail).UpdateColumns(it => new { it.F_ACC_D_QTY, it.T_MODIFY }).ExecuteCommand();
                                //        whi.F_ALLOC_QTY += (float)(detail.F_QTY - detail.F_ACC_D_QTY);
                                //        whi.T_MODIFY = DateTime.Now;
                                //        db.Updateable(whi).UpdateColumns(it => new { it.F_ALLOC_QTY, it.T_MODIFY }).ExecuteCommand();
                                //        break;
                                //    }
                                //}
                            }


                            Expression<Func<CntrItemRel, bool>> expression1 = x => x.S_ITEM_CODE == detail.S_ITEM_CODE;
                            expression1.AndAlso(x => x.Cntr.C_ENABLE == "Y");
                            expression1.AndAlso(x => (x.F_QTY - x.F_ALLOC_QTY) > 0);
                            if (!string.IsNullOrEmpty(detail.S_BATCH_NO)) expression1.AndAlso(x => x.S_BATCH_NO == detail.S_BATCH_NO);
                            if (!string.IsNullOrEmpty(detail.S_OWNER)) expression1.AndAlso(x => x.S_OWNER == detail.S_OWNER);
                            //if (!string.IsNullOrEmpty(detail.S_ERP_WH_CODE)) expression1.AndAlso(x => x.S_ERP_WH_CODE == detail.S_ERP_WH_CODE);

                            if (!bol)
                            {
                                //按分拣单子表去配货，查找可用托盘(先查所有符合的，后面再优化)
                                var cirList = db.Queryable<CntrItemRel>().Includes(c => c.Cntr)
                                .Where(expression1)
                                .OrderBy(c => c.T_CREATE)
                                .ToList();
                                for (int j = 0; j < cirList.Count; j++)
                                {
                                    var cir = cirList[j];
                                    //var isfj = db.Queryable<TN_Distribution_CNTR>().Where(c => c.S_CNTR_CODE == cir.S_CNTR_CODE && c.C_REVERSE == "Y" && c.N_B_STATE < 2).First();
                                    //if (isfj == null)
                                    //{
                                    //    var dc_no = WMSHelper.GenerateDistrbutionCntrNo();
                                    //    bol = true;
                                    //    var dc = new TN_Distribution_CNTR
                                    //    {
                                    //        S_DC_NO = dc_no,
                                    //        S_BS_NO = detail.S_DO_NO,
                                    //        S_BS_TYPE = OutboundOrder.S_BS_TYPE,
                                    //        S_CNTR_CODE = cir.S_CNTR_CODE,
                                    //        S_EXIT_AREA_CODE = OutboundOrder.S_AREA_CODE,
                                    //        S_OP_TYPE = OutboundOrder.S_BS_TYPE
                                    //    };
                                    //    db.Insertable(dc).ExecuteCommand();
                                    //    var dc_detail = new TN_Distribution_CNTR_Detail
                                    //    {
                                    //        S_ITEM_CODE = detail.S_ITEM_CODE,
                                    //        S_ITEM_NAME = detail.S_ITEM_NAME,
                                    //        S_BATCH_NO = detail.S_BATCH_NO,
                                    //        S_ERP_WH_CODE = detail.S_ERP_WH_CODE,
                                    //        S_SUPPLIER_NO = detail.S_SUPPLIER_NO,
                                    //        S_OWNER = detail.S_OWNER,
                                    //        N_BS_ROW_NO = detail.N_ROW_NO,
                                    //        S_BS_TYPE = OutboundOrder.S_BS_TYPE,
                                    //        S_DC_NO = dc_no,
                                    //        S_BS_NO = OutboundOrder.S_NO,
                                    //    };
                                    //    bool needBreak = false;
                                    //    if (cir.F_QTY - cir.F_ALLOC_QTY >= (detail.F_QTY - detail.F_ACC_D_QTY))
                                    //    {
                                    //        dc_detail.F_QTY = detail.F_QTY - detail.F_ACC_D_QTY;
                                    //        needBreak = true;
                                    //    }
                                    //    else
                                    //    {
                                    //        //生成分拣明细，继续创建
                                    //        dc_detail.F_QTY = cir.F_QTY - cir.F_ALLOC_QTY;
                                    //    }
                                    //    db.Insertable(dc_detail).ExecuteCommand();
                                    //    //更新容器货品表分配量
                                    //    cir.F_ALLOC_QTY += (float)dc_detail.F_QTY;
                                    //    cir.T_MODIFY = DateTime.Now;
                                    //    db.Updateable(cir).UpdateColumns(it => new { it.F_ALLOC_QTY, it.T_MODIFY }).ExecuteCommand();
                                    //    //更新分拣单子表的量
                                    //    detail.F_ACC_D_QTY += dc_detail.F_QTY;
                                    //    detail.T_MODIFY = DateTime.Now;
                                    //    db.Updateable(detail).UpdateColumns(it => new { it.F_ACC_D_QTY, it.T_MODIFY }).ExecuteCommand();
                                    //    whi.F_ALLOC_QTY += (float)dc_detail.F_QTY;
                                    //    whi.T_MODIFY = DateTime.Now;
                                    //    db.Updateable(whi).UpdateColumns(it => new { it.F_ALLOC_QTY, it.T_MODIFY }).ExecuteCommand();
                                    //    if (needBreak)
                                    //    {
                                    //        break;
                                    //    }
                                    //}
                                }
                            }
                        }
                        else
                        {
                            //修改出库单明细状态为缺件
                        }
                    }
                }

                //修改出库单状态为执行 
            });

            return result;
        }

        private static void quhuowuhuo(SqlSugarClient db, WCSTask task)
        {
            TaskProcess.OperateStatus(task, 7);
            task.S_NOTE = "异常";
            db.Updateable(task).UpdateColumns(it => new { it.S_NOTE }).ExecuteCommand();
        }







        internal static WeiLiResult CancelOrder(CancelOrderModel model)
        {
            WeiLiResult result = new WeiLiResult();
            var db = new SqlHelper<object>().GetInstance();
            var tasks = db.Queryable<WCSTask>().Where(a => a.S_OP_CODE == model.orderNo).ToList();
            if (tasks.Count >= 1)
            {
                //流程任务数量执行超过一条 任务不允许取消
                result.code = 500;
                result.msg = "流程任务执行中途不允许取消";
                return result;
            }
            var task = db.Queryable<WCSTask>().Where(a => a.S_OP_CODE == model.orderNo).OrderByDescending(a => a.T_CREATE).First();
            if (task != null)
            {
                if (WCSHelper.CheckActionRecordExist(task.S_CODE, 4))
                {
                    result.code = 500;
                    result.msg = "任务已取货完成 不允许取消";
                    return result;
                }
                if (task.N_B_STATE == 0)
                {
                    //等待直接修改状态为取消
                    WCSHelper.UpdateStatus(model.orderNo, 5);
                    //result.msg = "任务等待，直接取消";
                }
                else if (task.N_B_STATE != 3 && task.N_B_STATE != 4)
                {
                    if (task.S_TYPE == "杭奥")
                    {
                        //通知立库取消任务
                    }
                    else
                    {
                        //已推送但是没有完成或者取消，通知hosttoagv
                        NDCHelper.Cancel(task.S_CODE.Trim());
                        //result.msg = "任务取消已经发送给小车";
                    }
                }
                else
                {
                    result.code = 500;
                    result.msg = "任务已结束";
                }
            }
            else
            {
                result.code = 500;
                result.msg = "任务不存在";
            }
            return result;
        }



        internal static WeiLiResult ChangeOrderPrioryty(ChangeOrderPriorytyModel model)
        {
            WeiLiResult result = new WeiLiResult();
            var db = new SqlHelper<object>().GetInstance();
            var task = db.Queryable<WCSTask>().Where(a => a.S_OP_CODE == model.orderNo).OrderByDescending(a => a.T_CREATE).First();
            if (task != null)
            {
                if (task.N_B_STATE == 0)
                {
                    //等待直接修改状态为取消
                    WCSHelper.UpdatePrioryty(task, model.priority);
                    result.msg = "修改优先级成功";
                }
                else if (task.N_B_STATE != 3 && task.N_B_STATE != 4)
                {
                    if (task.S_TYPE == "杭奥")
                    {
                        //通知立库修改任务优先级
                        result.msg = "修改优先级成功";
                    }
                    else
                    {
                        //通知杭叉修改优先级
                        NDCHelper.Cancel(task.S_CODE.Trim());
                        result.msg = "修改优先级成功";
                    }
                }
                else
                {
                    result.code = 500;
                    result.msg = "任务已结束";
                }
            }
            else
            {
                result.code = 500;
                result.msg = "任务不存在";
            }
            return result;
        }













        internal static SimpleResult PalletSorting(PalletSorting model)
        {
            var result = new SimpleResult();
            //校验入库单数量，不可以超，成功后插入托盘物料表，更新入库单累计数量
            //也可以直接lua查询入库单数量，做校验
            var info = WMSHelper.GetPutawayOrderDetail(model.arrival_no, model.item_code);
            if (info != null)
            {
                if (info.F_QTY - info.F_ACC_B_QTY >= model.qty)
                {
                    // 插入到托盘明细表
                    var cntr = ContainerHelper.GetCntr(model.cntr_code, true);
                    if (cntr != null)
                    {
                        ContainerHelper.BindCntrItem(cntr, model.item_code, info.S_BATCH_NO, model.qty, model.arrival_no);
                        //更新入库单累计绑定数量
                        info.F_ACC_B_QTY += model.qty;
                        WMSHelper.UpdatePutawayOrderDetailQty(info);
                    }
                    else
                    {
                        result.resultCode = 2;
                        result.resultMsg = "获取托盘信息失败";
                    }
                }
                else
                {
                    result.resultCode = 1;
                    result.resultMsg = "累计码盘数量超出入库单数量";
                }
            }
            else
            {
                result.resultCode = 3;
                result.resultMsg = $"未找到入库单{model.arrival_no}";
            }

            return result;
        }




        public class ReceivingNoteSerialNo
        {
            public List<serial> data { get; set; } = new List<serial>();
            public class serial
            {
                public string rowID { get; set; }
                public List<string> serialNo { get; set; } = new List<string>();
            }
        }
        internal static SimpleResult OutboundOrder(OutboundOrder model)
        {
            var result = new SimpleResult();
            //创建发货单，人工点确认后生成分拣单，没有缺货的自动更新为失败，有货的更新为执行中
            //创建入库单主子表
            var po = WMSHelper.GetShippingOrder(model.Data.out_no);
            if (po == null)
            {
                po = new ShippingOrder { S_NO = model.Data.out_no, S_BS_TYPE = model.Data.op_type, LINE_AREA = model.Data.line_area };
                po.Details = new List<ShippingDetail>();
                if (model.Data.items.Count > 0)
                {
                    model.Data.items.ForEach(a =>
                    {
                        po.Details.Add(new ShippingDetail
                        {
                            S_SHIPPING_NO = model.Data.out_no,
                            N_ROW_NO = po.Details.Count + 1,
                            S_ITEM_CODE = a.item_code,
                            F_QTY = a.qty,
                            S_BATCH_NO = a.batch_no,
                        });
                    });
                    WMSHelper.CreateShippingOrder(po);
                }

            }
            return result;
        }

        internal static SimpleResult ShippingOrderExecute(ShippingOrderCheck model)
        {
            var result = new SimpleResult();
            //检查库存，更新发货单，生成分拣单，自动合并波次
            //这个后台做比较麻烦，mobox3库存在内存中，任务完成的时候无法增加，还是用c#直接管内存，计算比较方便
            WMSHelper.CreateSortingOrder(model.out_nos.Split(',').ToList());
            return result;
        }

        /// <summary>
        /// 后面要把方法放到wmsHelper中
        /// </summary>
        /// <param name="models"></param>
        /// <returns></returns>
        internal static SimpleResult SortingResultCheck(List<SortingResultCheck> models)
        {
            //生成分拣结果，更新分拣明细状态
            var result = new SimpleResult();
            WMSHelper.SortingConfrim(models);
            return result;
        }

        internal static SimpleResult NdcRecives(NdcDto dto)
        {
            SimpleResult result = new SimpleResult();
            result.resultCode = 0;
            result.resultMsg = "成功";
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var locinfo = db.Queryable<Location>().Where(a => a.S_CODE == dto.From).First();
                if (locinfo?.N_LOCK_STATE != 0)
                {
                    result.resultCode = 1;
                    result.resultMsg = "起始库位已锁/不存在";
                    LogHelper.Info("起始库位已锁");
                    return result;
                }
                var endlocinfo = db.Queryable<Location>().Where(a => a.S_CODE == dto.To).First();
                if (endlocinfo?.N_LOCK_STATE != 0)
                {
                    result.resultCode = 1;
                    result.resultMsg = "终点库位已锁/不存在";
                    LogHelper.Info("终点库位已锁");
                    return result;
                }

                var wcsTask = new WCSTask
                {
                    S_OP_CODE = "",
                    S_OP_NAME = "",
                    S_CODE = WCSHelper.GenerateTaskNo(),
                    S_TYPE = "转运",
                    S_START_LOC = dto.From,
                    S_START_AREA = locinfo.S_AREA_CODE,
                    S_START_WH = locinfo.S_WH_CODE,
                    S_END_LOC = endlocinfo.S_CODE,
                    S_END_AREA = endlocinfo.S_AREA_CODE,
                    S_END_WH = endlocinfo.S_WH_CODE,
                    S_SCHEDULE_TYPE = "NDC",
                    //N_CNTR_COUNT = 1,
                    S_CNTR_CODE = WMSHelper.GenerateCntrCodeNo()
                };

                bool res = WCSHelper.CreateTask(wcsTask);
                if (res)
                {
                    LocationHelper.LockLoc(locinfo.S_CODE, 2);
                    LocationHelper.LockLoc(endlocinfo.S_CODE, 1);
                }

            }
            catch (Exception ex)
            {
                throw;
            }
            return result;

        }

        /// <summary>
        /// 后面要把方法放到wmsHelper中
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResult Instock(InstockInfo model)
        {
            var result = new SimpleResult();
            //pda入库，目前人工放货在巷道口，扫托盘，后台只能计算当前巷道的终点，单深位立库
            //1，判断托盘信息，一种是码盘后的，默认enable是N，另一种是分拣回的
            var cntr = ContainerHelper.GetCntr(model.cntr);
            if (cntr != null)
            {
                var sortingInfo = WMSHelper.GetSortingDetailByCntr(model.cntr);
                if (cntr.C_ENABLE == "Y" && sortingInfo != null && sortingInfo.Count > 0)
                {
                    result.resultCode = 2;
                    result.resultMsg = $"托盘{model.cntr}未分拣完成";
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = $"托盘{model.cntr}不存在";
            }
            if (result.resultCode == 0)
            {
                //获取接驳位所在的巷道, 查找功能区，入库接驳位找逻辑库区（每个巷道一个逻辑库区）
                var fa = LocationHelper.GetFunctionAreaByCode(model.start, 2, 10);
                if (fa != null)
                {
                    //创建入库作业，简单判断一下是否有可入货位，如果不判断，人工货放上去一直不能入，也不知道原因
                    var end = LocationHelper.GetZoneLoc(fa.S_MASTER_CODE);
                    if (end != null)
                    {
                        //判断托盘是否已经生成任务，如果没有则生成
                        var wmsTask = WMSHelper.GetWmsTaskByCntr(model.cntr);
                        if (wmsTask != null)
                        {
                            result.resultCode = 3;
                            result.resultMsg = $"起点{model.start} 托盘{model.cntr}已经创建任务，请勿重复申请";
                        }
                        else
                        {
                            wmsTask = new WMSTask
                            {
                                S_CNTR_CODE = model.cntr,
                                S_CODE = WMSHelper.GenerateTaskNo(),
                                S_START_LOC = model.start,
                                S_END_LOC = end.S_LOC_CODE,
                                N_TYPE = 1,
                                S_TYPE = WMSTask.GetTypeStr(1),
                                S_OP_DEF_CODE = "",
                                S_OP_DEF_NAME = "pda入立库"
                            };
                            if (WMSHelper.CreateWmsTask(wmsTask))
                            {
                                LocationHelper.LockLoc(model.start, 1);
                                result.resultMsg = $"创建作业成功，作业号{wmsTask.S_CODE}";
                            }
                        }
                    }
                    else
                    {
                        result.resultCode = 3;
                        result.resultMsg = $"起点{model.start}对应的逻辑库区{fa.S_MASTER_CODE}没有可用货位，请更换巷道";
                    }
                }
                else
                {
                    result.resultCode = 3;
                    result.resultMsg = $"起点{model.start}没有对应的逻辑库区，请在逻辑库区设置功能区-入库接驳位";
                }
            }
            return result;
        }

        internal static SimpleResult SortingOrderExecute(SortingOrderCheck model)
        {
            var result = new SimpleResult();
            //分拣单配货执行
            WMSHelper.CreateSortingOrderDetail(model.s_no);
            return result;
        }


        internal static SimpleResult CheckSortingWholeCntr(CheckSortingWholeCntr model)
        {
            var result = new SimpleResult();
            if (WMSHelper.CheckSortingWholeCntr(model.cntr, model.autoSort == 1))
            {
                result.resultCode = 1;
                result.resultMsg = "整托分拣";
            }
            return result;
        }
        internal static CodeInfo GetCodeInfo(string code, string org)
        {
            //return new CodeInfo {  Fitemid_XK=code, FSourceNo="123456"};
            CodeInfo result = null;
            try
            {
                var db = new SqlHelper<object>().GetInstance(Settings.SqlServer1);
                var nameP = new SugarParameter("@FBarCode", code);
                var orgP = new SugarParameter("@Forg", org);
                //var ageP = new SugarParameter("@age", null, true);//设置为output
                //var dt = db.Ado.UseStoredProcedure().GetDataTable("sp_school", nameP, ageP);//返回dt
                result = db.Ado.UseStoredProcedure().SqlQuery<CodeInfo>("WMS_FBarCode", nameP, orgP).First();//返回List
                Console.WriteLine($"读存储过程成功,result={result}");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return result;
        }

        internal static SimpleResult PalletSorting1(PalletSorting1 model)
        {
            var result = new SimpleResult();
            //校验入库单数量，不可以超，成功后插入托盘物料表，更新入库单累计数量
            //也可以直接lua查询入库单数量，做校验
            //先用bar_code读存储过程获取信息
            var codeInfo = GetCodeInfo(model.bar_code, model.org);
            var info = WMSHelper.GetPutawayOrderDetail(model.bar_code);
            if (info != null)
            {
                if (info.F_QTY - info.F_ACC_B_QTY >= model.qty)
                {
                    // 插入到托盘明细表

                    var cntr = ContainerHelper.GetCntr(model.cntr_code, true);
                    if (cntr != null)
                    {
                        ContainerHelper.BindCntrItem(cntr, model.bar_code, info.S_BATCH_NO, model.qty, info.S_BATCH_NO);
                        //更新入库单累计绑定数量
                        info.F_ACC_B_QTY += model.qty;
                        WMSHelper.UpdatePutawayOrderDetailQty(info);
                    }
                    else
                    {
                        result.resultCode = 2;
                        result.resultMsg = "获取托盘信息失败";
                    }


                }
                else
                {
                    result.resultCode = 1;
                    result.resultMsg = "累计码盘数量超出入库单数量";
                }
            }
            else
            {
                result.resultCode = 3;
                result.resultMsg = $"未获取到该物料{model.bar_code}的入库单明细信息";
            }

            return result;
        }


        //public class AddTaskModel
        //{
        //    public string From { get; set; }
        //    public string To { get; set; }
        //    public string No { get; set; }
        //}
        public class TN_LocationModel
        {
            public string TN_Location { get; set; }
        }
        public class CodeInfo
        {
            /// <summary>
            /// 生产订单内码
            /// </summary>
            public string FInterID { get; set; }
            /// <summary>
            /// 生产订单编号
            /// </summary>
            public string FSourceNo { get; set; }
            /// <summary>
            /// 批号
            /// </summary>
            public string FGMPBatchNo { get; set; }
            public string FState { get; set; }
            /// <summary>
            /// 物料编码（内码就是编码）
            /// </summary>
            public string Fitemid_XK { get; set; }
            /// <summary>
            /// 分录id
            /// </summary>
            public string Fentryid { get; set; }
        }
        public class NoteInfo : CodeInfo
        {
            public string WmsBillNo { get; set; }
        }
    }
}