using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using yunneiWCS.Common;
using yunneiWCS.data;
using yunneiWCS.DataAccess;
using yunneiWCS.EnumDefine;
using yunneiWCS.EnumDefine.Device;
using yunneiWCS.EnumDefine.InStockOrder;
using yunneiWCS.ORM;
using yunneiWCS.SystemInteraction.tianyong;

namespace yunneiWCS.ExtendFunction
{
    /// <summary>
    /// 增补创建的扩展方法 【EditBy shaocx,2022-02-05】
    /// </summary>
    public class MyExtend
    {

        /// <summary>
        /// 消息时间字符串
        /// </summary>
        /// <returns></returns>
        public static string MsgTimeStr()
        {
            return "[消息时间:" + DateTimeHelper.ConvertToStringForOnlyShowTime(DateTime.Now) + "]";
        }

        /// <summary>
        /// 是否是 物料库存的转移
        /// </summary>
        /// <param name="taskType"></param>
        /// <returns></returns>
        public static bool IsMaterilStockMove(taskType currentTaskType)
        {
            if (currentTaskType == taskType.空库位
                || currentTaskType == taskType.呼叫空托
                 || currentTaskType == taskType.空托回库
                  || currentTaskType == taskType.空托下线入库
                   || currentTaskType == taskType.空托手动入库
                    || currentTaskType == taskType.空托人工出库
                     || currentTaskType == taskType.旁路工位缸体空托回库
                  )
            {
                return false;
            }
            return true;
        }

        public static string HandlerNoIssuedTaskFor旁路工位缸体空托或余料回库(dbmodel mod, string convPlace, task item, string[] agvSendStatus)
        {
            //注意：这个middlePlace是工人自己选的！
            if (convPlace != "")
            {
                SystemWarningMsg.Thread_SendTask_NoIssue_GT_ErrMsg = DateTime.Now.ToString("dd日HH:mm:ss") + "更新状态为已下发成功,任务ID:" + item.taskId;
                item.middlePlace = convPlace;
                //item.taskStatus = 3;
                item.taskStatus = (int)taskStatus.已下发;
                item.remark = "已下发";
                item.remark = "更新状态为已下发成功";
                position unlockPosition = mod.position.FirstOrDefault(x => x.positionName == convPlace);
                if (unlockPosition != null)
                {
                    //unlockPosition.isLock = true;
                    PositionHandler.Lock(true, unlockPosition, "处理未下发的任务(缸体)", SysGloble.WCSNAME, item);
                }
                //起点库位解锁、设置无货 【EditBy shaocx,2022-03-23】
                position _sourcePlace = mod.position.FirstOrDefault(x => x.positionName == item.sourcePlace);
                PositionHandler.LockAndFree(false, false, _sourcePlace, "处理未下发的任务(缸体)，修改起点", SysGloble.WCSNAME, item);

                int saveRes = mod.SaveChanges();
                #region 检验保存是否成功
                for (int i = 0; i < 4; i++)
                {
                    if (saveRes < 1)
                    {
                        saveRes = mod.SaveChanges();
                    }
                    else
                    {
                        break;
                    }
                }
                if (saveRes < 1)
                {
                    WZ.Useful.Commons.LogTextHelper.WriteLine("Form1", "sendTask", "数据库保存失败！ 任务id:" + item.taskId);
                    return "数据库保存失败！ 任务id:" + item.taskId;
                }
                #endregion
            }
            else
            {
                agvSendStatus[0] = DateTime.Now.ToString("dd日HH:mm:ss") + "更新状态为已下发失败，输送线都被占用,任务ID:" + item.taskId;

                //保存失败信息到任务表中 【EditBy shaocx,2022-03-16】
                item.remark = "更新状态为已下发失败，输送线都被占用";
                mod.SaveChanges();
                return DateTime.Now.ToString("dd日HH:mm:ss") + "更新状态为已下发失败，输送线都被占用,任务ID:" + item.taskId;
            }
            return "任务处理成功";
        }

        /// <summary>
        /// 处理未下发的直达上线点的任务
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="isvirtual"></param>
        /// <param name="agvs"></param>
        /// <param name="item"></param>
        /// <param name="agvSendStatus"></param>
        /// <returns>错误消息</returns>
        public static string HandleTaskForNoIssuedForDirectOnLinePoint(dbmodel mod, List<AgvStatus> agvs, task item,
            string[] agvSendStatus
            )
        {
            var errMsg_1 = "处理未下发的任务(HandleTaskForNoIssued):";
            bool isReadAgv = false;
            taskType _taskType = (taskType)Enum.Parse(typeof(taskType), item.taskType.ToString());
            if (_taskType == taskType.缸体下线直接去上线点)
            {
                isReadAgv = MyExtendHelper.ValidateAgvIsFree(item, TaskAreaEnum.缸体侧, agvs, agvSendStatus);
            }
            else if (_taskType == taskType.缸盖下线直接去上线点)
            {
                isReadAgv = MyExtendHelper.ValidateAgvIsFree(item, TaskAreaEnum.缸盖侧, agvs, agvSendStatus);
            }
            var errMsg = "";
            _HandleTaskForNoIssuedForDirectOnLinePoint(isReadAgv, _taskType, mod, agvs, item, agvSendStatus, ref errMsg);
            if (!string.IsNullOrEmpty(errMsg))
                return errMsg_1 + errMsg;



            return errMsg;
        }

