using Newtonsoft.Json;
using NongFuWebApi.Services;
using NongFuWebApi.Controllers;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using static NongFuWebApi.Controllers.AMSModel;
using System.Configuration;

namespace NongFuWebApi.Models
{
    public class ApiHelper
    {
        private static HttpHelper httpHelper = new HttpHelper();
        static string url = ConfigurationManager.AppSettings["WMSUrl"].ToString();

        #region 靖宇接口方法
        /// <summary>
        /// 工单信息获取接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel WorkInfo(TASK_WorkInfoModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            try
            {
                var db = new SqlHelper<WorkOrder1>().GetInstance();
                var workInfo = db.Queryable<WorkOrder1>().Where(a => a.S_WorkNo == model.WorkNo).First();
                //bool req = false;
                //查询执行中或者处于暂停的  当前产线工单
                //如果不存在，即插入工单表数据信息，默认执行中
                //反之，判断当前是否为  结束工单，如果是，更新结束时间，反之，返回工单已存在
                //WorkState  1-新建  2-完成

                if (workInfo == null && model.WorkState == "1")
                {
                    //如果物料名称用物料表物料名称，查询物料表物料名称

                    var iteminfo = db.Queryable<ItemInfo>().Where(a => a.S_ITEM_CODE == model.MaterialCode).First();
                    if (iteminfo != null)
                    {
                        model.ItemCode = iteminfo.S_ITEM_NAME;
                    }


                    WorkOrder1 wmsTask = new WorkOrder1()
                    {
                        S_WorkNo = model.WorkNo,
                        S_PLineNo = model.DeviceName,
                        // SQL_UsingNo = "N",
                        S_ORDER_TYPE = "产线下线",
                        S_ItemCode = model.MaterialCode,
                        SQL_ItemName = model.ItemCode,
                        S_WorkState = "新建",
                        withCode = "是",
                        S_Modify = model.WorkTime,
                        // MaterialCode = model.MaterialCode
                    };
                    TaskHelper.JingYuInsertWork(wmsTask);
                    result.success = true;
                    result.errMsg = $"工单信息接收成功，工单已创建！";
                    string deviceName = model.DeviceName;
                    //SendPlcWorkState(deviceName);
                }
                else if (workInfo != null && model.WorkState == "2")
                {
                    if (!workInfo.S_WorkState.Trim().Contains("完成"))
                    {
                        TaskHelper.UpdateStatus1(workInfo, "已完成", model.WorkTime);
                        result.success = true;
                        result.errMsg = $"工单信息接收成功，工单已完成！";
                        string deviceName = model.DeviceName;
                        //SendPlcWorkState(deviceName, false);
                    }
                    else result.errMsg = $"工单信息接收成功，工单已完成！";
                }
                else if (workInfo != null && model.WorkState == "1") result.errMsg = $"当前工单已存在。工单号：{workInfo.S_WorkNo}，产线号：{model.DeviceName}";
            }
            catch (Exception ex)
            {
                result.errMsg = $"工单信息接收异常：{ex.Message}";
            }
            return result;
        }

