using Newtonsoft.Json;
using System;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.DbModels.Task;
using WCS.BLL.Manager;
using WCS.BLL.Tool;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.InOutRecord;
using WCS.Model.ApiModel.MKYBackgroundThread;
using WCS.Model.ApiModel.OutStore;
using WCS.Model.WebSocketModel;
using static WCS.BLL.HardWare.WarningLight;

namespace WCS.BLL.HardWare
{
    /// <summary>
    /// 智能货架
    /// </summary>
    public class MXL4Shelf : IShelfBase
    {
        public MXL4Shelf(ShelfInfo shelfInfo)
        {
            ShelfTypeName = shelfInfo.ShelfTypeName;
            ShelfId = shelfInfo.Id;
            ShelfCode = shelfInfo.ShelfCode;
            RowCounts = shelfInfo.Rowcounts;
            ColumnCounts = shelfInfo.Columncounts;
            SetCurrentMode(TaskModeEnum.待机模式);
            ClientIp = shelfInfo.ClientIp;
            LightId = shelfInfo.LightId;
            WarningLight = new WarningLight() { LightId = shelfInfo.LightId };

            //初始化Module
            var task = Task.Run(() =>
             {
                 var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => t.ShelfId == ShelfId).ToList();
                 foreach (var module in modules)
                 {
                     MXL4Modules.Add(new MXL4ShelfModule()
                     {
                         ModuleId = module.Id,
                         ModuleCode = module.ModuleCode,
                         BoardId = module.BoardId,
                         IsEnable = module.IsEnable,
                         CurrentMode = TaskModeEnum.待机模式,

                         IsNeedRefresh = true,
                     });
                 }
                 ModulesStr = string.Join(";", MXL4Modules.Select(t => t.ModuleCode));

                 ModuleIds = MXL4Modules.Select(t => t.BoardId).ToList();
             });