        /// <summary>
        /// 处理未下发的直达上线点的任务
        /// </summary>
        /// <param name="isReadAgv"></param>
        /// <param name="_taskType"></param>
        /// <param name="mod"></param>
        /// <param name="agvs"></param>
        /// <param name="item"></param>
        /// <param name="agvSendStatus"></param>
        /// <param name="errMsg"></param>
        private static void _HandleTaskForNoIssuedForDirectOnLinePoint(bool isReadAgv, taskType _taskType, dbmodel mod, List<AgvStatus> agvs, task item,
         string[] agvSendStatus, ref string errMsg
         )
        {
            #region 发送rgv任务
            if (isReadAgv)
            {
                //起点,起点在数据库中没有定义，因此不需要使用

                //目标点
                position to_positionStation = mod.position.FirstOrDefault(x => x.positionName == item.toPlace);
                if (to_positionStation == null)
                {
                    errMsg = "未找到目标库位" + item.toPlace;
                    WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskForNoIssued", errMsg);
                    return;
                }

                #region  验证上线点是否有库存
                var to_Stock = MyExtendHelper.GetProductStockById(mod, to_positionStation.positionId);
                if (to_Stock != null)
                {
                    errMsg = "发现目标库位有库存，不允许发送agv任务到该上线点，上线点：" + item.toPlace;
                    WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskForNoIssued", errMsg);
                    return;
                }
                #endregion

                #region 发送AGV任务 并清空库存

                string res = "失败";
                if (!MyExtendHelper.IsAllowSimulatorHandle(item))
                {//生产环境
                    res = baseData.sendAgvTask(item, item.taskId, item.sourcePlace, item.toPlace, 1);
                }
                else
                {//虚拟模式或强制完成
                    res = "";
                }
                string tasktype = _taskType.ToString();
                if (res == "")
                {
                    #region 清空库存更新状态
                    item.taskStatus = (int)taskStatus.完成;//注意：一定是任务完成，发送给AGV任务后，直接修改为任务完成，将库存转移到天永机器人那边的上线点
                    item.remark = "完成";
                    mod.SaveChanges();
                    agvSendStatus[0] = DateTime.Now.ToString("dd日HH:mm:ss") + "发送成功,任务ID:" + item.taskId;


                    #region 增加库存
                    inStockOrder finishCode = mod.inStockOrder.FirstOrDefault(x => x.orderCode == item.createListCode);
                    if (finishCode == null)
                    {
                        errMsg = "没有找到入库单！ 单号:" + item.createListCode;
                        WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskForNoIssued", errMsg);
                        return;
                    }
                    material mat = mod.material.FirstOrDefault(x => x.materialCode == finishCode.productCode);
                    productStock stock = new productStock();
                    stock.positionId = to_positionStation.positionId;
                    stock.createTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                    stock.materialId = mat != null ? mat.materialId : 0;
                    stock.supplier = finishCode.supplier;//供应商
                    stock.quantity = finishCode.quantity;
                    stock.updateTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                    stock.taskType = (int)_taskType;
                    // stock.productCode = mat != null ? "" : finishCode.productCode;//没有维护物料数据就把数据放到
                    stock.containerCode = finishCode.containerCode;
                    mod.productStock.Add(stock);

                    var orderList = mod.inStockOrderList.Where(x => x.orderCodeId == finishCode.orderCodeId).ToList();
                    foreach (var myitem in orderList)
                    {
                        productStockList stockList = new productStockList();
                        stockList.stockId = to_positionStation.positionId;
                        stockList.productCode = myitem.productCode;
                        stockList.productName = myitem.productName;
                        stockList.serialNumber = myitem.serialNumber;
                        mod.productStockList.Add(stockList);
                    }

                    // to_positionStation.isfree = true;
                    PositionHandler.Free(true, to_positionStation, "处理未下发的直达上线点的任务", SysGloble.WCSNAME, item);

                    OutInStockRecordHandler.AddOutInStockRecord(mod, OutInFlag.入库, item.sourcePlace, "Virtual", item, "入库类型的任务");
                    OutInStockRecordHandler.AddOutInStockRecord(mod, OutInFlag.出库, "Virtual", item.toPlace, item, "出库类型的任务");

                    #endregion

                    #endregion
                }
                else
                {
                    //保存失败信息到任务表中 【EditBy shaocx,2022-03-16】
                    item.remark = "发送AGV任务失败:" + res;
                    mod.SaveChanges();

                    agvSendStatus[0] = DateTime.Now.ToString("dd日HH:mm:ss") + "发送AGV任务失败:" + res + ",任务ID:" + item.taskId;
                    errMsg = tasktype + "发送RGV任务失败,接口返回:" + res;
                    WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskForNoIssued", errMsg);
                }
                #endregion

                if (_taskType == taskType.缸盖下线直接去上线点)
                {//给天永发信号
                    TianYongSystem.UpdateStoreByTaskID(mod, item, item.toPlace, (int)item.taskId, "缸盖下线直接去上线点,进入天永站点");
                }

                int saveRes = mod.SaveChanges();
                #region 验证是否保存成功
                if (saveRes < 1)
                {
                    errMsg = "数据库保存失败！ 任务id:" + item.taskId;
                    WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskForNoIssued", errMsg);
                }
                #endregion
            }
            else
            {
                errMsg = agvSendStatus[0] = DateTime.Now.ToString("dd日HH:mm:ss") + "没发送任务-ARV繁忙,任务ID:" + item.taskId + "，起点:" + item.sourcePlace + "，目标点:" + item.toPlace;
            }

            #endregion
        }