        /// <summary>
        /// 富勒托盘  带更改托盘码的托盘信息下发方法
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel SendTrayCode(SendTrayCodeModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            var db = new SqlHelper<object>().GetInstance();
            string msg = "";
            try
            {
                model.TrayInfo.ForEach(a =>
                {
                    /* 富勒更新异常托盘流程
                     * 1.替换码必定有值
                     * 2.如果存在原码：
                     *      a.中间表有数据，直接使用 替换码 替换中间表 原码 托盘数据      --OVER
                     *      b.中间表，托盘物料表 均无 原码 数据，则 使用托盘码插入数据    --OVER
                     *      c.中间表无数据，托盘物料表有 原码 数据，则表示，当前托盘已经生成任务，
                     *        直接替换 任务表，托盘物料表数据  备注：如果 货位托盘表 存在数据，则需要一并替换    --OVER
                     * 3.如果不存在原码：
                     *      a.直接使用 替换码 插入中间表 数据     --OVER
                     * **/
                    var trayInfo = TaskHelper.GetJingYuTrayInfo(a.trayCode, a.trayNum);
                    if (trayInfo == null)
                    {
                        string TrayCode = string.IsNullOrEmpty(a.trayCode) ? a.sign : a.trayCode;
                        if (!string.IsNullOrEmpty(a.sign) && !string.IsNullOrEmpty(a.trayCode))
                        {
                            //中间表无数据，判断托盘物料表
                            var trayItemTable = db.Queryable<CntrItemRel>().Where(it => it.S_CNTR_CODE == a.trayCode).First();
                            if (trayItemTable != null)
                            {
                                //存在数据--更新相关任务数据以及当前托盘物料数据
                                trayItemTable.S_CNTR_CODE = a.sign;
                                var taskInfo = db.Queryable<WMSTask>().Where(it => it.S_CNTRS.Contains(a.trayCode)).OrderByDescending(it => it.T_CREATE).First();
                                if (taskInfo != null)
                                {
                                    string cntrs = taskInfo.S_CNTRS.Replace(a.trayCode, a.sign);
                                    taskInfo.S_CNTRS = cntrs;
                                    db.Updateable(trayItemTable).WhereColumns(it => new { it.S_ID }).UpdateColumns(it => new { it.S_CNTR_CODE }).ExecuteCommand();
                                    db.Updateable(taskInfo).UpdateColumns(b => new { b.S_CNTRS }).ExecuteCommand();
                                    // UpdateScreenTable(a, db);//更新 屏幕显示表 托盘数据
                                    msg = msg + $"更新托盘数据成功:已同步任务以及托盘物料表相关更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                                    var locTrayInfo = db.Queryable<LocCntrRel>().Where(it => it.S_CNTR_CODE == a.trayCode).First();
                                    if (locTrayInfo != null)
                                    {
                                        locTrayInfo.S_CNTR_CODE = a.sign;
                                        db.Updateable(locTrayInfo).UpdateColumns(b => new { b.S_CNTR_CODE }).ExecuteCommand();
                                    }
                                    result.success = true;
                                }
                            }
                            else
                            {
                                TaskHelper.InsertTrayCodeJy(a, a.sign, a.deviceName, db, ref msg);//不存在数据--插入中间表数据
                                msg = msg + $"更新托盘数据异常：当前 托盘物料表不存在此托盘信息，直接插入中间表数据。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            }
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据处理反馈：" + $"{msg}", "ThirdSystemLog");
                        }
                        else
                        {
                            TaskHelper.InsertTrayCodeJy(a, TrayCode, a.deviceName, db, ref msg);
                            result.success = true;
                            result.errCode = 0;
                            if (!string.IsNullOrEmpty(a.trayCode)) msg = msg + $"插入托盘数据成功:托盘号：{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            else msg = msg + $"更新托盘数据成功:托盘号：{a.trayCode},更新码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：处理托盘数据成功！" + $"托盘码:{a.trayCode},更新码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
                        }
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(a.sign))
                        {
                            trayInfo.workNo = a.workNo;
                            trayInfo.trayCode = a.sign;
                            trayInfo.trayNum = a.trayNum;
                            trayInfo.batchNo = a.batchNo;
                            trayInfo.trayRule = a.trayRule;
                            trayInfo.itemLayer = a.itemLayer;
                            db.Updateable(trayInfo).UpdateColumns(b => new { b.workNo, b.trayCode, b.trayNum, b.batchNo, b.trayRule, b.itemLayer }).ExecuteCommand();
                            var workInfo = db.Queryable<WorkOrder1>().Where(b => b.S_PLineNo == a.deviceName && b.S_WorkNo == a.workNo).First();
                            if (workInfo != null)
                            {
                                workInfo.S_ItemLayer = a.itemLayer;
                                db.Updateable(workInfo).UpdateColumns(b => new { b.S_ItemLayer }).ExecuteCommand();
                            }
                            //UpdateScreenTable(a, db);//更新 屏幕显示表 托盘数据
                            result.success = true;
                            msg = msg + $"更新托盘数据成功:托盘已更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据成功！" + $"托盘已更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};", "ThirdSystemLog");
                        }
                        else
                        {
                            result.success = false;
                            msg = msg + $"更新托盘数据失败:未传输替换码。托盘号：{a.trayCode},替换码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据失败！" + $"托盘码:{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
                        }
                    }
                });
                result.errMsg = msg;
            }
            catch (Exception ex)
            {
                LogHelper.Error($"SendTrayCode Error:{ex.Message}", ex);
            }
            return result;
        }

        /// <summary>
        /// 人工分拣出库接口解绑托盘
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel UnbindingTrayCode(UnbindingTrayCodeModel model)
        {
            var result = new SimpleResultModel { success = false, errCode = -1 };
            string msg = ""; int n = 0; string locCode = "";
            var db = new SqlHelper<object>().GetInstance();
            if (model.TrayInfo != null)
            {
                for (int i = 0; i < model.TrayInfo.Count(); i++)
                {

                    string cntrCode = model.TrayInfo[i];
                    LogHelper.Info($"删除托盘{cntrCode}");
                    var trayInfo = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == cntrCode).First();
                    if (trayInfo != null)
                    {
                        locCode = trayInfo.S_LOC_CODE.Trim();
                        //排锁表操作
                        //if (!string.IsNullOrEmpty(locCode))
                        //{
                        //    var locInfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locCode).First();
                        //    if (locInfo != null)
                        //    {
                        //        TaskHelper.YiKuUnLockRow(db, locInfo.N_ROW.Trim(), locInfo.S_AREA_CODE.Trim(), false, false, true);
                        //        var Srow = db.Queryable<RowLock>().Where(a => a.N_ROW == locInfo.N_ROW.Trim() && a.S_AREA_CODE == locInfo.S_AREA_CODE.Trim()).First();
                        //        if (Srow != null)
                        //        {
                        //            Srow.S_LOCK_STATE = "其他锁";
                        //            db.Updateable(Srow).UpdateColumns(a => new { a.S_LOCK_STATE }).ExecuteCommand();
                        //        }
                        //    }
                        //}


                        result.success = true;
                        if (db.Deleteable<LocCntrRel>(a => a.S_CNTR_CODE == cntrCode).ExecuteCommand() <= 0)
                        {
                            db.Deleteable<LocCntrRel>(a => a.S_CNTR_CODE == cntrCode).ExecuteCommand();
                        }
                        if (db.Deleteable<CntrItemRel>(a => a.S_CNTR_CODE == cntrCode).ExecuteCommand() <= 0)
                        {
                            db.Deleteable<CntrItemRel>(a => a.S_CNTR_CODE == cntrCode).ExecuteCommand();
                        }

                        msg = msg + $"{n++}:当前托盘号：{model.TrayInfo[i]},解绑成功！";
                    }
                    else
                    {
                        msg = msg + $"{n++}:当前托盘号：{model.TrayInfo[i]},不存在对应货位！";
                    }
                    if (!string.IsNullOrEmpty(locCode))
                    {
                        var locNum = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == locCode).ToList();
                        int num = 0;
                        var locInfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locCode).First();

                        if (locInfo != null)
                        {
                            RowLocLock(locInfo);
                            locInfo.N_CURRENT_NUM = GetLocTrayNum(locNum, num);
                            LogHelper.Info("UnbindingTrayCode Dispose：更新当前货位当前数量！" + $"货位编码：{locCode},数量：{locInfo.N_CURRENT_NUM}", "ThirdSystemLog");
                            db.Updateable(locInfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                            var locaHaveTray = db.Queryable<Location>().Where(a => a.N_ROW == locInfo.N_ROW.Trim() && a.N_CURRENT_NUM > 0).ToList();
                            if (locaHaveTray.Count == 0) TaskHelper.YiKuUnLockRow(db, locInfo.N_ROW.Trim(), locInfo.S_AREA_CODE.Trim(), true, false, true);
                            //else TaskController.Monitor.YiKuUnLockRow(db, locInfo.N_ROW.Trim(), locInfo.S_AREA_CODE.Trim(), false);
                        }
                    }
                }
            }
            else
            {
                msg = $"人工分拣出库：富勒传输数据异常！传输为空值！";
            }
            result.errMsg = msg;
            LogHelper.Info("UnbindingTrayCode Dispose：" + result.errMsg, "ThirdSystemLog");
            return result;
        }
        /// <summary>
        /// 分拣出库锁定一排，托盘全部解绑完成解锁单个货位
        /// </summary>
        /// <param name="loc"></param>
        /// <param name="res"></param>
        private static void RowLocLock(Location loc)
        {
            var db = new SqlHelper<object>().GetInstance();
            if (loc.S_LOCK_STATE != "无")
            {
                var locNum = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == loc.S_LOC_CODE).ToList();
                if (locNum.Count <= 0)
                {
                    var loclist = db.Queryable<Location>().Where(a => a.S_AREA_CODE == loc.S_AREA_CODE && a.N_ROW == loc.N_ROW && a.N_CURRENT_NUM > 0).ToList();
                    if (loclist.Count > 1)
                    {
                        TaskHelper.UpdateLocStock(loc, "无");
                    }

                }
            }
            else
            {
                var loclist = db.Queryable<Location>().Where(a => a.S_AREA_CODE == loc.S_AREA_CODE && a.N_ROW == loc.N_ROW && a.N_CURRENT_NUM > 0).ToList();
                if (loclist.Count > 0)
                {
                    loclist.ForEach(a =>
                    {
                        TaskHelper.UpdateLocStock(a, "出库锁");

                    });
                }
            }


        }

        #endregion



        /// <summary>
        /// 工单信息获取接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel WorkInfoCA(TASK_WorkInfoModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            try
            {
                var db = new SqlHelper<ChunAnWorkOrder>().GetInstance();
                var workInfo = db.Queryable<ChunAnWorkOrder>().Where(a => a.SQL_WorkNo == model.WorkNo).First();
                //bool req = false;
                //查询执行中或者处于暂停的  当前产线工单
                //如果不存在，即插入工单表数据信息，默认执行中
                //反之，判断当前是否为  结束工单，如果是，更新结束时间，反之，返回工单已存在
                //WorkState  1-新建  2-完成
                if (workInfo == null && model.WorkState == "1")
                {
                    ChunAnWorkOrder wmsTask = new ChunAnWorkOrder()
                    {
                        SQL_WorkNo = model.WorkNo,
                        SQL_PLineNo = model.DeviceName,
                        SQL_UsingNo = "N",
                        SQL_ORDER_TYPE = "产线下线",
                        SQL_ItemCode = model.ItemCode,
                        SQL_State = "新建",
                        SQL_Modify = model.WorkTime,
                        MaterialCode = model.MaterialCode
                    };
                    TaskHelper.ChunAnInsertWork(wmsTask);
                    result.success = true;
                    result.errMsg = $"工单信息接收成功，工单已创建！";
                    string deviceName = model.DeviceName;
                    SendPlcWorkState(deviceName);
                }
                else if (workInfo != null && model.WorkState == "2")
                {
                    if (!workInfo.SQL_State.Trim().Contains("完成"))
                    {
                        TaskHelper.UpdateStatus(workInfo, "已完成", model.WorkTime);
                        result.success = true;
                        result.errMsg = $"工单信息接收成功，工单已完成！";
                        string deviceName = model.DeviceName;
                        SendPlcWorkState(deviceName, false);
                    }
                    else result.errMsg = $"工单信息接收成功，工单已完成！";
                }
                else if (workInfo != null && model.WorkState == "1") result.errMsg = $"当前工单已存在。工单号：{workInfo.SQL_WorkNo}，产线号：{model.DeviceName}";
            }
            catch (Exception ex)
            {
                result.errMsg = $"工单信息接收异常：{ex.Message}";
            }
            return result;
        }

        /// <summary>
        /// 工单信息获取接口（标准工单模型）
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel WorkInfoStand(TASK_WorkInfoModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var workInfo = db.Queryable<ConveryWorkOrder>().Where(a => a.S_WorkNo == model.WorkNo).First();
                //bool req = false;
                //查询执行中或者处于暂停的  当前产线工单
                //如果不存在，即插入工单表数据信息，默认执行中
                //反之，判断当前是否为  结束工单，如果是，更新结束时间，反之，返回工单已存在
                //WorkState  1-新建  2-完成
                if (workInfo == null && model.WorkState == "1")
                {
                    ConveryWorkOrder wmsTask = new ConveryWorkOrder()
                    {
                        S_WorkNo = model.WorkNo,
                        S_PLineNo = model.DeviceName,
                        S_ORDER_TYPE = "产线下线",
                        S_ItemCode = model.MaterialCode,
                        S_WorkState = "新建",
                        T_MODIFY = DateTime.Parse(model.WorkTime)
                    };
                    result.success = db.Insertable(wmsTask).ExecuteCommand() > 0;
                    result.success = true;
                    result.errMsg = $"工单信息接收成功，工单已创建！";
                }
                else if (workInfo != null && model.WorkState == "2")
                {
                    if (!workInfo.S_WorkState.Trim().Contains("完成"))
                    {
                        workInfo.S_WorkState = "已完成";
                        db.Updateable(workInfo).UpdateColumns(it => new { it.S_WorkState }).ExecuteCommand();
                        result.success = true;
                        result.errMsg = $"工单信息接收成功，工单已完成！";
                    }
                    else result.errMsg = $"工单信息接收成功，工单已完成！";
                }
                else if (workInfo != null && model.WorkState == "1") result.errMsg = $"当前工单已存在。工单号：{workInfo.S_WorkNo}，产线号：{model.DeviceName}";
            }
            catch (Exception ex)
            {
                result.errMsg = $"工单信息接收异常：{ex.Message}";
            }
            return result;
        }

        /// <summary>
        /// 向PLC发送工单开启或关闭状态
        /// </summary>
        /// <param name="deviceName"></param>
        /// <param name="state">true-新建 false-完成</param>
        private static bool SendPlcWorkState(string deviceName, bool state = true)
        {
            bool result = false;
            string sendTcpMsg = "";
            string deviceIP = ConfigurationManager.AppSettings[deviceName].ToString();
            if (state) sendTcpMsg = "3F00300d0a";
            else sendTcpMsg = "3F00400d0a";
            if (!string.IsNullOrEmpty(sendTcpMsg) && !string.IsNullOrEmpty(deviceIP))
            {
                var db = new SqlHelper<ChunAnCacheData>().GetInstance();
                var cacheData = db.Queryable<ChunAnCacheData>().Where(a => a.DataSign == "TcpData" && a.Ext1 == deviceIP && a.Ext2 == sendTcpMsg).First();
                if (cacheData == null)
                {
                    ChunAnCacheData chunAnCacheData = new ChunAnCacheData
                    {
                        DataSign = "TcpData",
                        Ext1 = deviceIP,
                        Ext2 = sendTcpMsg
                    };
                    result = db.Insertable(chunAnCacheData).ExecuteCommand() > 0;
                }
            }
            return result;
        }

        /// <summary>
        /// 生产下线托盘信息下发接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>

        #region   标准托盘信息下发方法
        //internal static SimpleResultModel SendTrayCode(SendTrayCodeModel model)
        //{
        //    SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
        //    var db = new SqlHelper<object>().GetInstance();
        //    string msg = "";
        //    try
        //    {
        //        model.TrayInfo.ForEach(a =>
        //        {
        //            //托盘码唯一：已存在入库的托盘码不允许再插入中间表
        //            var trayAreaInfo = db.Queryable<LocCntrRel>().Where(b => b.S_CNTR_CODE == a.trayCode).First();
        //            if (trayAreaInfo == null)
        //            {
        //                var trayInfo = TaskHelper.GetChunAnTrayInfo(a.trayCode, a.trayNum);
        //                if (trayInfo == null)
        //                {
        //                    if (!string.IsNullOrEmpty(a.sign))
        //                    {
        //                        msg = msg + $"更新托盘数据失败:托盘已不存在。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
        //                        LogHelper.Info("SendTrayCode Dispose：更新托盘数据失败！" + $"托盘已不存在。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};", "ThirdSystemLog");
        //                    }
        //                    else
        //                    {
        //                        ChunAnTrayInfo ChunAnTrayInfo = new ChunAnTrayInfo()
        //                        {
        //                            deviceName = a.deviceName,
        //                            workNo = a.workNo,
        //                            trayCode = a.trayCode,
        //                            trayNum = a.trayNum,
        //                            dateTime = a.dateTime,
        //                            batchNo = a.batchNo,
        //                            trayRule = a.trayRule,
        //                            itemLayer = a.itemLayer
        //                        };
        //                        TaskHelper.ChunAnInsertTrayInfo(ChunAnTrayInfo);
        //                        result.success = true;
        //                        result.errCode = 0;
        //                        msg = msg + $"插入托盘数据成功:托盘号：{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
        //                        LogHelper.Info("SendTrayCode Dispose：插入托盘数据成功！" + $"托盘码:{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
        //                    }
        //                }
        //                else
        //                {
        //                    if (!string.IsNullOrEmpty(a.sign))
        //                    {
        //                        trayInfo.workNo = a.workNo;
        //                        trayInfo.trayCode = a.sign;
        //                        trayInfo.trayNum = a.trayNum;
        //                        trayInfo.batchNo = a.batchNo;
        //                        trayInfo.trayRule = a.trayRule;
        //                        trayInfo.itemLayer = a.itemLayer;
        //                        db.Updateable(trayInfo).UpdateColumns(b => new { b.workNo, b.trayCode, b.trayNum, b.batchNo, b.trayRule, b.itemLayer }).ExecuteCommand();
        //                        msg = msg + $"更新托盘数据成功:托盘已更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
        //                        LogHelper.Info("SendTrayCode Dispose：更新托盘数据成功！" + $"托盘已更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};", "ThirdSystemLog");
        //                    }
        //                    else
        //                    {
        //                        result.success = false;
        //                        msg = msg + $"插入托盘数据失败:托盘号：{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
        //                        LogHelper.Info("SendTrayCode Dispose：插入托盘数据失败！" + $"托盘码:{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
        //                    }
        //                }
        //            }
        //            else
        //            {
        //                result.success = false;
        //                msg = msg + $"插入托盘数据失败:托盘已存在。货位号：{trayAreaInfo.S_LOC_CODE.Trim()},托盘号：{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
        //                LogHelper.Info("SendTrayCode Dispose：插入托盘数据失败！" + $"托盘已存在。货位号：{trayAreaInfo.S_LOC_CODE.Trim()},托盘码:{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
        //            }
        //        });
        //        result.errMsg = msg;
        //    }
        //    catch (Exception ex)
        //    {
        //        LogHelper.Error($"SendTrayCode Error:{ex.Message}", ex);
        //        result.errMsg = ex.Message;
        //    }
        //    return result;
        //}
        #endregion

        #region   带更改托盘码的托盘信息下发方法
        internal static SimpleResultModel SendTrayCodeCA(SendTrayCodeModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            var db = new SqlHelper<object>().GetInstance();
            string msg = "";
            try
            {
                model.TrayInfo.ForEach(a =>
                {
                    /* 富勒更新异常托盘流程
                     * 1.替换码必定有值
                     * 2.如果存在原码：
                     *      a.中间表有数据，直接使用 替换码 替换中间表 原码 托盘数据      --OVER
                     *      b.中间表，托盘物料表 均无 原码 数据，则 使用托盘码插入数据    --OVER
                     *      c.中间表无数据，托盘物料表有 原码 数据，则表示，当前托盘已经生成任务，
                     *        直接替换 任务表，托盘物料表数据  备注：如果 货位托盘表 存在数据，则需要一并替换    --OVER
                     * 3.如果不存在原码：
                     *      a.直接使用 替换码 插入中间表 数据     --OVER
                     * **/
                    var trayInfo = TaskHelper.GetChunAnTrayInfo(a.trayCode, a.trayNum);
                    if (trayInfo == null)
                    {
                        string TrayCode = string.IsNullOrEmpty(a.trayCode) ? a.sign : a.trayCode;
                        if (!string.IsNullOrEmpty(a.sign) && !string.IsNullOrEmpty(a.trayCode))
                        {
                            //中间表无数据，判断托盘物料表
                            var trayItemTable = db.Queryable<CntrItemRel>().Where(it => it.S_CNTR_CODE == a.trayCode).First();
                            if (trayItemTable != null)
                            {
                                //存在数据--更新相关任务数据以及当前托盘物料数据
                                trayItemTable.S_CNTR_CODE = a.sign;
                                var taskInfo = db.Queryable<WMSTask>().Where(it => it.S_CNTRS.Contains(a.trayCode)).OrderByDescending(it => it.T_CREATE).First();
                                if (taskInfo != null)
                                {
                                    string cntrs = taskInfo.S_CNTRS.Replace(a.trayCode, a.sign);
                                    taskInfo.S_CNTRS = cntrs;
                                    db.Updateable(trayItemTable).WhereColumns(it => new { it.S_ID }).UpdateColumns(it => new { it.S_CNTR_CODE }).ExecuteCommand();
                                    db.Updateable(taskInfo).UpdateColumns(b => new { b.S_CNTRS }).ExecuteCommand();
                                    UpdateScreenTable(a, db);//更新 屏幕显示表 托盘数据
                                    msg = msg + $"更新托盘数据成功:已同步任务以及托盘物料表相关更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                                    var locTrayInfo = db.Queryable<LocCntrRel>().Where(it => it.S_CNTR_CODE == a.trayCode).First();
                                    if (locTrayInfo != null)
                                    {
                                        locTrayInfo.S_CNTR_CODE = a.sign;
                                        db.Updateable(locTrayInfo).UpdateColumns(b => new { b.S_CNTR_CODE }).ExecuteCommand();
                                    }
                                    result.success = true;
                                }
                            }
                            else
                            {
                                TaskHelper.InsertTrayCode(a, a.sign, a.deviceName, db, ref msg);//不存在数据--插入中间表数据
                                msg = msg + $"更新托盘数据异常：当前 托盘物料表不存在此托盘信息，直接插入中间表数据。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            }
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据处理反馈：" + $"{msg}", "ThirdSystemLog");
                        }
                        else
                        {
                            TaskHelper.InsertTrayCode(a, TrayCode, a.deviceName, db, ref msg);
                            result.success = true;
                            result.errCode = 0;
                            if (!string.IsNullOrEmpty(a.trayCode)) msg = msg + $"插入托盘数据成功:托盘号：{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            else msg = msg + $"更新托盘数据成功:托盘号：{a.trayCode},更新码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：处理托盘数据成功！" + $"托盘码:{a.trayCode},更新码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
                        }
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(a.sign))
                        {
                            trayInfo.workNo = a.workNo;
                            trayInfo.trayCode = a.sign;
                            trayInfo.trayNum = a.trayNum;
                            trayInfo.batchNo = a.batchNo;
                            trayInfo.trayRule = a.trayRule;
                            trayInfo.itemLayer = a.itemLayer;
                            db.Updateable(trayInfo).UpdateColumns(b => new { b.workNo, b.trayCode, b.trayNum, b.batchNo, b.trayRule, b.itemLayer }).ExecuteCommand();
                            UpdateScreenTable(a, db);//更新 屏幕显示表 托盘数据
                            result.success = true;
                            msg = msg + $"更新托盘数据成功:托盘已更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据成功！" + $"托盘已更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};", "ThirdSystemLog");
                        }
                        else
                        {
                            result.success = false;
                            msg = msg + $"更新托盘数据失败:未传输替换码。托盘号：{a.trayCode},替换码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据失败！" + $"托盘码:{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
                        }
                    }
                });
                result.errMsg = msg;
            }
            catch (Exception ex)
            {
                LogHelper.Error($"SendTrayCode Error:{ex.Message}", ex);
            }
            return result;
        }

        internal static SimpleResultModel SendTrayCodeStand(SendTrayCodeModel model)
        {
            SimpleResultModel result = new SimpleResultModel { success = false, errCode = -1 };
            var db = new SqlHelper<object>().GetInstance();
            string msg = "";
            try
            {
                model.TrayInfo.ForEach(a =>
                {
                    var trayInfo = db.Queryable<ChunAnTrayInfoTwo>().Where(it => it.trayCode == a.trayCode && it.trayNum == a.trayNum).First();
                    if (trayInfo == null)
                    {
                        // 如果富勒未传输托盘码，则将替换码作为托盘码使用
                        string TrayCode = string.IsNullOrEmpty(a.trayCode) ? a.sign : a.trayCode;
                        if (!string.IsNullOrEmpty(a.sign) && !string.IsNullOrEmpty(a.trayCode))
                        {
                            //调用WMS接口查询当前托盘是否已经入库，如果入库则传输托盘码给WMS；反之，则插入托盘中间表作为新托盘使用

                            string res = JsonConvert.SerializeObject(new
                            {
                                trayCode = a.trayCode
                            });
                            string req = httpHelper.WebPost(url + "QueryTrayCode", res);
                            msg = msg + $"调用WMS返回结果：入参：{res},回参：{req};";
                            if (!string.IsNullOrEmpty(req))
                            {
                                var reqInfo = JsonConvert.DeserializeObject<SimpleResultModel>(req);
                                if (reqInfo.success)
                                {
                                    //调用WMS接口传输托盘数据
                                    string res1 = JsonConvert.SerializeObject(new
                                    {
                                        deviceName = a.deviceName,
                                        workNo = a.workNo,
                                        trayCode = a.trayCode,
                                        trayNum = a.trayNum,
                                        dateTime = a.dateTime,
                                        batchNo = a.batchNo,
                                        trayRule = a.trayRule,
                                        itemLayer = a.itemLayer,
                                        sign = a.sign
                                    });
                                    string req1 = httpHelper.WebPost(url + "SendTrayCode", res1);
                                    LogHelper.Info($"SendTrayCode WMSReq:{req1}", "ThirdSystemLog");
                                }
                                else
                                {
                                    SendTrayCodeStandInsertTrayData(a, result, db, trayInfo, TrayCode);
                                    msg = msg + $"更新托盘数据异常：当前 托盘物料表不存在此托盘信息，直接插入中间表数据。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                                }
                            }
                            else
                            {
                                SendTrayCodeStandInsertTrayData(a, result, db, trayInfo, TrayCode);
                                msg = msg + $"更新托盘数据异常：调用WMS查询托盘失败，直接插入中间表数据。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            }
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据处理反馈：" + $"{msg}", "ThirdSystemLog");
                        }
                        else
                        {
                            SendTrayCodeStandInsertTrayData(a, result, db, trayInfo, TrayCode);
                            result.errCode = 0;
                            if (!string.IsNullOrEmpty(a.trayCode)) msg = msg + $"插入托盘数据成功:托盘号：{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            else msg = msg + $"更新托盘数据成功:托盘号：{a.trayCode},更新码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：处理托盘数据成功！" + $"托盘码:{a.trayCode},更新码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
                        }
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(a.sign))
                        {
                            trayInfo.workNo = a.workNo;
                            trayInfo.trayCode = a.sign;
                            trayInfo.trayNum = a.trayNum;
                            trayInfo.batchNo = a.batchNo;
                            trayInfo.trayRule = a.trayRule;
                            trayInfo.itemLayer = a.itemLayer;
                            db.Updateable(trayInfo).UpdateColumns(b => new { b.workNo, b.trayCode, b.trayNum, b.batchNo, b.trayRule, b.itemLayer }).ExecuteCommand();
                            result.success = true;
                            msg = msg + $"更新托盘数据成功:托盘已更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据成功！" + $"托盘已更新。托盘号：{a.trayCode},更新托盘号：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};", "ThirdSystemLog");
                        }
                        else
                        {
                            result.success = false;
                            msg = msg + $"更新托盘数据失败:未传输替换码。托盘号：{a.trayCode},替换码：{a.sign},托盘数量：{a.trayNum},托盘时间：{a.dateTime};";
                            LogHelper.Info("SendTrayCode Dispose：更新托盘数据失败！" + $"托盘码:{a.trayCode},托盘数量：{a.trayNum},托盘时间：{a.dateTime}", "ThirdSystemLog");
                        }
                    }
                });
                result.errMsg = msg;
            }
            catch (Exception ex)
            {
                LogHelper.Error($"SendTrayCode Error:{ex.Message}", ex);
            }
            return result;
        }

        /// <summary>
        /// 梅坪-插入托盘数据
        /// </summary>
        /// <param name="a"></param>
        /// <param name="result"></param>
        /// <param name="db"></param>
        /// <param name="trayInfo"></param>
        /// <param name="TrayCode"></param>
        private static void SendTrayCodeStandInsertTrayData(TrayInfo a, SimpleResultModel result, SqlSugar.SqlSugarClient db, ChunAnTrayInfoTwo trayInfo, string TrayCode)
        {
            ChunAnTrayInfoTwo ChunAnTrayInfo = new ChunAnTrayInfoTwo()
            {
                deviceName = a.deviceName,
                workNo = a.workNo,
                trayCode = TrayCode,
                trayNum = a.trayNum,
                dateTime = a.dateTime,
                batchNo = a.batchNo,
                trayRule = a.trayRule,
                itemLayer = a.itemLayer
            };
            result.success = db.Insertable(ChunAnTrayInfo).ExecuteCommand() > 0;
        }

        /// <summary>
        /// 更新屏幕表数据
        /// </summary>
        /// <param name="a"></param>
        /// <param name="db"></param>
        private static void UpdateScreenTable(TrayInfo a, SqlSugar.SqlSugarClient db)
        #endregion
        {
            var screen = db.Queryable<ChunAnScreenData>().Where(it => it.DataTypeNo == "托盘数据" && it.TrayCode == a.trayCode).First();
            if (screen != null)
            {
                screen.TrayCode = a.sign;
                db.Updateable(screen).UpdateColumns(b => new { b.TrayCode }).ExecuteCommand();
            }
        }

        /// <summary>
        /// 人工分拣出库接口解绑托盘
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel UnbindingTrayCodeCA(UnbindingTrayCodeModel model)
        {
            var result = new SimpleResultModel { success = false, errCode = -1 };
            string msg = ""; int n = 0; string locCode = "";
            var db = new SqlHelper<object>().GetInstance();
            if (model.TrayInfo != null)
            {
                for (int i = 0; i < model.TrayInfo.Count(); i++)
                {
                    string cntrCode = model.TrayInfo[i];
                    var trayInfo = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == cntrCode).First();
                    if (trayInfo != null)
                    {
                        locCode = trayInfo.S_LOC_CODE.Trim();
                        if (!string.IsNullOrEmpty(locCode))
                        {
                            var locInfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locCode).First();
                            if (locInfo != null)
                            {
                                TaskHelper.YiKuUnLockRow(db, locInfo.N_ROW.Trim(), locInfo.S_AREA_CODE.Trim(), false, false, true);
                                var Srow = db.Queryable<RowLock>().Where(a => a.N_ROW == locInfo.N_ROW.Trim() && a.S_AREA_CODE == locInfo.S_AREA_CODE.Trim()).First();
                                if (Srow != null)
                                {
                                    Srow.S_LOCK_STATE = "其他锁";
                                    db.Updateable(Srow).UpdateColumns(a => new { a.S_LOCK_STATE }).ExecuteCommand();
                                }
                            }
                        }
                        result.success = true;
                        db.Deleteable<LocCntrRel>(a => a.S_CNTR_CODE == cntrCode).ExecuteCommand();
                        db.Deleteable<CntrItemRel>(a => a.S_CNTR_CODE == cntrCode).ExecuteCommand();
                        msg = msg + $"{n++}:当前托盘号：{model.TrayInfo[i]},解绑成功！";
                    }
                    else msg = msg + $"{n++}:当前托盘号：{model.TrayInfo[i]},不存在对应货位！";
                    if (!string.IsNullOrEmpty(locCode))
                    {
                        var locNum = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == locCode).ToList();
                        int num = 0;
                        var locInfo = db.Queryable<Location>().Where(a => a.S_LOC_CODE == locCode).First();
                        if (locInfo != null)
                        {
                            locInfo.N_CURRENT_NUM = GetLocTrayNum(locNum, num);
                            LogHelper.Info("UnbindingTrayCode Dispose：更新当前货位当前数量！" + $"货位编码：{locCode},数量：{locInfo.N_CURRENT_NUM}", "ThirdSystemLog");
                            db.Updateable(locInfo).UpdateColumns(a => new { a.N_CURRENT_NUM }).ExecuteCommand();
                            var locaHaveTray = db.Queryable<Location>().Where(a => a.N_ROW == locInfo.N_ROW.Trim() && a.N_CURRENT_NUM > 0).ToList();
                            if (locaHaveTray.Count == 0) TaskHelper.YiKuUnLockRow(db, locInfo.N_ROW.Trim(), locInfo.S_AREA_CODE.Trim(), true, false, true);
                            //else TaskController.Monitor.YiKuUnLockRow(db, locInfo.N_ROW.Trim(), locInfo.S_AREA_CODE.Trim(), false);
                        }
                    }
                }
            }
            else msg = $"人工分拣出库：富勒传输数据异常！传输为空值！";
            result.errMsg = msg;
            LogHelper.Info("UnbindingTrayCode Dispose：" + result.errMsg, "ThirdSystemLog");
            return result;
        }
        /// <summary>
        /// 人工分拣出库接口解绑托盘-梅坪项目(直接调用WMS接口传输数据)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResultModel UnbindingTrayCodeStand(UnbindingTrayCodeModel model)
        {
            var result = new SimpleResultModel { success = false, errCode = -1 };
            string msg = "";
            if (model.TrayInfo != null)
            {
                string res = JsonConvert.SerializeObject(new
                {
                    TrayInfo = model.TrayInfo
                });
                string req = httpHelper.WebPost(url + "UnbindingTrayCode", res);
                if (req.Contains("true")) result.success = true;
                LogHelper.Info($"UnbindingTrayCode WMSReq：{req}", "ThirdSystemLog");
            }
            else msg = $"人工分拣出库：富勒传输数据异常！传输为空值！";
            result.errMsg = msg;
            LogHelper.Info("UnbindingTrayCode Dispose：" + result.errMsg, "ThirdSystemLog");
            return result;
        }
        private static int GetLocTrayNum(List<LocCntrRel> locNum, int num)
        {
            int trayNum = locNum.Count();
            switch (trayNum)
            {
                case 0:
                    num = 0;
                    break;
                case 1:
                    num = 1;
                    break;
                case 2:
                    num = 1;
                    break;
                case 3:
                    num = 2;
                    break;
                case 4:
                    num = 2;
                    break;
            }

            return num;
        }
    }
}