            //一个货架存在一个线程去刷新数据
            Task.Run(async () =>
            {
                //等待模组加载完毕再开始发送数据进行刷新
                Task.WaitAll(task);

                while (true)
                {
                    //Logs.Write($"[后台刷新线程]开始刷新{ShelfCode}");
                    try
                    {
                        await Task.Delay(100);
                        //Logs.Write($"[后台刷新线程]开始刷新{ShelfCode}");
                        if (TcpCleint == null)
                        {
                            await Task.Delay(2000);
                            continue;
                        }

                        //Logs.Write($"[后台刷新线程]TcpCleint =null {ShelfCode}");
                        //未完成首次连接时 暂不发送
                        if (TcpCleint.IsFirstConnected == false)
                        {
                            await Task.Delay(2000);
                            continue;
                        }
                        // Logs.Write($"[test]{ShelfCode}3");
                        //查询属于本货架的任务
                        var currentShelfTasks = DbHelp.db.Queryable<CurrentTask>()
                                                         .Where(t => t.ShelfId == this.ShelfId)
                                                         .Where(t => (t.IsSended == false && t.IsSuspended == false) || t.IsCancel == true || (t.IsSended == true && t.IsSuspended == true))
                                                         .OrderBy(t => t.CreateTime)
                                                         .ToList();

                        //Logs.Write($"[后台刷新线程]属于本货架的任务{currentShelfTasks.Count}");
                        //获取因为任务需要刷新的module
                        var haveTaskModules = currentShelfTasks.Where(t => t.IsCancel == true || (t.IsSended == false && t.IsSuspended == false))
                                                               .Select(t => t.ModuleId)
                                                               .Distinct()
                                                               .ToList();
                        MXL4Modules.ForEach(t =>
                        {
                            if (haveTaskModules.Contains(t.ModuleId))
                            {
                                t.IsNeedRefresh = true;
                            }
                        });

                        // Logs.Write($"[test]{ShelfCode}4");
                        //查询是否有需要刷新的
                        var needRefreshModules = MXL4Modules.Where(t => t.IsNeedRefresh)
                                                            .ToList();
                        foreach (var module in needRefreshModules)
                        {
                            try
                            {
                                //查询当前是否有任务
                                var currentTasks = currentShelfTasks.Where(t => t.ModuleId == module.ModuleId)
                                                            .OrderBy(t => t.CreateTime)
                                                            .ToList();

                                //if (currentTasks == null || currentTasks.Count <= 0)
                                //{ 
                                //    continue;
                                //}

                                #region 取消任务的逻辑 
                                var cancelTasks = currentTasks.Where(t => t.IsCancel == true)
                                                                   .ToList();
                                if (cancelTasks != null && cancelTasks.Count > 0)
                                {
                                    Logs.Write($"[后台刷新线程]当前有任务需要取消！");
                                    //删除取消的这个任务
                                    DbHelp.db.Deleteable(cancelTasks).ExecuteCommand();
                                    currentShelfTasks.RemoveAll(t => t.IsCancel == true);

                                    //退出当前模式
                                    if (module.CurrentMode != TaskModeEnum.待机模式)
                                    {
                                        Logs.Write($"当前模组不是待机模式 退出对应模式");
                                        // 退出对应模式
                                        switch (module.CurrentMode)
                                        {
                                            case (TaskModeEnum.入库模式):
                                                module.GoOutInstoreMode(TcpCleint);
                                                break;
                                            case (TaskModeEnum.出库模式):
                                                module.GoOutOutstoreMode(TcpCleint);
                                                break;
                                            case (TaskModeEnum.盘点模式):
                                                module.GoOutStocktakingMode(TcpCleint);
                                                break;
                                            default:
                                                break;
                                        }
                                        await Task.Delay(10);
                                    }
                                    module.IsNeedRefresh = true;
                                    continue;
                                }
                                #endregion

                                #region 挂起任务退出的逻辑
                                var suspendedTasks = currentTasks.Where(t =>t.IsSended == true && t.IsSuspended == true)
                                                                .FirstOrDefault();
                                if (suspendedTasks != null)
                                {
                                    Logs.Write("【挂起】任务，先退出当前模式，再重新发送所有任务内容！");
                                    //先退出当前模式
                                    if (module.CurrentMode != TaskModeEnum.待机模式)
                                    {
                                        Logs.Write($"【挂起】模组当前模式为{module.CurrentMode},先退出模式");
                                        switch (module.CurrentMode)
                                        {
                                            case (TaskModeEnum.入库模式):
                                                module.GoOutInstoreMode(TcpCleint);
                                                break;
                                            case (TaskModeEnum.出库模式):
                                                module.GoOutOutstoreMode(TcpCleint);
                                                break;
                                            case (TaskModeEnum.盘点模式):
                                                module.GoOutStocktakingMode(TcpCleint);
                                                break;
                                            default:
                                                break;
                                        }
                                        await Task.Delay(10);

                                        //将此字段更新为未发送
                                        suspendedTasks.IsSended = false;
                                        DbHelp.db.Updateable(suspendedTasks).ExecuteCommand();
                                        Logs.Write($"【挂起】模组当前模式为{module.CurrentMode},先退出模式1");
                                    }
                                    
                                    module.IsNeedRefresh = true;
                                    continue;
                                }
                                #endregion


                                //入库、出库、盘点等任务
                                if (currentTasks != null && currentTasks.Count > 0)
                                {
                                    Logs.Write($"[test]{ShelfCode}5.2");
                                    var firstTask = currentTasks.First();
                                    var taskMode = currentTasks.First().TaskMode;
                                    #region 处理模组的模式 没有Continue
                                    if (module.CurrentMode == TaskModeEnum.待机模式)
                                    {
                                        //进入对应模式
                                        switch (taskMode)
                                        {
                                            case (TaskModeEnum.入库模式):
                                                module.GoInInstoreMode(TcpCleint, firstTask.ButtonColor);
                                                break;
                                            case (TaskModeEnum.出库模式):
                                                module.GoInOutstoreMode(TcpCleint, firstTask.ButtonColor);
                                                break;
                                            case (TaskModeEnum.盘点模式):
                                                module.GoInStocktakingMode(TcpCleint, firstTask.ButtonColor);
                                                break;
                                            default:
                                                break;
                                        }
                                        //等待10ms这边将状态成功更新了来
                                        await Task.Delay(10);
                                    }
                                    else
                                    {
                                        taskMode = module.CurrentMode;
                                    }
                                    #endregion

                                    //只显示当前模式的任务
                                    currentTasks = currentTasks.Where(t => t.TaskMode == taskMode).ToList();
                                    //这个分支应该很少跑到 有刷新必然有新任务
                                    if (currentTasks == null || currentTasks.Count == 0)
                                    {
                                        Logs.Write($"【后台发送线程】{module.ModuleCode}当前模式{module.CurrentMode},需要刷新！但是没有对应的新任务！");
                                        var tasks = DbHelp.db.Queryable<CurrentTask>()
                                                                    .Where(t => t.ModuleId == module.ModuleId)
                                                                    .Where(t => t.IsSended == true)
                                                                    .Where(t => t.TaskMode == taskMode)
                                                                    .OrderBy(t => t.CreateTime)
                                                                    .ToList();
                                        if (tasks != null && tasks.Count > 0)
                                        {
                                            Logs.Write($"【后台发送线程】{module.ModuleCode}当前模式{module.CurrentMode},需要刷新！但是没有对应的新任务！有已发送的任务未完成故不处理！");
                                            module.IsNeedRefresh = false;
                                            continue;
                                        }
                                        //退出对应模式到待机模式！ 后续持续刷新数据!
                                        else
                                        {
                                            Logs.Write($"【后台发送线程】{module.ModuleCode}当前模式{module.CurrentMode},需要刷新！但是没有对应的新任务！没有已发送未完成的任务！退出当前模式！");
                                            // 退出对应模式
                                            switch (taskMode)
                                            {
                                                case (TaskModeEnum.入库模式):
                                                    module.GoOutInstoreMode(TcpCleint);
                                                    break;
                                                case (TaskModeEnum.出库模式):
                                                    module.GoOutOutstoreMode(TcpCleint);
                                                    break;
                                                case (TaskModeEnum.盘点模式):
                                                    module.GoOutStocktakingMode(TcpCleint);
                                                    break;
                                                default:
                                                    break;
                                            }
                                            continue;
                                        }
                                    }
                                    //按照任务顺序给其发送数据
                                    foreach (var currentTask in currentTasks)
                                    {
                                        module.SendTaskId(currentTask.TaskID, TcpCleint);
                                        module.SendMatCode(currentTask.MatCode, TcpCleint);
                                        module.SendMatName(currentTask.MatName, TcpCleint);
                                        module.SendMatSpec(currentTask.MatSpec, TcpCleint);
                                        module.SendMatBatch(currentTask.MatBatch, TcpCleint);
                                        module.SendMatQty(currentTask.Qty, TcpCleint);

                                        currentTask.IsSended = true;
                                        DbHelp.db.Updateable(currentTask).ExecuteCommand();
                                    }
                                    //发送完毕后就不刷新了
                                    module.IsNeedRefresh = false;
                                    continue;
                                }
                                //不存在入库、出库、盘点等任务 应该变成待机
                                else
                                {
                                    //退出对应模式到待机模式！ 退出后续会再走这个else分支刷新数据!
                                    if (module.CurrentMode != TaskModeEnum.待机模式)
                                    {
                                        Logs.Write($"[test]{ShelfCode}5.4");
                                        // 退出对应模式
                                        switch (module.CurrentMode)
                                        {
                                            case (TaskModeEnum.入库模式):
                                                module.GoOutInstoreMode(TcpCleint);
                                                break;
                                            case (TaskModeEnum.出库模式):
                                                module.GoOutOutstoreMode(TcpCleint);
                                                break;
                                            case (TaskModeEnum.盘点模式):
                                                module.GoOutStocktakingMode(TcpCleint);
                                                break;
                                            default:
                                                break;
                                        }
                                        continue;
                                    }
                                    else
                                    {
                                        //模组是待机模式后 如果还有任务 那么显示对应的任务
                                        var otherTasks = DbHelp.db.Queryable<CurrentTask>()
                                                                  .Where(t => t.ModuleId == module.ModuleId && t.IsSended == true)
                                                                  .ToList();
                                        if (otherTasks != null && otherTasks.Count > 0)
                                        {
                                            Logs.Write($"[后台刷新线程]当前有任务需要重新发送！");
                                            otherTasks.ForEach(t => { t.IsSended = false; });
                                            DbHelp.db.Updateable(otherTasks).ExecuteCommand();

                                            Thread.Sleep(1000);
                                            Logs.Write($"[后台刷新线程]当前有任务{otherTasks.Count}个需要重新发送！");
                                            continue;
                                        }
                                        else
                                        {
                                            #region 请求接口 
                                            //向上层系统获取数据
                                            var stockQueryUrl = @"http://10.41.235.10:8989/ztwcs/stockQuery";
                                            var dataBody = new StockQueryRequest();
                                            dataBody.storeCodes.Add(module.ModuleCode);
                                            Logs.Write("111", LogsType.StartBoot);
                                            var result = ApiHelp.GetDataFromHttp<StockQueryResponse>(stockQueryUrl, dataBody, "POST", true);
                                            if (result == null)
                                            {
                                                //Logs.Write("2222", LogsType.StartBoot);
                                                continue;
                                            }
                                            //获取成功 有数据 绑定对应数据
                                            if (result.code == 200)
                                            {

                                                var jsonString = result.data;
                                              
                                                if (!string.IsNullOrEmpty(jsonString))
                                                {
                                                    Logs.Write($"44", LogsType.StartBoot);
                                                    //20250514 接口返回多一个\\"\ 造成无法解析
                                                    jsonString.Replace("\\\\\"\\", string.Empty);
                                                    // 去除所有双引号前面的反斜杠
                                                    jsonString = Regex.Replace(jsonString, @"\\(.)", "$1"); ;
                                                    List<StockQueryResponseDataItem>? data = null;
                                                    try
                                                    {
                                                        data = JsonConvert.DeserializeObject<List<StockQueryResponseDataItem>>(jsonString);
                                                    }
                                                    catch (Exception ex)
                                                    {
                                                        Logs.Write($"【库存信息反序列化失败】返回的json字符串为:\r\n{jsonString},无法成功反序列化");
                                                        module.IsNeedRefresh = false;
                                                        continue;
                                                    }
                                                    
                                                    if (data != null && data.Count > 0)
                                                    {
                                                        //硬件只能显示7个 只保留前7个
                                                        if (data.Count > 7)
                                                        {
                                                            data = data.Take(7).ToList();
                                                        }
                                                        int taskid = 1;
                                                        try
                                                        {
                                                            foreach (var item in data)
                                                            {
                                                                module.SendTaskId(taskid++, TcpCleint);
                                                                module.SendMatCode(item.material_code, TcpCleint);
                                                                module.SendMatName(item.material_name, TcpCleint);
                                                                module.SendMatSpec(item.material_spec, TcpCleint);
                                                                module.SendMatBatch(item.batch_no, TcpCleint);
                                                                module.SendMatQty((int)item.qty, TcpCleint);
                                                            }
                                                        }
                                                        catch (Exception)
                                                        {
                                                            Logs.Write($"模组[{module.ModuleCode}],未发送成功！！！", LogsType.StartBoot);
                                                            module.Reset(TcpCleint);
                                                        }
                                                        finally
                                                        {
                                                            module.IsNeedRefresh = false;
                                                        }
                                                        continue;
                                                    }
                                                    //库存里面无数据
                                                    else
                                                    {
                                                        Logs.Write($"6666", LogsType.StartBoot);
                                                        //获取成功 无数据
                                                        try
                                                        {
                                                            module.StandbyNoInfoDisplay(TcpCleint);
                                                        }
                                                        catch 
                                                        {
                                                            Logs.Write($"模组[{module.ModuleCode}],未发送成功！！！", LogsType.StartBoot);
                                                        }
                                                        finally
                                                        {
                                                            module.IsNeedRefresh = false;//未获取到库存数据 回没有库位显示信息给硬件
                                                        }
                                                        continue;
                                                    }
                                                }
                                                else
                                                {

                                                    Logs.Write($"66666", LogsType.StartBoot);
                                                    //获取成功 无数据
                                                    module.StandbyNoInfoDisplay(TcpCleint);
                                                    module.IsNeedRefresh = false;//未获取到库存数据 回没有库位显示信息给硬件
                                                    continue;
                                                }

                                            }
                                            else
                                            {
                                                Logs.Write($"code!=200", LogsType.StartBoot);
                                                continue;
                                            }
                                            #endregion
                                        }
                                    }
                                }
                            }
                            catch (Exception ex)
                            {

                                Logs.Write($"【后台发送线程】遇到异常{ex.Message},{ex.StackTrace}");
                            }

                        }

                        //刷新报警灯
                        if (needRefreshModules != null && needRefreshModules.Count > 0)
                        {
                            var isShelfHaveTask = DbHelp.db.Queryable<CurrentTask>()
                                                         .Where(t => t.ShelfId == this.ShelfId)
                                                         .Where(t => t.IsSended == true)
                                                         .Any();
                            if (isShelfHaveTask)
                            {
                                WarningLight.GreenLight(TcpCleint);
                            }
                            else
                            {
                                WarningLight.CloseLight(TcpCleint);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Logs.Write($"【后台发送线程】遇到异常{ex.Message},{ex.StackTrace}");
                    }
                    await Task.Delay(1000);
                }
            });
        }

        public string ShelfTypeName { get; set; }
        public int ShelfId { get; set; }
        public string ShelfCode { get; set; }
        public int RowCounts { get; set; }
        public int ColumnCounts { get; set; }
        public TaskModeEnum CurrentMode { get; set; }
        public DateTime SetCurrentModeTime { get; set; }
        public string ModulesStr { get; set; }//当前货架所有模组的Str
        public string GroupName { get; set; }
        public List<SmartShelfModule> Modules { get; set; } = new List<SmartShelfModule>();
        public List<MXL4ShelfModule> MXL4Modules { get; set; } = new List<MXL4ShelfModule>();
        public TCPClient TcpCleint { get { return TCPClientManager.GetTCPClientByIPHost(ClientIp); } }
        public int LightId { get; set; }
        public LightColorEnum LightColor { get; set; }
        public bool IsWarning { get; set; } = false;
        public WarningLight WarningLight { get; set; }
        public void ClearWarning()
        {
            if (this.CurrentMode == TaskModeEnum.入库模式)
            {
                WarningLight.BlueLight(TcpCleint);
            }
            else if (this.CurrentMode == TaskModeEnum.出库模式)
            {
                WarningLight.GreenLight(TcpCleint);
            }
            else if (this.CurrentMode == TaskModeEnum.盘点模式)
            {
                WarningLight.GreenLight(TcpCleint);
            }
            else
            {
                WarningLight.CloseLight(TcpCleint);
            }
        }
        /// <summary>
        /// 自检异常、未响应对应模式的异常
        /// </summary>
        public List<string> ExceptionMessages { get; set; } = new List<string>();
        /// <summary>
        /// 过程中异常 入库过程中异常/出库过程中异常
        /// </summary>
        public List<ProcessingExceptionType> ProcessingExceptions { get; set; } = new List<ProcessingExceptionType>();
        public string? CurrentCom { get; set; } = string.Empty;

        public MatInfoResponse InStoreData { get; set; }

        public List<string> CurrentOutStoreMatSNs { get; set; } = new List<string>();

        public OutOrder CurrentOutOrder { get; set; }

        public string OrderNumber { get; set; }

        public StockTakingOrder CurrentStockTakingOrder { get; set; }

        public List<int> ModuleIds { get; set; }
        public string ClientIp { get; set; }

        //websocket通知的前端的IP地址
        public string WebSocketIpAddress { get; set; } = "127.0.0.2";

        public string OutOperateUser { get; set; } = string.Empty;

        #region 协议处理
        public void Reset()
        {
            MXL4Modules.ForEach(t => t.Reset(TcpCleint));
        }

        #region 弃用
        void IShelfBase.Warning()
        {
        }
        public void ShelfCheck()
        {
        }
        public void GoInInstore(string? IPAddress)
        {

        }
        public void GoOutInstore()
        {

        }
        public void GoInOutstore(List<OutOrderMatDetail> MatDetails, OutOrder outOrder, string OperateUser)
        {
        }
        public void GoOutOutstore()
        {
        }
        public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder stockTakingOrder)
        {
        }
        /// <summary>
        /// 确认盘点 Pda进行触发
        /// </summary>
        public bool ConfirmStocktakingSingle(int BoardId, int LightNumber)
        {
            return false;
        }
        public void GoOutStocktaking()
        {
        }
        #endregion