        /// <summary>
        /// 堆垛机出库任务，发送任务给设备
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="srm"></param>
        /// <param name="isvirtual"></param>
        /// <param name="_task"></param>
        public static bool HandleTaskForutStoreBySrm(dbmodel mod, task _task, ref string errMsg)
        {
            taskType _taskType = (taskType)Enum.Parse(typeof(taskType), _task.taskType.ToString());
            #region 发送堆垛机任务
            if (!MyExtendHelper.IsAllowSimulatorHandle(_task))
            {
                //if (srm.mode == "自动" && srm.Alarm_info == "无故障" && srm.state == "待机")
                if (MyExtendHelper.IsAllowSendNewTaskToSrm())
                {
                    baseData.sendSrmTask(_task, _task.taskId, _task.sourcePlace, _task.toPlace, 1);
                }
                else
                {
                    errMsg = "堆垛机目前状态不满足下发任务给他,不能下发任务" + _task.taskId;
                    return false;
                }
            }
            position toPlace = mod.position.FirstOrDefault(x => x.positionName == _task.toPlace);
            if (toPlace != null)
            {
                //toPlace.isLock = true;
                PositionHandler.Lock(true, toPlace, _taskType.ToString() + "任务，发送堆垛机任务时，锁定该库位", SysGloble.WCSNAME, _task);
            }
            position sorucePlace = mod.position.FirstOrDefault(x => x.positionName == _task.sourcePlace);
            if (sorucePlace != null)
            {
                //sorucePlace.isLock = true;
                PositionHandler.Lock(true, sorucePlace, _taskType.ToString() + "任务，发送堆垛机任务时，锁定该库位", SysGloble.WCSNAME, _task);
            }
            //保存任务记录
            _task.taskStatus = (int)taskStatus.已下发;
            _task.remark = "已下发";
            #endregion

            int saveRes = mod.SaveChanges();
            if (saveRes < 1)
            {
                errMsg = "数据库保存失败！ 任务id:" + _task.taskId;
                WZ.Useful.Commons.LogTextHelper.WriteLine("Form1", "HandleTaskForutStoreBySrm", "数据库保存失败！ 任务id:" + _task.taskId);
                return false;
            }
            else
            {
                return true;
            }
        }

        /// <summary>
        /// 人工入库任务，发送任务给设备
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="srm"></param>
        /// <param name="isvirtual"></param>
        /// <param name="_task"></param>
        public static bool HandleTaskForHandInStore(dbmodel mod, task _task, ref string errMsg)
        {

            #region 发送堆垛机任务
            if (!MyExtendHelper.IsAllowSimulatorHandle(_task))
            {
                //if (srm.mode == "自动" && srm.Alarm_info == "无故障" && srm.state == "待机")
                if (MyExtendHelper.IsAllowSendNewTaskToSrm())
                {
                    #region 发送输送线放料完成信号任务
                    TransEnum _TransEnum = MyExtendHelper.GetTransByPlace(_task.sourcePlace);
                    TransService.LoadMaterialConfirm(Convert.ToInt32(_TransEnum) - 1);
                    #endregion

                    baseData.sendSrmTask(_task, _task.taskId, _task.sourcePlace, _task.toPlace, 1);
                }
                else
                {
                    errMsg = "堆垛机目前状态不满足下发任务给他,不能下发任务" + _task.taskId;
                    return false;
                }
            }
            position toPlace = mod.position.FirstOrDefault(x => x.positionName == _task.toPlace);
            if (toPlace != null)
            {
                //toPlace.isLock = true;
                PositionHandler.Lock(true, toPlace, "人工入库任务,发送堆垛机任务时，锁定该库位", SysGloble.WCSNAME, _task);
            }
            position sorucePlace = mod.position.FirstOrDefault(x => x.positionName == _task.sourcePlace);
            if (sorucePlace != null)
            {
                //sorucePlace.isLock = true;
                PositionHandler.Lock(true, sorucePlace, "人工入库任务,发送堆垛机任务时，锁定该库位", SysGloble.WCSNAME, _task);
            }
            //保存任务记录
            _task.taskStatus = (int)taskStatus.已下发;
            _task.remark = "已下发";
            #endregion

            int saveRes = mod.SaveChanges();
            if (saveRes < 1)
            {
                errMsg = "数据库保存失败！ 任务id:" + _task.taskId;
                WZ.Useful.Commons.LogTextHelper.WriteLine("Form1", "HandleTaskForHandInStore", "数据库保存失败！ 任务id:" + _task.taskId);
                return false;
            }
            else
            {
                return true;
            }
        }

        /// <summary>
        /// 更新库存时间
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="toPlace"></param>
        /// <param name="remark"></param>
        public static void UpdateProductStock_updateTime(dbmodel mod, position toPlace, string remark)
        {
            //更新库存的时间 [EditBy shaocx,2022-05-07]
            productStock stock = mod.productStock.Where(x => x.positionId == toPlace.positionId).FirstOrDefault();
            if (stock == null)
            {
                throw new Exception(remark + "，更新库存时间时未找到" + toPlace.positionName + "的库存");
            }
            stock.updateTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
        }

        #region 堆垛机任务完成后的数据处理

