using HH.WCS.NongFuChaYuan.DeviceService;
using HH.WCS.NongFuChaYuan.DispatchService;
using HH.WCS.NongFuChaYuan.TaskController;
using HH.WCS.NongFuChaYuan.OtherService;
using HH.WCS.NongFuChaYuan.WmsService;
using Newtonsoft.Json;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using static HH.WCS.NongFuChaYuan.ApiService.ApiModel;
using static HH.WCS.NongFuChaYuan.ApiService.OtherModel;
using System;

namespace HH.WCS.NongFuChaYuan.ApiService
{
    /// <summary>
    /// API接口实现类
    /// </summary>
    public class ApiHelper
    {
        static ApiHelper()
        {

        }

        #region   HostToAgv接口实现类

        /// <summary>
        /// AGV信号处理
        /// </summary>
        /// <param name="model"></param>
        public static void OperateTaskStatus(AgvTaskState model)
        {
            if (string.IsNullOrEmpty(model.No))
            {
                //无任务号请求(交管)
                DeviceProcess.SpecialTraffic(model.ForkliftNo, model.LockNo, model.State);
            }
            else
            {
                var wmsTask = TaskHelper.GetTask(model.No);
                if (wmsTask != null)
                {
                    if (model.ForkliftNo != "0")
                    {
                        if (model.State <= 7)
                        {
                            if (!TaskHelper.CheckActionRecordExist(model.No, model.State.ToString()))
                            {
                                //有任务号请求
                                switch (model.State)
                                {
                                    case 1:
                                        TaskHelper.Begin(wmsTask, model.ForkliftNo);
                                        break;
                                    #region MyRegion
                                    case 3:
                                        TaskHelper.UpdateStatus(wmsTask, "开始取货");
                                        break;
                                    case 4:
                                        TaskProcess.OperateStatus(wmsTask, 4);
                                        TaskHelper.UpdateStatus(wmsTask, "取货完成");
                                        break;
                                    case 5:
                                        TaskHelper.UpdateStatus(wmsTask, "开始卸货");
                                        break;
                                    case 6:
                                        TaskProcess.OperateStatus(wmsTask, 6);
                                        TaskHelper.UpdateStatus(wmsTask, "卸货完成");
                                        break;
                                    #endregion
                                    case 2:
                                        if (!TaskHelper.CheckActionRecordExist(model.No, "6"))
                                        {
                                            TaskProcess.OperateStatus(wmsTask, 6);
                                        }
                                        TaskHelper.End(wmsTask);
                                        break;
                                    case 7:
                                        TaskProcess.OperateStatus(wmsTask, 7);
                                        TaskHelper.Fail(wmsTask);
                                        break;
                                }
                                TaskHelper.UpdateAgvNo(wmsTask, model.ForkliftNo);
                                TaskHelper.AddActionRecord(model.No, model.State, model.ForkliftNo, model.ExtData);
                                TaskProcess.ThirdReportStatus(wmsTask.S_SRC_NO.Trim(), model.ForkliftNo, model.State, model.ExtData, wmsTask);
                                TaskProcess.GeneralInterFaceFunc(wmsTask, model.State.ToString());
                                TaskProcess.RoboticarmTask(wmsTask, model.State);
                            }
                        }
                        else
                        {
                            //安全请求等
                            TaskProcess.OperateReq(model.No, model.State, model.ForkliftNo, model.ExtData);
                            TaskHelper.AddActionRecord(model.No, model.State, model.ForkliftNo, model.ExtData);
                        }
                    }
                }
            }
        }