        public void SetCurrentMode(TaskModeEnum mode)
        {
            this.CurrentMode = mode;
            this.SetCurrentModeTime = DateTime.Now;
            Task.Run(() =>
            {
                var shelf = DbHelp.db.Queryable<ShelfInfo>().Where(t => t.Id == ShelfId).First();
                if (shelf != null)
                {
                    shelf.CurrentMode = mode;
                    shelf.SetCurrentModeTime = SetCurrentModeTime;
                    DbHelp.db.Updateable(shelf).ExecuteCommand();
                }
            });
        }
        #endregion

        #region 报警灯协议返回处理
        public void WarningLightProcess(byte[] data, int boardId)
        {
            if (data[TcpCleint.PreFixLength + 2] == 0x20 && data[TcpCleint.PreFixLength + 3] == 0x01)
            {
                //常亮或关闭 0x00常亮 0x01关闭
                if (data[TcpCleint.PreFixLength + 5] == 0x00)
                {
                    LightColor = LightColorEnum.关闭;
                    Logs.Write($"货架[{ShelfCode}]，灯状态更新为：{LightColor}");
                }
                else if (data[TcpCleint.PreFixLength + 5] == 0x01)
                {
                    switch (data[7])
                    {
                        case 0x01:
                            LightColor = LightColorEnum.红色;
                            break;
                        case 0x02:
                            LightColor = LightColorEnum.绿色;
                            break;
                        case 0x03:
                            LightColor = LightColorEnum.蓝色;
                            break;
                        default:
                            break;
                    }
                    Logs.Write($"货架[{ShelfCode}]，灯状态更新为：{LightColor}");
                }
            }
        }
        #endregion