        /// <summary>
        /// 堆垛机任务完成后的数据处理
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="finishTask"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        public static bool HandleSrmfinishConfirm(dbmodel mod, task finishTask, ref string errMsg)
        {
            long taskID = finishTask.taskId;
            //事务处理
            using (var trans = mod.Database.BeginTransaction())
            {
                try
                {
                    position sourcePlace, toPlace = null;
                    #region 库存数据处理
                    taskType currentTaskType = (taskType)Enum.Parse(typeof(taskType), finishTask.taskType.ToString());
                    switch (currentTaskType)
                    {
                        case taskType.空托回库:
                        case taskType.空托下线入库:
                        case taskType.空托手动入库:
                        case taskType.余料回库:
                        case taskType.旁路工位缸体空托回库:
                        case taskType.旁路工位缸体余料回库:
                            #region 空托回库、余料回库
                            toPlace = mod.position.FirstOrDefault(x => x.positionName == finishTask.toPlace);
                            sourcePlace = mod.position.FirstOrDefault(x => x.positionName == finishTask.sourcePlace);
                            if (sourcePlace != null)
                            {
                                //fromPos.isfree = false;
                                //fromPos.isLock = false;
                                PositionHandler.LockAndFree(false, false, sourcePlace, "堆垛机任务完成后的数据处理", SysGloble.WCSNAME, finishTask);
                            }
                            if (toPlace != null)
                            {
                                bool ishaveGG = SysGloble.GG_OnLine_Stations.Contains(finishTask.sourcePlace.Trim());
                                #region 空托盘回库或余料回库
                                //if (finishTask.taskName == "缸体空托回库" || finishTask.taskName == "缸盖空托回库")//如果是
                                if (finishTask.taskType == (int)taskType.空托回库 || finishTask.taskType == (int)taskType.旁路工位缸体空托回库)//如果是
                                {
                                    productStock stock = new productStock();
                                    stock.positionId = toPlace.positionId;
                                    stock.createTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                    stock.materialId = ishaveGG == true ? 3 : 4;//缸体4，缸盖3 固定不变的
                                    stock.quantity = 0;//默认3个
                                    stock.status = 1;
                                    stock.taskType = 6;//空托盘回库
                                    stock.updateTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                    stock.containerCode = finishTask.containerCode;//增加托盘号赋值 
                                    mod.productStock.Add(stock);

                                    toPlace.positionType = (byte)positionType.空托盘;
                                }
                                else if (finishTask.taskType == (int)taskType.空托下线入库
                                        || finishTask.taskType == (int)taskType.空托手动入库
                                        )//如果是
                                {
                                    productStock stock = new productStock();
                                    stock.positionId = toPlace.positionId;
                                    stock.createTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                    stock.materialId = finishTask.materialCode == "GG-KTP" ? 3 : 4;//缸体4，缸盖3 固定不变的
                                    stock.quantity = 0;//默认3个
                                    stock.status = 1;
                                    stock.taskType = 6;//空托盘回库
                                    stock.updateTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                    stock.containerCode = finishTask.containerCode;//增加托盘号赋值 
                                    mod.productStock.Add(stock);

                                    toPlace.positionType = (byte)positionType.空托盘;
                                }
                                else
                                {
                                    toPlace.positionType = (byte)positionType.余料回库;
                                    //更新库存的时间 [EditBy shaocx,2022-05-07]
                                    UpdateProductStock_updateTime(mod, toPlace, "堆垛机任务完成后");
                                    //if (finishTask.taskName == "缸体余料回库")
                                    //{
                                    //    pos.positionType = (byte)positionType.缸体;
                                    //}
                                    //else
                                    //{
                                    //    pos.positionType = (byte)positionType.缸盖;
                                    //}
                                }
                                //pos.isfree = true;
                                //pos.isLock = false;
                                PositionHandler.LockAndFree(false, true, toPlace, "堆垛机任务完成后的数据处理", SysGloble.WCSNAME, finishTask);
                                UnLockConverPlaceForInStore(mod, finishTask, "堆垛机任务完成后的数据处理,任务是入库类型,解除输送线的锁定和有货状态");
                                //finishTask.taskStatus = 5;
                                finishTask.taskStatus = (int)taskStatus.完成;
                                finishTask.remark = "完成";
                                finishTask.finishTime = DateTime.Now;
                                #endregion
                            }
                            else
                            {
                                throw new Exception("入库任务，目标站点找不到，toPlace：" + finishTask.toPlace);
                            }
                            OutInStockRecordHandler.AddOutInStockRecord(mod, OutInFlag.入库, finishTask.sourcePlace, finishTask.toPlace, finishTask, "入库类型的任务");
                            OutInStockRecord_V2_MesHandler.AddRecord(mod, OutInFlag.入库, finishTask.toPlace, finishTask, "入库类型的任务", currentTaskType);//堆垛机任务完成后的入库
                            #endregion
                            break;
                        case taskType.缸体下线:
                        case taskType.缸盖下线:
                        case taskType.手动入库:
                            #region  缸体下线、缸盖下线、手动入库
                            inStockOrder finishCode = mod.inStockOrder.FirstOrDefault(x => x.orderCode == finishTask.createListCode);
                            if (finishCode != null)
                            {
                                if (finishTask.taskType == (int)taskType.手动入库)
                                {//释放输送线锁定状态 [EditBy shaocx,2022-03-21]
                                    position fromPos = mod.position.FirstOrDefault(x => x.positionName == finishTask.sourcePlace);//输送线地址
                                    if (fromPos != null)
                                    {
                                        //fromPos.isfree = false;//释放输送线地址
                                        //fromPos.isLock = false;
                                        PositionHandler.LockAndFree(false, false, fromPos, "手动入库，堆垛机任务完成后的数据处理", SysGloble.WCSNAME, finishTask);
                                    }
                                }

                                UnLockConverPlaceForInStore(mod, finishTask, "堆垛机任务完成后的数据处理,任务是入库类型,解除输送线的锁定和有货状态");

                                #region 缸体缸盖下线数据处理
                                //finishCode.status = 4;
                                finishCode.status = (int)InStockOrderStatus.完成;
                                //finishTask.taskStatus = 5;
                                finishTask.taskStatus = (int)taskStatus.完成;
                                finishTask.remark = "完成";
                                finishTask.finishTime = DateTime.Now;
                                position pos = mod.position.FirstOrDefault(x => x.positionName == finishTask.toPlace);
                                var orderList = mod.inStockOrderList.Where(x => x.orderCodeId == finishCode.orderCodeId).ToList();
                                material mat = mod.material.FirstOrDefault(x => x.materialCode == finishCode.productCode);
                                long materialId = 0;
                                if (mat == null)//不存在就创建一个物料
                                {
                                    material newMaterial = new material();
                                    newMaterial.materialCode = finishCode.productCode;
                                    newMaterial.materialName = "待更新";
                                    newMaterial.materialType = finishCode.orderCode.Trim().Substring(0, 2) == "GT" ? (int)materialType.缸体 : (int)materialType.缸盖;
                                    newMaterial.createTime = DateTime.Now;
                                    newMaterial.creator = "WCS";
                                    newMaterial.version = "";
                                    mod.material.Add(newMaterial);
                                    int resAdd = mod.SaveChanges();//必须先SaveChanges，否则 newMaterial.materialId无法赋值
                                    if (resAdd > 0)
                                    {
                                        materialId = newMaterial.materialId;
                                    }
                                }
                                System.Collections.Generic.List<productStockList> insert_productStocks = new List<productStockList>();
                                if (pos != null && orderList.Count > 0)
                                {
                                    productStock stock = new productStock();
                                    stock.positionId = pos.positionId;
                                    stock.createTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                    stock.materialId = mat != null ? mat.materialId : materialId;
                                    stock.supplier = finishCode.supplier;//供应商
                                    stock.quantity = finishCode.quantity;
                                    stock.updateTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                                    stock.taskType = finishTask.taskType;
                                    // stock.productCode = mat != null ? "" : finishCode.productCode;//没有维护物料数据就把数据放到
                                    stock.containerCode = finishCode.containerCode;
                                    mod.productStock.Add(stock);
                                    pos.positionType = finishCode.orderCode.Trim().Substring(0, 2) == "GT" ? (byte)positionType.缸体 : (byte)positionType.缸盖;//用表单首2字母判断是缸体还是缸盖
                                    //pos.isfree = true;
                                    //pos.isLock = false;
                                    PositionHandler.LockAndFree(false, true, pos, "堆垛机任务完成后的数据处理", SysGloble.WCSNAME, finishTask);
                                    int res = mod.SaveChanges();//必须先SaveChanges，否则 newMaterial.materialId无法赋值
                                    if (res > 0)
                                    {
                                        foreach (var item in orderList)
                                        {
                                            productStockList stockList = new productStockList();
                                            stockList.stockId = pos.positionId;
                                            stockList.productCode = item.productCode;
                                            stockList.productName = item.productName;
                                            stockList.serialNumber = item.serialNumber;
                                            mod.productStockList.Add(stockList);
                                            insert_productStocks.Add(stockList);
                                        }
                                    }

                                }
                                else
                                {
                                    WZ.Useful.Commons.LogTextHelper.WriteLine("Form1", "finishConfirm", "任务ID：" + taskID + "找库位或者找物料失败");
                                    errMsg = "任务ID：" + taskID + "找库位或者找物料失败";
                                    throw new Exception(errMsg);
                                }
                                #endregion

                                OutInStockRecordHandler.AddOutInStockRecord(mod, OutInFlag.入库, finishTask.sourcePlace, finishTask.toPlace, finishTask, "入库类型的任务");
                                OutInStockRecord_V2_MesHandler.AddRecord(mod, OutInFlag.入库, finishTask.toPlace, finishTask, "入库类型的任务", insert_productStocks, currentTaskType);//堆垛机任务完成后的入库
                            }
                            else
                            {
                                WZ.Useful.Commons.LogTextHelper.WriteLine("Form1", "finishConfirm", "任务ID：" + taskID + "找不到出库单");
                                finishTask.taskStatus = 6;//6是异常
                                finishTask.remark = "异常";
                            }
                            #endregion
                            break;
                        case taskType.手动出库://增加手动出库的分支 【EditBy shaocx,2022-03-02】
                        case taskType.空托人工出库:
                            #region 手动出库
                            //库存清除
                            sourcePlace = mod.position.FirstOrDefault(x => x.positionName == finishTask.sourcePlace);
                            toPlace = mod.position.FirstOrDefault(x => x.positionName == finishTask.toPlace);
                            //sourcePlace.isfree = true;
                            //sourcePlace.isLock = false;
                            PositionHandler.LockAndFree(false, true, sourcePlace, "堆垛机任务完成后的数据处理", SysGloble.WCSNAME, finishTask);
                            //toPlace.isfree = true;
                            //toPlace.isLock = false;
                            PositionHandler.LockAndFree(false, true, toPlace, "堆垛机任务完成后的数据处理", SysGloble.WCSNAME, finishTask);

                            finishTask.taskStatus = (int)taskStatus.完成;
                            finishTask.remark = "完成";
                            finishTask.finishTime = DateTime.Now;



                            var result = deleteProduct(false, "sys", mod, finishTask.sourcePlace, finishTask, ref errMsg, "堆垛机任务完成-手动出库");//删除库存
                            if (result == false) throw new Exception(errMsg);

                            OutInStockRecordHandler.AddOutInStockRecord(mod, OutInFlag.出库, finishTask.sourcePlace, finishTask.toPlace, finishTask, "出库类型的任务");

                            #endregion
                            break;
                        case taskType.缸体上线去旁路工位://增加 缸体上线去旁路工位 的分支 【EditBy shaocx,2022-04-24】 
                            _HandleTaskFor缸体上线去旁路工位WhenSrmTaskFinish(currentTaskType, mod, finishTask, ref errMsg);
                            break;
                        case taskType.出库分拣://增加出库分拣的分支 【EditBy shaocx,2022-03-02】
                            #region 出库分拣
                            //1、如果任务状态为 已下发，表示是堆垛机出库任务，此时只更新任务状态=待分拣
                            //2、待分拣状态-》分拣完成状态，是在WMS中由用户分拣点击时更改的。
                            //3、分拣完成状态-》分拣完成后下发设备任务状态，是在WCS中线程处理任务【分拣完成】中更改的。
                            //4、如果任务状态为 分拣完成后下发设备任务，表示是堆垛机入库任务，此时要将解锁库位，并且状态改为 已完成
                            if (finishTask.taskStatus == (int)taskStatus.已下发)
                            {
                                finishTask.taskStatus = (int)taskStatus.待分拣;
                                finishTask.remark = "待分拣";
                            }
                            else if (finishTask.taskStatus == (int)taskStatus.分拣完成后下发设备任务)
                            {
                                finishTask.taskStatus = (int)taskStatus.完成;
                                finishTask.remark = "完成";
                                finishTask.finishTime = DateTime.Now;
                                //解锁库位
                                sourcePlace = mod.position.FirstOrDefault(x => x.positionName == finishTask.sourcePlace);
                                toPlace = mod.position.FirstOrDefault(x => x.positionName == finishTask.toPlace);
                                //sourcePlace.isLock = false;
                                PositionHandler.Lock(false, sourcePlace, "堆垛机任务完成后的数据处理", SysGloble.WCSNAME, finishTask);
                                //toPlace.isfree = true;
                                //toPlace.isLock = false;
                                PositionHandler.LockAndFree(false, true, toPlace, "堆垛机任务完成后的数据处理", SysGloble.WCSNAME, finishTask);
                            }
                            else
                            {
                                errMsg = "任务类型是出库分拣时，堆垛机完成前，任务状态只能是 分拣完成后下发设备任务或已下发，不能是:" + finishTask.taskStatus;
                                throw new Exception(errMsg);
                            }
                            #endregion
                            break;
                        case taskType.缸盖上线:
                        case taskType.缸体上线:
                            //解除输送点的锁定 [EditBy shaocx,2022-03-23]
                            if (!string.IsNullOrEmpty(finishTask.middlePlace))
                            {
                                var convPlace = mod.position.FirstOrDefault(x => x.positionName == finishTask.middlePlace);
                                PositionHandler.Lock(false, convPlace, "缸盖上线，缸体上线，堆垛机任务完成后的数据处理，解除输送点的锁定", SysGloble.WCSNAME, finishTask);
                            }
                            else
                            {
                                errMsg = "缸盖上线/缸体上线任务，中转位为空，暂不处理";
                                return false;
                            }
                            OutInStockRecord_V2_MesHandler.AddRecord(mod, OutInFlag.出库, finishTask.sourcePlace, finishTask, "出库类型的任务", currentTaskType);//堆垛机任务完成后的出库
                            break;
                        default://其他，出库确认
                            //finishTask.taskStatus = 3;
                            finishTask.taskStatus = (int)taskStatus.已下发;
                            finishTask.remark = "已下发";
                            break;
                    }


                    #endregion

                    int saveRes = mod.SaveChanges();
                    if (saveRes < 1)
                    {
                        errMsg = "更新条数为" + saveRes;
                        throw new Exception(errMsg);
                    }
                    trans.Commit();
                }
                catch (Exception)
                {
                    trans.Rollback();
                    throw;
                }
                finally
                {

                }
            }

            return true;
        }