        internal static SimpleResult AddTask(ApiModel.AddTaskModel model)
        {
            var result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();
            if (!string.IsNullOrEmpty(model.StartBit) && !string.IsNullOrEmpty(model.EndBit))
            {
                //创建点到点自动转运任务
                IntensiveArea.DaMingShanCreateTransport(model.StartBit, model.EndBit, "点到点转运", model.TrayCode, 1, 1, "", 1);
            }
            else if (!string.IsNullOrEmpty(model.StartBit) && string.IsNullOrEmpty(model.EndBit))
            {
                //根据配置文件来选择终点库区
                if (!string.IsNullOrEmpty(model.ItemCode))
                {
                    var info = Settings.GetItemCacheAreaList().Where(a => a.ItemCode == model.ItemCode).FirstOrDefault();
                    if (info != null)
                    {
                        string areaNo = info.AreaCode;
                        var endbitlist = db.Queryable<Location>().Where(a => a.S_AREA_CODE == areaNo && a.N_CURRENT_NUM == 0)
                            .PartitionBy(a => a.N_ROW)
                            .OrderBy(a => a.N_COL)
                            .Take(1)
                            .ToList();
                        foreach (var item in endbitlist)
                        {
                            var lockinfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == item.S_AREA_CODE && a.N_ROW == item.N_ROW && a.S_LOCK_STATE != "无").First();
                            if (lockinfo == null)
                            {
                                //创建任务
                                IntensiveArea.DaMingShanCreateTransport(model.StartBit, item.S_LOC_CODE, "点到点转运", model.TrayCode, 1, 1, "", 1);
                                break;
                            }
                        }
                    }
                    else
                    {
                        result.resultCode = 1;
                        result.resultMsg = "物料编码对应的库区未配置";
                    }
                }
                else
                {
                    result.resultCode = -2;
                    result.resultMsg = "物料编码不能为空";
                }
            }
            else
            {
                result.resultCode = -1;
                result.resultMsg = "起点不能为空";
            }


            return result;
        }

        static object AGVDeviceReceiveLock = new object();

        /// <summary>
        /// AGV状态处理
        /// </summary>
        /// <param name="forkliftNo"></param>
        /// <param name="battery"></param>
        /// <param name="agvCurrTaskInfo"></param>
        /// <param name="errCode"></param>
        /// <param name="errCode2"></param>
        /// <param name="faildCode"></param>
        internal static void AGVDeviceReceiveSet(string forkliftNo, string battery, string agvCurrTaskInfo, string errCode, string errCode2, string faildCode)
        {
            lock (AGVDeviceReceiveLock)
            {
                var db = new SqlHelper<HangChaAGV>().GetInstance();
                var agvDeviceInfo = db.Queryable<HangChaAGV>().Where(a => a.agvNo == forkliftNo).First();
                if (agvDeviceInfo == null)
                {
                    var agvInfo = new HangChaAGV()
                    {
                        agvNo = forkliftNo,
                        agvBattery = battery,
                        agvCurrTaskInfo = agvCurrTaskInfo,
                        agvErrCode = errCode,
                        errCode2 = errCode2,
                        faildCode = faildCode
                    };
                    db.Insertable(agvInfo).ExecuteCommand();
                }
                else
                {
                    agvDeviceInfo.agvBattery = battery;
                    agvDeviceInfo.agvCurrTaskInfo = agvCurrTaskInfo;
                    agvDeviceInfo.agvErrCode = errCode;
                    agvDeviceInfo.errCode2 = errCode2;
                    agvDeviceInfo.faildCode = faildCode;
                    db.Updateable(agvDeviceInfo).UpdateColumns(a => new
                    { a.agvBattery, a.agvCurrTaskInfo, a.agvErrCode, a.errCode2, a.faildCode }).ExecuteCommand();
                }
            }
        }

        #endregion

        #region   Mobox接口实现类
        /// <summary>
        /// Mobox取消任务
        /// </summary>
        /// <param name="model"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        internal static SimpleResult MoboxCancelTask(MoboxTaskBase model, SimpleResult result)
        {
            var task = TaskHelper.GetTask(model.TaskNo);
            if (task != null)
            {
                if (task.S_B_STATE.Trim() == "未执行")
                {
                    //未执行直接修改状态为取消
                    result.resultMsg = "任务未执行，直接取消";
                    TaskHelper.UpdateStatus(model.TaskNo.Trim(), "取消");
                    //task.S_B_STATE = "取消";
                    TaskProcess.OperateStatus(task, 7);
                    //TaskProcess.TaskCanCelOrComplete(task);
                    TaskProcess.GeneralInterFaceFunc(task, "7");
                }
                else if (task.S_B_STATE.Trim() == "已推送")
                {
                    //已推送但是小车未执行，取消需要通知HOSTTOAGV
                    NDCHelper.Cancel(task.S_TASK_NO.Trim());
                    result.resultMsg = "任务取消已经发送给小车";
                    TaskHelper.UpdateStatus(model.TaskNo.Trim(), "取消");
                    //task.S_B_STATE = "取消";
                    TaskProcess.OperateStatus(task, 7);
                    //TaskProcess.TaskCanCelOrComplete(task);
                    TaskProcess.GeneralInterFaceFunc(task, "7");
                }
                else
                {
                    result.resultCode = 1;
                    result.resultMsg = "任务已结束或处于执行中，不允许取消！";
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = "任务不存在";
            }
            return result;
        }

        internal static SimpleResultModel BindingTrayCode(BindingTrayCodeModel model)
        {
            var result = new SimpleResultModel { success = false };
            var db = new SqlHelper<object>().GetInstance();
            if (!string.IsNullOrEmpty(model.location) && !string.IsNullOrEmpty(model.TrayInfo))
            {
                var locinfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == model.location).First();
                if (locinfo != null)
                {
                    var info = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == model.location && a.S_CNTR_CODE == model.TrayInfo).First();
                    if (info == null)
                    {
                        locinfo.N_CURRENT_NUM++;
                        if (locinfo.N_CURRENT_NUM <= locinfo.N_CAPACITY)
                        {
                            var cntrinfo = new LocCntrRel { S_LOC_CODE = model.location, S_CNTR_CODE = model.TrayInfo };
                            db.Insertable<LocCntrRel>(cntrinfo).ExecuteCommand();
                            db.Updateable<Location>(locinfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                            result.success = true;
                            result.errCode = 0;
                        }
                        else
                        {
                            result.errCode = -2;
                            result.errMsg = "当前数量超过最大容量 不允许绑定";
                        }

                    }
                    else
                    {
                        result.errCode = -2;
                        result.errMsg = "货位容器表中该站点已绑定该托盘";
                    }
                }
                else
                {
                    result.errCode = -1;
                    result.errMsg = "错误的货位编码";
                }
            }
            else
            {
                result.errCode = -1;
                result.errMsg = "参数不能为空";
            }

            return result;
        }