        #region 液晶标签协议返回处理
        public void ProtocolProcess(byte[] data, int boardId)
        {
            //协议处理 判断功能位
            switch (data[TcpCleint.PreFixLength + 2])
            {
                case 0xA4://标签回到待机模式 请求获取显示数据的信号
                    if (data[TcpCleint.PreFixLength + 3] == 0x02)
                        GoBackStandbyModeReturnProcess(data, boardId);
                    else if (data[TcpCleint.PreFixLength + 3] == 0x05)
                        SelectSuspendTaskProcess(data, boardId);
                    break;
                case 0xA1:
                    //标签返回入库成功信号
                    if (data[TcpCleint.PreFixLength + 3] == 0x05)
                        InStoreSuccessProcess(data, boardId);
                    //进入入库模式成功
                    else if (data[TcpCleint.PreFixLength + 3] == 0x01)
                        GoInInStoreReturnProcess(data, boardId);
                    //退出入库模式
                    else if (data[TcpCleint.PreFixLength + 3] == 0x03)
                        GoBackStandbyModeReturnProcess(data, boardId);
                    //挂载此出库任务
                    else if (data[TcpCleint.PreFixLength + 3] == 0x04)
                        SuspendTaskProcess(data, boardId);
                    break;
                case 0xA2:
                    //标签返回出库成功信号
                    if (data[TcpCleint.PreFixLength + 3] == 0x04)
                        OutStoreSuccessProcess(data, boardId);
                    //进入出库模式成功
                    else if (data[TcpCleint.PreFixLength + 3] == 0x01)
                        GoInOutStoreReturnProcess(data, boardId);
                    //退出出库模式
                    else if (data[TcpCleint.PreFixLength + 3] == 0x03)
                        GoBackStandbyModeReturnProcess(data, boardId);
                    break;
                case 0xA3:
                    //标签返回盘点成功信号
                    if (data[TcpCleint.PreFixLength + 3] == 0x03)
                        StocktakingSuccessProcess(data, boardId);
                    //进入盘点模式
                    else if (data[TcpCleint.PreFixLength + 3] == 0x01)
                        GoInStocktakingReturnProcess(data, boardId);
                    //退出盘点模式
                    else if (data[TcpCleint.PreFixLength + 3] == 0x02)
                        GoBackStandbyModeReturnProcess(data, boardId);
                    break;
                default:
                    ;
                    break;
            }
        }