        #region 堆垛机任务完成后，对任务 缸体上线到旁路工位的处理

        /// <summary>
        /// 堆垛机任务完成后，对任务 缸体上线到旁路工位的处理
        /// </summary>
        /// <param name="_taskType"></param>
        /// <param name="mod"></param>
        /// <param name="item"></param>
        /// <param name="errMsg"></param>
        private static void _HandleTaskFor缸体上线去旁路工位WhenSrmTaskFinish(taskType _taskType, dbmodel mod, task item, ref string errMsg
       )
        {
            //起点
            position source_positionStation = mod.position.FirstOrDefault(x => x.positionName == item.sourcePlace);
            if (source_positionStation == null)
            {
                errMsg = "未找到起点库位" + item.sourcePlace;
                WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskFor缸体上线去旁路工位", errMsg);
                return;
            }
            //中间点
            position mid_positionStation = mod.position.FirstOrDefault(x => x.positionName == item.middlePlace);
            if (mid_positionStation == null)
            {
                errMsg = "未找到输送线库位" + item.middlePlace;
                WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskFor缸体上线去旁路工位", errMsg);
                return;
            }
            //目标点
            position to_positionStation = mod.position.FirstOrDefault(x => x.positionName == item.toPlace);
            if (to_positionStation == null)
            {
                errMsg = "未找到目标库位" + item.toPlace;
                WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskFor缸体上线去旁路工位", errMsg);
                return;
            }

            #region  验证上线点是否有库存
            var to_Stock = MyExtendHelper.GetProductStockById(mod, to_positionStation.positionId);
            if (to_Stock != null)
            {
                errMsg = "发现目标库位有库存，不允许结束任务到该上线点，上线点：" + item.toPlace;
                WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskFor缸体上线去旁路工位", errMsg);
                return;
            }
            #endregion


            item.taskStatus = (int)taskStatus.完成;//注意：一定是任务完成，发送给AGV任务后，直接修改为任务完成，将库存转移到天永机器人那边的上线点
            item.remark = "完成";


            #region 库存转移
            productStock stock = mod.productStock.FirstOrDefault(x => x.positionId == source_positionStation.positionId);
            if (stock != null)
            {
                stock.positionId = to_positionStation.positionId;
                stock.updateTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                //positionStation.isfree = true;
                PositionHandler.Free(true, to_positionStation, "处理任务是下发中，任务类型是 呼叫空托And缸体上线And缸盖上线的库存管理", SysGloble.WCSNAME, item);
            }
            else
            {
                errMsg = "没有找到库存！ 库位号:" + item.sourcePlace;
                WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskFor缸体上线去旁路工位", errMsg);
                return;
            }
            List<productStockList> stocklist = mod.productStockList.Where(x => x.stockId == source_positionStation.positionId).ToList();
            if (stocklist.Count > 0)
            {
                foreach (var itemList in stocklist)
                {
                    itemList.stockId = to_positionStation.positionId;
                }
            }
            else
            {
                errMsg = "没有找到库存明细！ 库位号:" + item.sourcePlace;
                WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskFor缸体上线去旁路工位", errMsg);
                return;
            }
            #endregion

            //站点释放
            PositionHandler.LockAndFree(false, false, source_positionStation, "处理 缸体上线到旁路工位的处理 的任务", SysGloble.WCSNAME, item);
            PositionHandler.LockAndFree(false, false, mid_positionStation, "处理 缸体上线到旁路工位的处理 的任务", SysGloble.WCSNAME, item);
            //设置目标位有货
            PositionHandler.Free(true, to_positionStation, "处理 缸体上线到旁路工位的处理 的任务", SysGloble.WCSNAME, item);

            OutInStockRecord_V2_MesHandler.AddRecord(mod, OutInFlag.出库, item.toPlace, item, "出库类型的任务", _taskType);//堆垛机任务完成后的出库
            OutInStockRecordHandler.AddOutInStockRecord(mod, OutInFlag.出库, item.sourcePlace, item.toPlace, item, "出库类型的任务");

            //通知天永,给天永发信号
            TianYongSystem.UpdateStoreByTaskID(mod, item, item.toPlace, (int)item.taskId, "缸体上线到旁路工位,进入天永站点");

            //注释掉SaveChanges,因为上层就SaveChanges了 【Editby shaocx,2022-05-04】
            //int saveRes = mod.SaveChanges();

            //#region 验证是否保存成功
            //if (saveRes < 1)
            //{
            //    errMsg = "数据库保存失败！ 任务id:" + item.taskId;
            //    WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "_HandleTaskFor缸体上线去旁路工位", errMsg);
            //}
            //else
            //{

            //}
            //#endregion

        }