        /// <summary>
        /// 空托绑定解绑接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel EmptyLocaBindAUnBind(EmptyLocaBindAUnBindModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            string msg = "";
            if (!string.IsNullOrEmpty(model.Location))
            {
                var db = new SqlHelper<object>().GetInstance();
                var locInfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == model.Location).First();
                if (locInfo != null)
                {
                    if (model.BindState == "1")
                    {
                        var firstLocInfo = db.Queryable<Location>().Where(a => a.N_ROW == locInfo.N_ROW.Trim()).OrderBy(a => a.N_COL).Take(1).First();
                        if (firstLocInfo != null)
                        {
                            string note = string.IsNullOrEmpty(firstLocInfo.S_NOTE) ? "" : firstLocInfo.S_NOTE.Trim();
                            if (string.IsNullOrEmpty(note))
                            {
                                locInfo.N_CURRENT_NUM = locInfo.N_CAPACITY;
                                //locInfo.S_NOTE = model.BindType;
                                db.Updateable(locInfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                                result.success = true; result.errCode = 0; msg = $"空托绑定解绑接口:货位：{model.Location}，绑定：成功！";
                            }
                            else msg = $"空托绑定解绑接口:与当前库位：{locInfo.N_ROW.Trim()}已存放托盘类型不匹配！";
                        }
                    }
                    else if (model.BindState == "2")
                    {
                        locInfo.N_CURRENT_NUM = 0;
                        //locInfo.S_NOTE = "";
                        db.Updateable(locInfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                        result.success = true; result.errCode = 0; msg = $"空托绑定解绑接口:货位：{model.Location}，解绑：成功！";
                    }
                }
                else msg = $"空托绑定解绑接口:未查到货位编码为：{model.Location}的货位信息！";
            }
            else msg = $"空托绑定解绑接口:传输数据异常，货位编码为空！";
            LogHelper.Info("EmptyLocaBindAUnBind Dispose：" + msg, "ThirdSystemLog");
            result.errMsg = msg;
            return result;
        }

        internal static SimpleResultModel BindingItemCode(BindingItemCodeModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            var db = new SqlHelper<object>().GetInstance();
            if (!string.IsNullOrEmpty(model.TrayInfo) && !string.IsNullOrEmpty(model.Location))
            {
                var locinfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == model.Location).First();
                if (locinfo != null)
                {
                    if (locinfo.N_CURRENT_NUM < locinfo.N_CAPACITY)
                    {
                        locinfo.N_CURRENT_NUM = locinfo.N_CURRENT_NUM + 1;
                        db.Updateable(locinfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                        var cntrinfo = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == model.TrayInfo).First();
                        if (cntrinfo == null)
                        {
                            LocCntrRel info = new LocCntrRel { S_CNTR_CODE = model.TrayInfo, S_LOC_CODE = model.Location };
                            db.Insertable(info).ExecuteCommand();
                            var iteminfo = db.Queryable<CntrItemRel>().Where(a => a.S_CNTR_CODE == model.TrayInfo).First();
                            if (iteminfo == null)
                            {
                                IntensiveArea.BindCntrItem(model.TrayInfo, model.ItemCode, model.BatchNo);
                                result.success = true;
                                result.errCode = 0;
                            }
                            else
                            {
                                result.errMsg = "物料表中已有该托盘物料信息,请检查托盘号或已重复绑定";
                            }
                        }
                        else
                        {
                            result.errMsg = "该托盘已绑定,请确定托盘号是否正确";
                        }
                    }
                    else
                    {
                        result.errMsg = "该货位数量大于等于容量";
                    }
                }
                else
                {
                    result.errMsg = "站点编码异常";
                }
            }
            else
            {
                result.errMsg = "托盘号不能为空";
            }