        /// <summary>
        /// 标签回到待机模式
        /// </summary>
        /// <param name="data"></param>
        public void GoBackStandbyModeReturnProcess(byte[] data, int boardId)
        {
            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                module.SetCurrentMode(TaskModeEnum.待机模式);
                module.IsNeedRefresh = true;
            }
            else
            {
                Logs.Write($"【回到待机模式】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
            //TO DO 所有退出后货架才待机
            SetCurrentMode(TaskModeEnum.待机模式);
        }


        /// <summary>
        /// 挂起任务
        /// </summary>
        /// <param name="data"></param>
        public async void SuspendTaskProcess(byte[] data, int boardId)
        {
            //获取当前挂载任务
            var taskSuspended = DbHelp.db.Queryable<CurrentTask>()
                                .Where(t => t.IsSuspended)
                                .First();
            if (taskSuspended != null)
            {
                Logs.Write($"【挂起任务】已有挂起任务 货架【{taskSuspended.ShelfCode}】模组{taskSuspended.ModuleCode},任务ID{taskSuspended.TaskID}，在数据库中！无法挂起第二个");
                return;
            }
            else
            {
                Logs.Write($"【挂起任务】当前没有挂起任务，可以进行任务挂起");
            }

            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                Logs.Write($"【挂起任务】获取到当前进行挂起任务的模组{module.ModuleCode},货架{ShelfCode}");
                //获取对应任务
                var taskId = Convert.ToInt32(data[TcpCleint.PreFixLength + 4]);//任务ID
                Logs.Write($"【挂起任务】获取到当前进行挂起任务的模组{module.ModuleCode},货架{ShelfCode}，任务ID{taskId}");
                var task = DbHelp.db.Queryable<CurrentTask>()
                                    .Where(t => t.TaskID == taskId && t.ModuleId == module.ModuleId)
                                    .First();
                if (task != null)
                {
                    Logs.Write($"【挂起任务】task != null");
                    task.IsSuspended = true;
                    DbHelp.db.Updateable(task).ExecuteCommand();

                    await Task.Delay(15);
                    module.IsNeedRefresh = true;
                    Logs.Write($"【挂起任务】模组{module.ModuleCode}已更新为需要刷新！");
                }
                else
                {
                    Logs.Write($"【挂起任务】货架【{ShelfCode}】模组{module.ModuleCode},任务ID{taskId}，在数据库中未找到对应任务！");
                }

            }
            else
            {
                Logs.Write($"【挂起任务】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
        }

        /// <summary>
        /// 选择挂起任务 挂载至另一个模组
        /// </summary>
        /// <param name="data"></param>
        public void SelectSuspendTaskProcess(byte[] data, int boardId)
        {
            Logs.Write("[选择挂起任务]接收到相关指令！");
            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                Logs.Write($"[选择挂起任务]接收到相关指令！货架{ShelfCode},模组{module.ModuleCode}");
                //获取当前挂载任务
                var task = DbHelp.db.Queryable<CurrentTask>()
                                    .Where(t => t.IsSuspended)
                                    .First();
                if (task != null)
                {
                    task.IsSuspended = false;
                    task.ShelfId = ShelfId;
                    task.ModuleId = module.ModuleId;
                    task.ModuleCode = module.ModuleCode;
                    task.IsSuspended = false;
                    task.IsSended = false;

                    DbHelp.db.Updateable(task).ExecuteCommand();

                    Thread.Sleep(30);
                    module.IsNeedRefresh = true;
                    Logs.Write($"[选择挂起任务]已获取到相关任务，任务已更新为当前模组");
                }
                else
                {
                    Logs.Write($"【选择挂起任务】货架【{ShelfCode}】模组{module.ModuleCode},在数据库中未找到当前挂起的任务！");
                }
            }
            else
            {
                Logs.Write($"【选择挂起任务】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
        }

        /// <summary>
        /// 标签返回进入入库模式信号
        /// </summary>
        /// <param name="data"></param>
        public void GoInInStoreReturnProcess(byte[] data, int boardId)
        {
            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                module.SetCurrentMode(TaskModeEnum.入库模式);
            }
            else
            {
                Logs.Write($"【进入入库模式成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
        }
        /// <summary>
        /// 标签返回进入出库模式信号
        /// </summary>
        /// <param name="data"></param>
        public void GoInOutStoreReturnProcess(byte[] data, int boardId)
        {
            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                module.SetCurrentMode(TaskModeEnum.出库模式);
            }
            else
            {
                Logs.Write($"【进入出库模式成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
        }

        /// <summary>
        /// 标签返回进入盘点模式信号
        /// </summary>
        /// <param name="data"></param>
        public void GoInStocktakingReturnProcess(byte[] data, int boardId)
        {
            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                module.SetCurrentMode(TaskModeEnum.盘点模式);
            }
            else
            {
                Logs.Write($"【进入盘点模式成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
        }


        /// <summary>
        /// 标签返回入库成功信号
        /// </summary>
        /// <param name="data"></param>
        public void InStoreSuccessProcess(byte[] data, int boardId)
        {
            var taskId = Convert.ToInt32(data[TcpCleint.PreFixLength + 4]);
            var finishQty = (data[TcpCleint.PreFixLength + 5] << 8) + data[TcpCleint.PreFixLength + 6];

            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                //获取对应的任务
                var task = DbHelp.db.Queryable<CurrentTask>()
                                           .Where(t => t.ModuleCode == module.ModuleCode)
                                           .Where(t => t.TaskID == taskId)
                                           .First();
                if (task != null)
                {
                    var finishedTask = new FinishedTask()
                    {
                        ShelfId = task.ShelfId,
                        ShelfCode = task.ShelfCode,
                        ModuleId = task.ModuleId,
                        ModuleCode = task.ModuleCode,
                        StoreId = task.StoreId,
                        StoreCode = task.StoreCode,
                        TaskID = task.TaskID,
                        Guid = task.Guid,
                        ItemNo = task.ItemNo,
                        TaskMode = task.TaskMode,
                        OrderNumber = task.OrderNumber,
                        ButtonColor = task.ButtonColor,
                        MatCode = task.MatCode,
                        MatName = task.MatName,
                        MatSpec = task.MatSpec,
                        MatBatch = task.MatBatch,
                        MatSN = task.MatSN,
                        CreateTime = task.CreateTime,
                        Qty = task.Qty,
                        FinishQty = finishQty,
                        FinishTime = DateTime.Now,
                    };
                    DbHelp.db.Insertable(finishedTask).ExecuteCommand();
                    DbHelp.db.Deleteable(task).ExecuteCommand();
                }
                else
                {
                    Logs.Write($"【入库成功】货架【{ShelfCode}】通过模组{module.ModuleCode}({boardId}),通过任务id{taskId}未找到对应任务！");
                }
            }
            else
            {
                Logs.Write($"【入库成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
        }

        /// <summary>
        /// 标签返回出库成功信号
        /// </summary>
        /// <param name="data"></param>
        public void OutStoreSuccessProcess(byte[] data, int boardId)
        {
            var taskId = Convert.ToInt32(data[TcpCleint.PreFixLength + 4]);
            var finishQty = (data[TcpCleint.PreFixLength + 5] << 8) + data[TcpCleint.PreFixLength + 6];

            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                //获取对应的任务
                var task = DbHelp.db.Queryable<CurrentTask>()
                                           .Where(t => t.ModuleCode == module.ModuleCode)
                                           .Where(t => t.TaskID == taskId)
                                           .First();
                if (task != null)
                {
                    var finishedTask = new FinishedTask()
                    {
                        ShelfId = task.ShelfId,
                        ShelfCode = task.ShelfCode,
                        ModuleId = task.ModuleId,
                        ModuleCode = task.ModuleCode,
                        StoreId = task.StoreId,
                        StoreCode = task.StoreCode,
                        TaskID = task.TaskID,
                        Guid = task.Guid,
                        ItemNo = task.ItemNo,
                        TaskMode = task.TaskMode,
                        OrderNumber = task.OrderNumber,
                        ButtonColor = task.ButtonColor,
                        MatCode = task.MatCode,
                        MatName = task.MatName,
                        MatSpec = task.MatSpec,
                        MatBatch = task.MatBatch,
                        MatSN = task.MatSN,
                        CreateTime = task.CreateTime,
                        Qty = task.Qty,
                        FinishQty = finishQty,
                        FinishTime = DateTime.Now,
                    };
                    DbHelp.db.Insertable(finishedTask).ExecuteCommand();
                    DbHelp.db.Deleteable(task).ExecuteCommand();
                }
                else
                {
                    Logs.Write($"【出库成功】货架【{ShelfCode}】通过模组{module.ModuleCode}({boardId}),通过任务id{taskId}未找到对应任务！");
                }
            }
            else
            {
                Logs.Write($"【出库成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
        }

        /// <summary>
        /// 标签返回盘点成功信号
        /// </summary>
        /// <param name="data"></param>
        public void StocktakingSuccessProcess(byte[] data, int boardId)
        {
            var taskId = Convert.ToInt32(data[TcpCleint.PreFixLength + 4]);
            var finishQty = (data[TcpCleint.PreFixLength + 5] << 8) + data[TcpCleint.PreFixLength + 6];

            //获取对应的模组
            var module = MXL4Modules.Where(t => t.BoardId == boardId)
                                    .FirstOrDefault();
            if (module != null)
            {
                //获取对应的任务
                var task = DbHelp.db.Queryable<CurrentTask>()
                                           .Where(t => t.ModuleCode == module.ModuleCode)
                                           .Where(t => t.TaskID == taskId)
                                           .First();
                if (task != null)
                {
                    var finishedTask = new FinishedTask()
                    {
                        ShelfId = task.ShelfId,
                        ShelfCode = task.ShelfCode,
                        ModuleId = task.ModuleId,
                        ModuleCode = task.ModuleCode,
                        StoreId = task.StoreId,
                        StoreCode = task.StoreCode,
                        TaskID = task.TaskID,
                        Guid = task.Guid,
                        ItemNo = task.ItemNo,
                        TaskMode = task.TaskMode,
                        OrderNumber = task.OrderNumber,
                        ButtonColor = task.ButtonColor,
                        MatCode = task.MatCode,
                        MatName = task.MatName,
                        MatSpec = task.MatSpec,
                        MatBatch = task.MatBatch,
                        MatSN = task.MatSN,
                        CreateTime = task.CreateTime,
                        Qty = task.Qty,
                        FinishQty = finishQty,
                        FinishTime = DateTime.Now,
                    };
                    DbHelp.db.Insertable(finishedTask).ExecuteCommand();
                    DbHelp.db.Deleteable(task).ExecuteCommand();
                }
                else
                {
                    Logs.Write($"【盘点成功】货架【{ShelfCode}】通过模组{module.ModuleCode}({boardId}),通过任务id{taskId}未找到对应任务！");
                }
            }
            else
            {
                Logs.Write($"【盘点成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
            }
        }
        #endregion
    }
}