        #endregion


        /// <summary>
        /// 堆垛机任务完成后，对入库类型的任务，解除输送线的锁定
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="finishTask"></param>
        /// <param name="remark"></param>
        private static void UnLockConverPlaceForInStore(dbmodel mod, task finishTask, string remark)
        {
            //解除输送点的锁定 [EditBy shaocx,2022-03-23]
            if (!string.IsNullOrEmpty(finishTask.middlePlace))
            {
                var convPlace = mod.position.FirstOrDefault(x => x.positionName == finishTask.middlePlace);
                PositionHandler.LockAndFree(false, false, convPlace, remark, SysGloble.WCSNAME, finishTask);
            }
        }

        #endregion

        /// <summary>
        /// 处理新建的出库表单[缸体上线、缸盖上线]
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="_task"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        public static bool DoHandleOutStockList(dbmodel mod, task _task, ref string errMsg)
        {
            try
            {
                string sourcePlace = "";
                VproductStock outStock = null;
                //根据配置供应商查询
                var supplier = BasicDataSetHandler.GetBasicDataSetForSupplier();
                outStock = FindOutStockFromSrm(mod, supplier, _task);

                if (outStock == null)
                {
                    _task.isQueLiao = 1;
                    _task.queLiaoSupplier = supplier;
                    errMsg = "库存无此物料," + (string.IsNullOrEmpty(supplier) ? "不按供应商查询" : "按照供应商" + supplier + "查询");
                    //更新到数据库中
                    _task.remark = errMsg;
                    mod.SaveChanges();
                    return false;
                }
                _task.isQueLiao = 0;
                _task.queLiaoSupplier = supplier;

                sourcePlace = outStock.positionName;
                _task.sourcePlace = sourcePlace;
                var changeStatus = taskStatus.未下发;
                _task.taskStatus = (int)changeStatus;
                _task.remark = "未下发";

                var obj_sourcePlace = mod.position.Where(x => x.positionId == outStock.positionId).FirstOrDefault();
                //锁定起点
                PositionHandler.Lock(true, obj_sourcePlace, _task.taskName + ",寻找到库存，锁定库位", "调度", _task);

                //更新任务表的信息
                _task.materialName = outStock.materialName;
                _task.supplier = outStock.supplier;//供应商 【EditBy shaocx,2022-01-15】
                _task.containerCode = outStock.containerCode;//托盘号  【EditBy shaocx,2022-01-15】
                _task.quantity = outStock.quantity;
                //更新出库表单的信息
                var outStockList = mod.outStockList.Where(x => x.outStockOrder == _task.createListCode).FirstOrDefault();
                if (outStockList != null)
                {
                    outStockList.materialName = outStock.materialName;
                    outStockList.quantity = outStock.quantity;
                    outStockList.version = outStock.version;//机型  【EditBy shaocx,2022-01-18】
                }

                int saveRes = mod.SaveChanges();
                if (saveRes < 1)
                {
                    errMsg = "更新条数为" + saveRes;
                    return false;
                }
                return true;
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {

            }
        }

        /// <summary>
        /// 获取要出库的立体库库存
        /// </summary>
        /// <param name="mod"></param>
        /// <param name="supplier"></param>
        /// <param name="_task"></param>
        /// <returns></returns>
        private static VproductStock FindOutStockFromSrm(dbmodel mod, string supplier, task _task)
        {
            try
            {
                List<VproductStock> outStockList = null;
                if (string.IsNullOrEmpty(supplier))
                {
                    outStockList = mod.VproductStock.OrderBy(x => x.createTime).Where(x => x.materialCode == _task.materialCode.Trim() && x.isLock == false).ToList();
                }
                else
                {
                    outStockList = mod.VproductStock.OrderBy(x => x.createTime).Where(x => x.supplier == supplier && x.materialCode == _task.materialCode.Trim() && x.isLock == false).ToList();
                }
                //注意：要删选掉那些不是立体库位的站点 【EditBy shaocx,2022-05-04】
                if (outStockList != null && outStockList.Count > 0)
                {
                    outStockList = outStockList.Where(x =>
                        !SysGloble.TransStations.Contains(x.positionName) &&
                        !SysGloble.GG_OffLine_Stations.Contains(x.positionName) &&
                        !SysGloble.GT_OffLine_Stations.Contains(x.positionName) &&
                        !SysGloble.GG_OnLine_Stations.Contains(x.positionName) &&
                        !SysGloble.GT_OnLine_Stations.Contains(x.positionName)
                        ).ToList();
                }
                if (outStockList != null && outStockList.Count > 0)
                {
                    foreach (var item in outStockList)
                    {
                        List<productStockList> stockSerialNumber = mod.productStockList.Where(x => x.stockId == item.positionId).ToList();
                        if (stockSerialNumber.Count < 1)
                        {
                            continue;
                        }
                        return item;
                    }
                }
                else
                {
                    return null;
                }
            }
            catch (Exception)
            {
                throw;
            }
            return null;
        }


        /// <summary>
        /// 根据库位删除数据
        /// </summary>
        /// <param name="isPerson">是否人工删除</param>
        /// <param name="mod"></param>
        /// <param name="positionName"></param>
        /// <param name="res"></param>
        /// <returns></returns>
        public static bool deleteProduct(bool isPerson, string user, dbmodel mod, string positionName, task _task, ref string res, string preLog)
        {
            res = "";
            string[] stations = { "GTU1", "GTU2", "GTU3", "GGU1", "GGU2", "GGU3" };
            try
            {
                VproductStock delteData = mod.VproductStock.FirstOrDefault(x => x.positionName == positionName);
                if (delteData != null)
                {
                    List<productStock> delteStockData = mod.productStock.Where(x => x.positionId == delteData.positionId).ToList();
                    if (delteStockData.Count > 0)
                    {
                        res = "删除成功";
                        foreach (var item in delteStockData)
                        {
                            mod.productStock.Remove(item);
                        }
                        position reset = mod.position.FirstOrDefault(x => x.positionId == delteData.positionId);
                        if (reset != null)
                        {
                            //reset.isfree = false;
                            //reset.isLock = false;
                            PositionHandler.LockAndFree(false, false, reset, "根据库位删除数据", SysGloble.WCSNAME, _task);
                            if (!stations.Contains(delteData.positionName.Trim()))
                            {
                                reset.positionType = (int)positionType.空库位;
                            }
                        }
                        List<productStockList> delteStockDatalist = mod.productStockList.Where(x => x.stockId == delteData.positionId).ToList();
                        if (delteStockDatalist.Count > 0)
                        {
                            OutInStockRecord_V2_MesHandler.AddRecordForPersonDelete(mod, OutInFlag.出库, "删除库存:" + preLog,
                                delteStockDatalist, delteStockData.First(), positionName);//堆垛机任务完成后的出库
                            foreach (var itemList in delteStockDatalist)
                            {
                                mod.productStockList.Remove(itemList);

                                //记录日志 [EditBy shaocx,2022-03-16]
                                StockClearLog _StockClearLog = new StockClearLog()
                                {
                                    ID = Guid.NewGuid().ToString(),
                                    serialNumber = itemList.serialNumber,
                                    containerCode = delteStockData[0].containerCode,
                                    materialCode = delteData.materialCode,
                                    materialName = delteData.materialName,
                                    positionName = delteData.positionName,
                                    qty = delteData.quantity,
                                    supplier = delteData.supplier,
                                    version = delteData.version,
                                    Remark = isPerson ? "人工清除库存" : "自动清除库存",
                                    CreateTime = DateTime.Now,
                                    LastModifyTime = DateTime.Now,
                                    Creator = user,
                                    LastModifier = user
                                };
                                mod.StockClearLog.Add(_StockClearLog);

                            }
                        }
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                res = "删除异常,请检查参数";
                WZ.Useful.Commons.LogTextHelper.WriteLine("IyunneiWcf", "TaskDisplay", ex.ToString());
                throw ex;
            }
        }


        /// <summary>
        /// 计算产量，并写入PLC
        /// </summary>
        /// <returns></returns>
        public static void CalcQty()
        {
            //Task.Run(() =>
            //{
            try
            {
                using (dbmodel mod = new dbmodel())
                {
                    //总产量
                    //var queryTask1 = (int)taskType.缸盖上线;
                    //var queryTask2 = (int)taskType.缸体上线;
                    //var queryTask3 = (int)taskType.手动入库;
                    //var queryTask4 = (int)taskType.缸体下线直接去上线点;
                    //var queryTask5 = (int)taskType.缸盖下线直接去上线点;
                    //var queryTask6 = (int)taskType.余料回库;

                    var queryStats = (int)taskStatus.完成;
                    var allQty = mod.task.Where(x =>
                        //(
                        //x.taskType == queryTask1
                        //|| x.taskType == queryTask2
                        //|| x.taskType == queryTask3
                        //|| x.taskType == queryTask4
                        //|| x.taskType == queryTask5
                        //|| x.taskType == queryTask6
                        //) &&
                        x.taskStatus == queryStats).Count();

                    var nowDateTimeStr_1 = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd") + " 00:00:00");
                    var nowDateTimeStr_2 = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd") + " 23:59:59");
                    var todayQty = mod.task.Where(x =>
                       //(
                       //x.taskType == queryTask1
                       //|| x.taskType == queryTask2
                       //|| x.taskType == queryTask3
                       //|| x.taskType == queryTask4
                       //|| x.taskType == queryTask5
                       //|| x.taskType == queryTask6
                       //) &&
                       x.taskStatus == queryStats
                       && x.finishTime != null && x.finishTime >= nowDateTimeStr_1 && x.finishTime <= nowDateTimeStr_2
                       ).Count();

                    var nowDateTimeStr_3 = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM") + "-01 00:00:00");
                    var nowDateTimeStr_4 = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM") + "-30 23:59:59");
                    var monthQty = mod.task.Where(x =>
                      //  (
                      //     x.taskType == queryTask1
                      //    || x.taskType == queryTask2
                      //    || x.taskType == queryTask3
                      //    || x.taskType == queryTask4
                      //    || x.taskType == queryTask5
                      //    || x.taskType == queryTask6
                      //) &&
                      x.taskStatus == queryStats
                      && x.finishTime != null && x.finishTime >= nowDateTimeStr_3 && x.finishTime <= nowDateTimeStr_4
                      ).Count();
                    TransService.WriteQty((allQty), todayQty, monthQty);

                    WZ.Useful.Commons.LogTextHelper.WriteLine("MyExtend", "CalcQty", "计算产量，并写入PLC成功,allQty:" + allQty + ",todayQty:" + todayQty + ",monthQty:" + monthQty);
                }
            }
            catch
            {
                throw;
            }
            //});
        }
    }
}