            return result;
        }

        internal static SimpleResultModel FuWeiInfo(FuWeiInfomodel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            if (!string.IsNullOrEmpty(model.deviceName))
            {
                var info = Settings.GetDeviceInfoList().Where(a => a.deviceName == model.deviceName).FirstOrDefault();
                if (info != null)
                {
                    if (string.IsNullOrEmpty(model.location))
                    {
                        //直接发送PLC消息
                        PlcHelper.SendHex(info.address, "3F00100D0A");
                    }
                    else
                    {
                        //匹配下件口发送对应的PLC消息
                        if (info.location[0] == model.location)
                        {
                            PlcHelper.SendHex(info.address, "3F00100D0A");
                        }
                        else
                        {
                            PlcHelper.SendHex(info.address, "3F00200D0A");
                        }
                    }
                    result.success = true;
                    result.errCode = 0;
                }
                else result.errMsg = $"产线号{model.deviceName}异常 配置文件找不到该产线号";
            }
            else result.errMsg = "产线号不能为空";
            return result;
        }



        /// <summary>
        /// Mobox强制完成任务
        /// </summary>
        /// <param name="model"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        internal static SimpleResult MoboxCompleteTask(MoboxTaskBase model, SimpleResult result)
        {
            var task = TaskHelper.GetTask(model.TaskNo);
            if (task != null)
            {
                if (!TaskHelper.CheckActionRecordExist(task.S_TASK_NO, "1"))
                {
                    result.resultMsg = "任务未执行，不允许强制完成！";
                    result.resultCode = 1;
                }
                else
                if (TaskHelper.CheckActionRecordExist(task.S_TASK_NO, "4") && task.S_TYPE.Trim() != "取消" && task.S_TYPE.Trim() != "失败" && task.S_TYPE.Trim() != "完成")
                {
                    //已推送但是没有完成或者取消，通知hosttoagv
                    result.resultMsg = "任务完成已经发送给小车";
                    TaskHelper.UpdateStatus(model.TaskNo.Trim(), "完成");
                    NDCHelper.Cancel(task.S_TASK_NO.Trim());
                    TaskProcess.TaskCanCelOrComplete(task, false);
                    TaskProcess.TASK_STATUSFunc(task);
                    TaskProcess.GeneralInterFaceFunc(task, "2");
                }
                else if (!TaskHelper.CheckActionRecordExist(task.S_TASK_NO, "4") && task.S_TYPE.Trim() != "取消" && task.S_TYPE.Trim() != "失败" && task.S_TYPE.Trim() != "完成")
                {
                    //已推送但是没有完成或者取消，通知hosttoagv
                    result.resultMsg = "任务取消已经发送给小车";
                    TaskHelper.UpdateStatus(model.TaskNo.Trim(), "取消");
                    NDCHelper.Cancel(task.S_TASK_NO.Trim());
                    //TaskProcess.TaskCanCelOrComplete(task, false);
                    //TaskProcess.TASK_STATUSFunc(task);
                    TaskProcess.OperateStatus(task, 7);
                    TaskProcess.GeneralInterFaceFunc(task, "7");
                }
                else
                {
                    result.resultCode = 1;
                    result.resultMsg = "任务已结束";
                }
            }
            else
            {
                result.resultCode = 1;
                result.resultMsg = "任务不存在";
            }
            return result;
        }

        internal static SimpleResult WeiTuo(MoboxTaskBase model)
        {
            var result = new SimpleResult();
            var db = new SqlHelper<object>().GetInstance();
            var task = TaskHelper.GetTask(model.TaskNo);
            if (task != null)
            {
                NDCHelper.Cancel(task.S_TASK_NO.Trim());
                result.resultMsg = "任务取消已经发送给小车";
                result.resultCode = 0;
                TaskHelper.UpdateStatus(model.TaskNo.Trim(), "取消");
                //TaskProcess.OperateStatus(task, 7);
                //TaskProcess.TaskCanCelOrComplete(task);
                TaskProcess.GeneralInterFaceFunc(task, "7");
                //IntensiveArea.ULlock(task.S_END_LOC);
                //解绑起点托盘
                //var trayInfoList = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == task.S_START_LOC).ToList();
                var trayInfoList = task.S_CNTRS.Split(',').ToList();
                if (trayInfoList.Count() > 0)
                {
                    trayInfoList.ForEach(a =>
                    {
                        db.Deleteable<LocCntrRel>().Where(b => b.S_CNTR_CODE == a).ExecuteCommand();
                        db.Deleteable<CntrItemRel>().Where(b => b.S_CNTR_CODE == a).ExecuteCommand();
                    });
                }
                LocationHelper.UnLockLoc(task.S_START_LOC);
                LocationHelper.UnLockLoc(task.S_END_LOC, task.S_TYPE);

            }
            else
            {
                result.resultMsg = "该任务号不存在";
                result.resultCode = -1;
            }

            return result;
        }

        internal static SimpleResultModel BHYiKuworkinfo(YiKuworkinfomodel model)
        {
            string endloc = "";
            int yikunum = 0;
            SimpleResultModel result = new SimpleResultModel { success = false };
            var db = new SqlHelper<WorkOrder>().GetInstance();
            if (!string.IsNullOrEmpty(model.S_WorkNo))
            {
                var info = db.Queryable<WorkOrder>().Where(a => a.S_WorkNo == model.S_WorkNo).First();
                if (info == null)
                {
                    var rowlist = db.Queryable<Location>()
                        .Where(a => a.S_AREA_CODE == model.S_EndLoca && a.N_CURRENT_NUM == 0 && a.S_LOCK_STATE == "无")
                        .PartitionBy(a => a.N_ROW)
                        .Take(1)
                        .ToList();
                    foreach (var item in rowlist)
                    {
                        endloc = endloc + item.N_ROW + ",";
                    }

                    if (model.S_YiKuNum == 0)
                    {
                        yikunum = 9999;
                    }
                    else
                    {
                        yikunum = model.S_YiKuNum;
                    }

                    WorkOrder wmsTask = new WorkOrder()
                    {
                        S_WorkNo = model.S_WorkNo,
                        //S_PLineNo = model.DeviceName,
                        //S_UsingNo = "N",
                        S_ORDER_TYPE = "备货移库",
                        S_ItemCode = model.S_ItemCode,
                        S_WorkState = model.S_WorkState,
                        S_StartLoca = model.S_StartLoca,
                        S_EndLoca = endloc,
                        S_YiKuNum = yikunum,
                        S_BatchNo = model.S_BatchNo
                        //S_Modify = model.WorkTime
                    };
                    WCSHelper.DaMingShanInsertWork(wmsTask);
                    result.success = true;
                    result.errMsg = $"工单信息接收成功，工单已创建！";
                }
                else
                {
                    result.errMsg = "工单号重复,工单表中有相同的数据";
                    result.errCode = -2;
                }
            }
            else
            {
                result.errMsg = "工单号不能为空";
                result.errCode = -1;
            }


            return result;
        }


        internal static SimpleResultModel YiKuworkinfo(YiKuworkinfomodel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false };
            var db = new SqlHelper<WorkOrder>().GetInstance();
            if (!string.IsNullOrEmpty(model.S_WorkNo))
            {
                var info = db.Queryable<WorkOrder>().Where(a => a.S_WorkNo == model.S_WorkNo).First();
                if (info == null)
                {
                    WorkOrder wmsTask = new WorkOrder()
                    {
                        S_WorkNo = model.S_WorkNo,
                        //S_PLineNo = model.DeviceName,
                        //S_UsingNo = "N",
                        S_ORDER_TYPE = "人工移库",
                        S_ItemCode = model.S_ItemCode,
                        S_WorkState = model.S_WorkState,
                        S_StartLoca = model.S_StartLoca,
                        S_EndLoca = model.S_EndLoca,
                        S_YiKuNum = model.S_YiKuNum,
                        S_BatchNo = model.S_BatchNo
                        //S_Modify = model.WorkTime
                    };
                    WCSHelper.DaMingShanInsertWork(wmsTask);
                    result.success = true;
                    result.errMsg = $"工单信息接收成功，工单已创建！";
                }
                else
                {
                    result.errMsg = "工单号重复,工单表中有相同的数据";
                    result.errCode = -2;
                }
            }
            else
            {
                result.errMsg = "工单号不能为空";
                result.errCode = -1;
            }


            return result;
        }

        /// <summary>
        /// 无码模式-人工分拣出库接口解绑托盘
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel NoCodeUnbindingTrayCode(NoCodeUnbindingTrayCodeModel model)
        {
            var result = new SimpleResultModel { success = false, errCode = -1 };
            string msg = ""; string locCode = ""; string areaCode = "";
            var db = new SqlHelper<object>().GetInstance();
            if (!string.IsNullOrEmpty(model.RowNo) && !string.IsNullOrEmpty(model.LockState))
            {
                var rowinfo = db.Queryable<Location>().Where(a => a.N_ROW == model.RowNo && (a.S_LOCK_STATE.Trim() == "入库锁" || a.S_LOCK_STATE.Trim() == "移库锁" || a.S_LOCK_STATE.Trim() == "出库锁")).First();
                if (rowinfo == null)
                {
                    if (model.LockState == "1")
                    {
                        //var rowInfo = db.Queryable<RowLock>().Where(a => a.N_ROW == model.RowNo).First();
                        //if (rowInfo != null)
                        //{
                        //    TaskController.Monitor.YiKuUnLockRow(db, model.RowNo.Trim(), rowInfo.S_AREA_CODE.Trim(), false);
                        var locInfo = db.Queryable<Location>().Where(a => a.N_ROW == model.RowNo.Trim()).ToList();
                        if (locInfo.Count() > 0)
                        {
                            locInfo.ForEach(a =>
                            {
                                if (a.S_LOCK_STATE.Trim() != "报废")
                                {
                                    a.S_LOCK_STATE = "其他锁";
                                    db.Updateable(a).UpdateColumns(b => new { b.S_LOCK_STATE }).ExecuteCommand();
                                }
                            });
                        }
                        result.success = true;
                        result.errCode = 0;
                        // }
                    }
                    else if (model.LockState == "2")
                    {
                        var locInfoList = db.Queryable<Location>().Where(a => a.N_ROW == model.RowNo.Trim()).ToList();
                        if (locInfoList.Count > 0)
                        {
                            for (int i = 0; i < locInfoList.Count; i++)
                            {
                                if (locInfoList[i].S_LOCK_STATE.Trim() != "报废")
                                {
                                    areaCode = locInfoList[i].S_AREA_CODE.Trim();
                                    locCode = locInfoList[i].S_LOC_CODE.Trim();
                                    var locInfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locCode).First();
                                    //if (model.IsDelete == "1")
                                    //{
                                    //    var trayInfoList = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == locCode).ToList();
                                    //    if (trayInfoList.Count() > 0)
                                    //    {
                                    //        trayInfoList.ForEach(a =>
                                    //        {
                                    //            db.Deleteable<LocCntrRel>().Where(b => b.S_CNTR_CODE == a.S_CNTR_CODE.Trim()).ExecuteCommand();
                                    //            db.Deleteable<CntrItemRel>().Where(b => b.S_CNTR_CODE == a.S_CNTR_CODE.Trim()).ExecuteCommand();
                                    //        });
                                    //    }
                                    //    locInfo.N_CURRENT_NUM = 0;
                                    //}
                                    //else if(model.IsDelete=="3") 
                                    //{
                                    //    locInfo.N_CURRENT_NUM = locInfo.N_CAPACITY;
                                    //}
                                    locInfo.S_LOCK_STATE = "无";
                                    db.Updateable(locInfo).UpdateColumns(a => new { a.S_LOCK_STATE }).ExecuteCommand();
                                }
                            }
                            result.success = true;
                            result.errCode = 0;
                            //TaskController.Monitor.YiKuUnLockRow(db, model.RowNo, areaCode);
                        }
                    }
                    else if (model.LockState == "3")
                    {
                        var locInfoList = db.Queryable<Location>().Where(a => a.N_ROW == model.RowNo.Trim()).ToList();
                        if (locInfoList.Count > 0)
                        {
                            for (int i = 0; i < locInfoList.Count; i++)
                            {
                                if (locInfoList[i].S_LOCK_STATE.Trim() != "报废")
                                {
                                    areaCode = locInfoList[i].S_AREA_CODE.Trim();
                                    locCode = locInfoList[i].S_LOC_CODE.Trim();
                                    var locInfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locCode).First();

                                    //if (model.IsDelete == "1")
                                    //{
                                    //    var trayInfoList = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == locCode).ToList();
                                    //    if (trayInfoList.Count() > 0)
                                    //    {
                                    //        trayInfoList.ForEach(a =>
                                    //        {
                                    //            db.Deleteable<LocCntrRel>().Where(b => b.S_CNTR_CODE == a.S_CNTR_CODE.Trim()).ExecuteCommand();
                                    //            db.Deleteable<CntrItemRel>().Where(b => b.S_CNTR_CODE == a.S_CNTR_CODE.Trim()).ExecuteCommand();
                                    //        });
                                    //    }
                                    //    locInfo.N_CURRENT_NUM = 0;
                                    //}
                                    //else if(model.IsDelete=="3") 
                                    //{
                                    locInfo.N_CURRENT_NUM = locInfo.N_CAPACITY;
                                    //}
                                    //locInfo.S_LOCK_STATE = "无";
                                    db.Updateable(locInfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                                }
                            }
                            result.success = true;
                            result.errCode = 0;
                            //TaskController.Monitor.YiKuUnLockRow(db, model.RowNo, areaCode);
                        }
                    }
                    else if (model.LockState == "4")
                    {
                        var locInfoList = db.Queryable<Location>().Where(a => a.N_ROW == model.RowNo.Trim()).ToList();
                        if (locInfoList.Count > 0)
                        {
                            for (int i = 0; i < locInfoList.Count; i++)
                            {
                                if (locInfoList[i].S_LOCK_STATE.Trim() != "报废")
                                {
                                    areaCode = locInfoList[i].S_AREA_CODE.Trim();
                                    locCode = locInfoList[i].S_LOC_CODE.Trim();
                                    var locInfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locCode).First();

                                    //if (model.IsDelete == "1")
                                    //{
                                    var trayInfoList = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == locCode).ToList();
                                    if (trayInfoList.Count() > 0)
                                    {
                                        trayInfoList.ForEach(a =>
                                        {
                                            db.Deleteable<LocCntrRel>().Where(b => b.S_CNTR_CODE == a.S_CNTR_CODE.Trim()).ExecuteCommand();
                                            db.Deleteable<CntrItemRel>().Where(b => b.S_CNTR_CODE == a.S_CNTR_CODE.Trim()).ExecuteCommand();
                                        });
                                    }
                                    locInfo.N_CURRENT_NUM = 0;
                                    //}
                                    //else if(model.IsDelete=="3") 
                                    //{
                                    //locInfo.N_CURRENT_NUM = locInfo.N_CAPACITY;
                                    //}
                                    //locInfo.S_LOCK_STATE = "无";
                                    db.Updateable(locInfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                                }
                            }
                            result.success = true;
                            result.errCode = 0;
                            //TaskController.Monitor.YiKuUnLockRow(db, model.RowNo, areaCode);
                        }
                    }
                }
                else
                {
                    msg = "该排有入库锁或移库锁，不予绑定解绑";
                }
            }
            else if (!string.IsNullOrEmpty(model.Location) && !string.IsNullOrEmpty(model.LockState))
            {
                var locinfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == model.Location && a.S_LOCK_STATE.Trim() == "无").First();
                if (locinfo != null)
                {
                    if (model.LockState == "5")
                    {
                        if (locinfo.S_LOCK_STATE != "报废")
                        {
                            locinfo.N_CURRENT_NUM = locinfo.N_CAPACITY;
                            db.Updateable(locinfo).UpdateColumns(it => new { it.N_CURRENT_NUM }).ExecuteCommand();
                            LocCntrRel info = new LocCntrRel { S_LOC_CODE = locinfo.S_LOC_CODE, S_CNTR_CODE = model.TrayNo, S_TRAY_TYPE = model.Type };
                            db.Insertable(info).ExecuteCommand();
                            result.success = true;
                            result.errCode = 0;
                        }
                        else
                        {
                            msg = "该货位状态为报废 不允许绑定操作";
                        }
                    }
                    if (model.LockState == "6")
                    {
                        locinfo.N_CURRENT_NUM = 0;
                        db.Updateable(locinfo).UpdateColumns(it => new { it.N_CURRENT_NUM }).ExecuteCommand();
                        db.Deleteable<LocCntrRel>().Where(a => a.S_LOC_CODE == locinfo.S_LOC_CODE).ExecuteCommand();
                        result.success = true;
                        result.errCode = 0;
                    }
                }
                else
                {
                    msg = "该货位状态异常，不予绑定解绑";
                }
            }
            else msg = $"MOBOX传输数据异常！传输为空值！";
            result.errMsg = msg;
            LogHelper.Info("NoCodeUnbindingTrayCode Dispose：" + result.errMsg, "ThirdSystemLog");
            return result;
        }
        #endregion

        #region   项目定制

        #region   西门子接口实现类
        /// <summary>
        /// 强制充电接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel ForcedCharging(OtherModel.ForcedChargingModel model)
        {
            SimpleResultModel result = new SimpleResultModel { errCode = -1 };
            try
            {
                bool charge = NDCHelper.SendChargeTask(model.agvNo);
                if (charge)
                {
                    result.errCode = 0;
                    result.errMsg = "推送小车充电成功！";
                    result.success = true;
                }
                else
                {
                    result.errMsg = "推送小车充电失败！";
                    result.success = false;
                }
            }
            catch
            {
                result.errMsg = "推送小车充电失败,未查询到车号！";
                result.success = false;
            }

            return result;
        }
        /// <summary>
        /// 取消任务接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel CancelTask(CancelTaskModel model)
        {
            SimpleResultModel result = new SimpleResultModel { errCode = -1, success = false };

            var task = TaskHelper.GetTaskBySrcNo(model.taskNo);
            if (task != null)
            {
                if (task.S_B_STATE.Trim() == "未执行")
                {
                    //未执行直接修改状态为取消
                    TaskHelper.UpdateStatus(task.S_TASK_NO, "取消");
                    result.success = true;
                    result.errCode = 0;
                    result.errMsg = "任务未执行，取消成功";
                }
                else if (task.S_B_STATE.Trim() != "取消" && task.S_B_STATE.Trim() != "完成")
                {
                    //已推送但是没有完成或者取消，通知hosttoagv
                    NDCHelper.Cancel(task.S_TASK_NO.Trim());
                    result.success = true;
                    result.errCode = 0;
                    result.errMsg = "任务取消已经发送给小车";
                }
                else result.errMsg = "任务已结束";
            }
            else result.errMsg = "任务不存在";

            return result;
        }
        /// <summary>
        /// 调整优先级接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel SetPriority(SetPriorityModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = true, errCode = -1 };
            var taskPriority = TaskHelper.GetTaskBySrcNo(model.taskNo);
            if (taskPriority != null)
            {
                if (taskPriority.S_B_STATE == "未执行" || taskPriority.S_B_STATE == "待推送" || taskPriority.S_B_STATE == "已推送")
                {
                    TaskHelper.UpdatePriority(taskPriority.S_TASK_NO, int.Parse(model.priority));//更改表数据
                    //if (taskPriority.S_B_STATE == "已推送") ;
                    result.errCode = 0;
                    result.errMsg = $"更改优先级成功！任务号：{model.taskNo}";
                    result.success = true;
                }
                else
                {
                    result.errMsg = $"更改优先级失败，当前任务已执行！任务号：{model.taskNo}";
                    result.success = false;
                }
            }
            else
            {
                result.errMsg = $"更改优先级失败，当前任务已经执行完毕或取消！任务号：{model.taskNo}";
                result.success = false;
            }
            LogHelper.Debug("SetPriority Request：" + JsonConvert.SerializeObject(result));
            return result;
        }
        /// <summary>
        /// 创建任务接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel AddTask(OtherModel.AddTaskModel model)
        {
            SimpleResultModel result = new SimpleResultModel { errCode = 0 };
            bool req = false;
            //string trayCodeType = ProcessHelper.GetTrayCode(model.trayCode);//获取托盘类型-对应杭叉提供参数
            //来源号判断是否存在
            if (!TaskHelper.CheckExistSrc(model.taskNo))
            {
                if (LocationHelper.CheckExist(model.startBit) && LocationHelper.CheckExist(model.endBit))
                {
                    req = TaskHelper.CreateTask(model.taskNo, model.startBit, model.endBit, model.taskType, 99, model.trayCode);
                }
                if (req == false)
                {
                    result.errCode = -1;
                    result.success = false;
                    result.errMsg = "创建任务失败";
                }
                else
                {
                    result.errCode = 0;
                    result.success = true;
                    result.errMsg = "创建成功";
                }
            }
            else
            {
                result.errCode = -1;
                result.success = false;
                result.errMsg = "任务已存在，无法再次创建！";
            }
            return result;
        }
        #endregion


        #endregion
    }
}