using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using TouchSocket.Core;
using TouchSocket.Sockets;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.DAL;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using static System.Formats.Asn1.AsnWriter;

namespace WCS.BLL.HardWare
{
    /// <summary>
    /// 智能货架
    /// </summary>
    public class SmartShelf : IShelfBase
    {
        public SmartShelf(ShelfInfo shelfInfo)
        {
            ShelfId = shelfInfo.Id;
            ShelfCode = shelfInfo.ShelfCode;
            RowCounts = shelfInfo.Rowcounts;
            ColumnCounts = shelfInfo.Columncounts;
            CurentMode = shelfInfo.CurrentMode;
            ClientIp = shelfInfo.ClientIp;
            LightId = shelfInfo.LightId;
            WarningLight = new WarningLight() { LightId = shelfInfo.LightId };

            //初始化Module
            Task.Run(() =>
             {
                 var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => t.ShelfId == ShelfId).ToList();
                 foreach (var module in modules)
                 {
                     Modules.Add(new SmartShelfModule()
                     {
                         ModuleId = module.Id,
                         ModuleCode = module.ModuleCode,
                         BoardId = module.BoardId,
                         IsEnable = module.IsEnable,
                         CurrentMode = module.CurentMode
                     });
                 }
                 ModulesStr = string.Join(";", Modules.Select(t => t.ModuleCode));

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

            ////初始化TCPCleint
            //TcpCleint = new TCPClient("192.168.0.11:20002", "192.168.0.154:20003");
            //TcpCleint.tcpClient.Received += (client, e) =>
            //{
            //    var data = e.ByteBlock.Buffer.Take((int)e.ByteBlock.Length).ToArray();
            //    e.ByteBlock.Clear();
            //    var len = data.Length;
            //    for (int index = 0; index < data.Length - TcpCleint.PreFixLength; index++)
            //    {
            //        //协议拆包 通过前缀校验是否为完整数据包
            //        var prefixInData = data.Skip(index).Take(TcpCleint.PreFixLength);
            //        var isEqual = prefixInData.SequenceEqual(TcpCleint.Prefix);
            //        if (isEqual)
            //        {
            //            var dataTemp = data.Skip(index).Take(TcpCleint.PreFixLength + TcpCleint.DataLength).ToArray();
            //            if (dataTemp.Length < TcpCleint.PreFixLength + TcpCleint.DataLength)//拆包后不满足一条指令的长度
            //            {
            //                continue;
            //            }
            //            index += (TcpCleint.PreFixLength + TcpCleint.DataLength - 1);//每次循环index会+1 所以这里-1
            //            //获取板子ID
            //            var boardIds = (data[TcpCleint.PreFixLength + 0] << 8) + data[TcpCleint.PreFixLength + 1];
            //            var lightNumber = Convert.ToInt32(data[TcpCleint.PreFixLength + 3]);

            //            //协议处理 判断功能位
            //            switch (dataTemp[TcpCleint.PreFixLength + 2])
            //            {
            //                case 0x01://进入入库模式信号
            //                    GoInInstoreProcess(dataTemp, boardIds, lightNumber);
            //                    break;
            //                case 0x03://正常入库信号
            //                    InStoreReturnProcess(dataTemp);
            //                    break;
            //                default:
            //                    ;
            //                    break;
            //            }
            //        }
            //    }
            //    return EasyTask.CompletedTask;
            //};
            //TcpCleint.Connect();
        }

        public int ShelfId { get; set; }
        public string ShelfCode { get; set; }
        public int RowCounts { get; set; }
        public int ColumnCounts { get; set; }
        public Mode CurentMode { get; set; }
        public string ModulesStr { get; set; }//当前货架所有模组的Str
        public string GroupName { get; set; }
        public List<SmartShelfModule> Modules { get; set; } = new List<SmartShelfModule>();
        public TCPClient TcpCleint { get { return TCPClientManager.GetTCPClientByIPHost(ClientIp); } }

        public int LightId { get; set; }
        public WarningLight WarningLight { get; set; }
        /// <summary>
        /// 自检异常、未响应对应模式的异常
        /// </summary>
        public List<string> ExceptionMessages { get; set; } = new List<string>();
        /// <summary>
        /// 过程中异常 入库过程中异常/出库过程中异常
        /// </summary>
        public List<ProcessingExceptionType> ProcessingExceptions { get; set; } = new List<ProcessingExceptionType>();
        public string? InstoreIpAddress { 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 List<int> ModuleIds { get; set; }
        public string ClientIp { get; set; }

        #region 协议处理
        public void GoInInstore(string? IPAddress)
        {
            try
            {
                if (this.CurentMode == Mode.入库模式)
                {
                    InstoreIpAddress = IPAddress;
                    return;
                }
                //判断当前模式是否为待机模式
                else if (this.CurentMode != Mode.待机模式)
                {
                    return;
                }
                else
                {
                    this.CurentMode = Mode.入库模式;
                }
                //清空错误
                ExceptionMessages.Clear();
                ProcessingExceptions.Clear();
                //货架所有模组发送指令进入入库模式
                foreach (var module in Modules.Where(t => t.IsEnable).ToList())
                {
                    module.GoInInstoreMode(TcpCleint);
                }
                //延时获取异常
                var timeOut = 3000;
                var timeSpan = TimeSpan.FromMilliseconds(0);
                var beginTime = DateTime.Now;
                while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
                {
                    timeSpan = DateTime.Now - beginTime;

                    //所有板子成功进入入库模式 表示进入入库模式成功，跳出循环
                    var isExistsNotInstore = Modules.Where(t => t.CurrentMode != Mode.入库模式)
                                                    .Where(t => t.IsEnable)
                                                    .Any();
                    if (!isExistsNotInstore)
                    {
                        break;
                    }

                    //接收到第一个异常就不继续循环了
                    if (ExceptionMessages.Count() > 0)
                    {
                        var deficientTime = timeOut - (int)timeSpan.TotalMilliseconds;
                        if (deficientTime > 0)
                            Thread.Sleep(deficientTime);
                        //出现异常的未进入入库模式，有红灯进行指引
                        this.CurentMode = Mode.待机模式;
                        break;
                    }

                    //循环延时处理
                    Thread.Sleep(50);
                }

                //循环结束后判断当前板子状态
                var notInstoreList = Modules.Where(t => t.CurrentMode != Mode.入库模式)
                                                .Where(t => t.IsEnable).ToList();

                if (notInstoreList.Count > 0)
                {
                    CurentMode = Mode.待机模式;
                    foreach (var item in notInstoreList)
                    {
                        ExceptionMessages.Add($"模组{item.ModuleCode}未进入入库模式！");
                    }
                }

                //警示灯亮起
                WarningLight.BlueLight(TcpCleint);
                //绑定当前进入入库PDA/WCS前端的IP
                InstoreIpAddress = IPAddress;
                //返回成功
                return;
            }
            catch (Exception ex)
            {
                GoOutInstore();
                throw ex;
            }
        }

        public void GoOutInstore()
        {
            //当前货架是否为入库模式
            if (CurentMode != Mode.入库模式)
            {
                return;
            }
            else
            {
                this.CurentMode = Mode.待机模式;
            }

            //清空错误
            ExceptionMessages.Clear();
            //货架所有模组发送指令退出入库模式
            foreach (var module in Modules.Where(t => t.IsEnable)
                                          .ToList())
            {
                if (module.CurrentMode == Mode.入库模式)
                    module.GoOutInstoreMode(TcpCleint);
            }

            var timeOut = 3000;
            var timeSpan = TimeSpan.FromMilliseconds(0);
            var beginTime = DateTime.Now;
            while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
            {
                timeSpan = DateTime.Now - beginTime;
                //所有板子是否成功退出入库模式
                var isExistsInstore = Modules.Where(t => t.CurrentMode != Mode.待机模式)
                                             .Where(t => t.IsEnable)
                                             .Any();
                if (!isExistsInstore)
                {
                    break;
                }
                //循环延时处理
                Thread.Sleep(50);
            }

            //循环结束后判断当前板子状态
            var list = Modules.Where(t => t.CurrentMode != Mode.待机模式)
                                        .Where(t => t.IsEnable)
                                        .ToList();
            if (list.Count > 0)
            {
                CurentMode = Mode.待机模式;
                foreach (var item in list)
                {
                    ExceptionMessages.Add($"模组{item.ModuleCode}未成功退出入库模式！");
                }
            }
            //报警灯熄灭
            WarningLight.CloseLight(TcpCleint);
        }

        public void GoInOutstore(List<OutOrderMatDetail> MatDetails, OutOrder outOrder)
        {
            //第一步：设置货架当前模式
            if (CurentMode != Mode.待机模式)
            {
                Modules.ForEach(t => { t.Reset(TcpCleint); });
            }
            CurentMode = Mode.出库模式;

            //第二步：货架添加需要出的SN 出库的领料单号
            //移除货架所有现有待出库的MatSN
            CurrentOutStoreMatSNs.Clear();
            ////添加属于当前货架的物料
            CurrentOutStoreMatSNs.AddRange(MatDetails.Select(t => t.MatSN).ToList());
            ////记录当前出库的发料单
            CurrentOutOrder = outOrder;

            ////第三步：对应的模组进入出库模式
            var boardIds = MatDetails.Select(t => t.StoreInfo.BoardId)
                                   .Distinct()
                                   .ToList();
            var outModules = Modules.Where(t => boardIds.Contains(t.BoardId)).ToList();
            outModules.ForEach(t =>
            {
                var outMatSns = MatDetails.Where(t => t.StoreInfo.ModuleId == t.Id)
                                          .Select(t => t.MatSN)
                                          .ToList();
                t.GoInOutStoreMode(TcpCleint, outMatSns);
            });
            //所有板子亮灯后 亮警示灯
            WarningLight.GreenLight(TcpCleint);
        }

        public void GoInStocktaking()
        {
            this.CurentMode = Mode.盘点模式;
        }

        public void GoOutOutstore()
        {
            //找到在出库中的模组
            var outingModules = Modules.Where(t => t.CurrentMode == Mode.出库模式)
                                       .ToList();
            foreach (var module in outingModules)
            {
                module.GoOutOutStoreMode(TcpCleint);
            }
            CurrentOutOrder = null;
            CurrentOutStoreMatSNs.Clear();
            this.CurentMode = Mode.待机模式;
        }

        public void GoOutStocktaking()
        {
            this.CurentMode = Mode.待机模式;
        }

        void IShelfBase.Reset()
        {
            throw new NotImplementedException();
        }

        void IShelfBase.SetCurrentMode()
        {
            throw new NotImplementedException();
        }

        void IShelfBase.Warning()
        {
            throw new NotImplementedException();
        }

        public void ShelfCheck()
        {
            foreach (var module in Modules.Where(t => t.IsEnable).ToList())
            {
                module.ShelfCheck(TcpCleint);
            }
        }
        #endregion

        #region 协议返回处理
        public void ProtocolProcess(byte[] data, int boardId, int lightNumber)
        {
            Logs.Write("协议处理中的数据" + BitConverter.ToString(data) + $"板子id{boardId}");
            //协议处理 判断功能位
            switch (data[TcpCleint.PreFixLength + 2])
            {
                case 0x01://进入入库模式返回信号
                    GoInInstoreProcess(data, boardId, lightNumber);
                    break;
                case 0x02://退出入库模式返回信号
                    GoOutInstoreProcess(data, boardId, lightNumber);
                    break;
                case 0x03://正常入库信号
                    InStoreReturnProcess(data);
                    break;
                case 0x04://入库模式中异常信号
                    InStoreExceptionReturnProcess(data, boardId, lightNumber);
                    break;
                case 0x05://进入出库模式返回信号
                    GoInOutstoreProcess(data, boardId, lightNumber);
                    break;
                case 0x06://退出出库模式返回信号
                    GoOutOutstoreProcess(data, boardId, lightNumber);
                    break;
                case 0x07://正常出库返回信号
                    OutstoreReturnProcess(data, boardId, lightNumber);
                    break;
                case 0x13://复位的返回信号
                    ResetReturnProcess(data, boardId, lightNumber);
                    break;
                default:
                    ;
                    break;
            }
        }
        /// <summary>
        /// 进入入库模式返回信号处理
        /// </summary>
        /// <param name="data"></param>
        public void GoInInstoreProcess(byte[] data, int boardId, int lightNumber)
        {
            //库存物料与实际情况匹配
            if (data[TcpCleint.PreFixLength + 3] == 0x01)
            {
                var module = this.Modules.Where(t => t.BoardId == boardId)
                         .FirstOrDefault();
                if (module == null)
                {
                    //TO DO 报错
                    return;
                }
                else
                {
                    module.CurrentMode = Mode.入库模式;
                }
            }
            //库存物料与实际情况不匹配
            else if (data[TcpCleint.PreFixLength + 3] == 0x00)
            {
                var module = this.Modules.Where(t => t.BoardId == boardId).FirstOrDefault();
                if (module == null)
                {
                    //TO DO 报错
                    return;
                }
                else
                {
                    module.CurrentMode = Mode.入库模式;
                }
                //获取当前板所有库位
                var storeInfos = DbHelp.db.Queryable<StoreInfo>()
                                          .Where(t => t.BoardId == boardId)
                                          .ToList();
                //当前板子的灯数量
                var boardStoreNumber = storeInfos.Count();

                List<char> dataTemp = new List<char>();
                int index11 = 0;
                while (boardStoreNumber > 0)
                {
                    if (boardStoreNumber >= 4)
                    {
                        dataTemp.AddRange(Convert.ToString(data[TcpCleint.PreFixLength + 4 + index11], 2).PadLeft(8, '0').Reverse().ToList());
                        boardStoreNumber = boardStoreNumber - 4;
                    }
                    else
                    {
                        dataTemp.AddRange(Convert.ToString(data[TcpCleint.PreFixLength + 4 + index11], 2).PadLeft(2 * boardStoreNumber, '0').Reverse().ToList());
                        boardStoreNumber = 0;
                    }
                    index11++;
                }
                //当前板子的灯数量
                boardStoreNumber = storeInfos.Count();
                for (int index = 0; index <= boardStoreNumber - 1; index++)
                {
                    //当前库位异常
                    if (dataTemp[2 * index + 1] == '1')
                    {
                        if (dataTemp[2 * index] == '1')
                        {
                            var storeInfo = storeInfos.Where(t => t.LightNumber == index + 1).First();
                            if (storeInfo != null)
                            {
                                #region 缓存记录异常信息
                                ExceptionMessages.Add($"{storeInfo.StoreCode}物料{storeInfo.CurrentMatSn}丢失,库存数据已删除，请重新扫码后入库");
                                #endregion

                                #region 【后台】丢失的数据处理
                                Task.Run(() =>
                                {
                                    try
                                    {
                                        DbHelp.db.BeginTran();
                                        //库位表字段清空
                                        storeInfo.CurrentMatSn = string.Empty;
                                        DbHelp.db.Updateable(storeInfo).ExecuteCommand();

                                        //库存表记录删除、插入出入记录
                                        var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>().Where(t => t.StoreId == storeInfo.Id).First();
                                        if (inventoryDetail != null)
                                        {
                                            var inOutRecord = new InOutRecord()
                                            {
                                                StoreCode = storeInfo.StoreCode,
                                                StoreId = storeInfo.Id,
                                                StoreInfo = storeInfo,

                                                MatSN = inventoryDetail.MatSN,
                                                MatCode = inventoryDetail.MatCode,
                                                MatName = inventoryDetail.MatName,
                                                MatBatch = inventoryDetail.MatBatch,
                                                MatQty = inventoryDetail.MatQty,
                                                MatSpec = inventoryDetail.MatSpec,
                                                MatCustomer = inventoryDetail.MatCustomer,
                                                MatSupplier = inventoryDetail.MatSupplier,

                                                Direction = DirectionEnum.丢失,
                                            };
                                            DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
                                            DbHelp.db.Deleteable(inventoryDetail).ExecuteCommand();
                                        }
                                        DbHelp.db.CommitTran();
                                    }
                                    catch (Exception e)
                                    {
                                        DbHelp.db.RollbackTran();
                                    }
                                });
                                #endregion

                                WarningLight.WaringLightAlwaysRed(TcpCleint);
                            }
                            //库位未配置、返回数据异常
                            else
                            {
                                //Logs.Write($"[进入入库模式异常]板Id{boardIds},库位号{index + 1}找不到对应库位！");
                            }
                        }
                        else if (dataTemp[2 * index] == '0')
                        {
                            var storeInfo = storeInfos.Where(t => t.LightNumber == index + 1).First();
                            if (storeInfo != null)
                            {
                                #region 缓存记录异常信息
                                ExceptionMessages.Add($"库位{storeInfo.StoreCode}:存在物料未扫描上架");
                                #endregion
                                WarningLight.WaringLightAlwaysRed(TcpCleint);
                            }
                            else
                            {
                                Logs.Write($"[进入入库模式异常]板Id{boardId},库位号{index + 1}找不到对应库位！");
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 退出入库模式返回信号处理
        /// </summary>
        /// <param name="data"></param>
        public void GoOutInstoreProcess(byte[] data, int boardId, int lightNumber)
        {
            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == Mode.入库模式).FirstOrDefault();
            if (module == null)
            {
                return;
            }
            else
            {
                module.CurrentMode = Mode.待机模式;
            }
        }

        /// <summary>
        /// 正常入库信号
        /// </summary>
        /// <param name="data"></param>
        public void InStoreReturnProcess(byte[] data)
        {
            var boardId = (data[TcpCleint.PreFixLength + 0] << 8) + data[TcpCleint.PreFixLength + 1];
            var number = Convert.ToInt32(data[TcpCleint.PreFixLength + 3]);
            var storeInfo = DbHelp.db.Queryable<StoreInfo>().Where(t => t.BoardId == boardId
                                                                     && t.LightNumber == number).First();
            if (storeInfo == null)
            {
                //TO DO 报错
                return;
            }
            var module = this.Modules.Where(t => t.BoardId == boardId)
                                     .FirstOrDefault();
            if (module == null)
            {
                //TO DO 报错
                return;
            }
            #region 判断是否扫码获取物料信息
            //物料未扫码
            if (this.InStoreData == null)
            {
                //重复给了多次信号
                if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn))
                {
                    module.ComfirmInstore(TcpCleint);
                    //TO DO Logs.Write($"[{guid}]CAN给了多次正常入库信号，防止硬件异常，返回了确认入库");
                    return;
                }
                else
                {
                    var exceptionMessage = storeInfo.StoreCode + "入库过程中存在物料未扫描上架！";
                    WebSoceketManager.TrySendMessage("127.0.0.1", exceptionMessage);

                    module.ComfirmErrInstore(TcpCleint);
                    WarningLight.WaringLightBlueEnd(TcpCleint);
                    //WaringLightBlueEnd(shelfStatus.ClientIp, shelfStatus.LightId);
                    //TO DO Logs.Write($"[{guid}]当前物料信息不存在，请取出后重新扫码进行入库！");
                    return;
                }
            }
            //该位置已放置物料
            else if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn))
            {
                module.ComfirmErrInstore(TcpCleint);
                WarningLight.WaringLightBlueEnd(TcpCleint);
                //ComfirmErrInstoreByIp(shelfStatus.ClientIp, boardIds);
                //WaringLightBlueEnd(shelfStatus.ClientIp, shelfStatus.LightId);
                //TO DO Logs.Write($"[{guid}]该位置已放置物料！");
                return;
            }
            #endregion

            #region 已扫码且库位未被占用 保存数据
            {
                try
                {
                    DbHelp.db.BeginTran();
                    //库存明细表
                    var inventoryDetail = new InventoryDetail
                    {
                        StoreCode = storeInfo.StoreCode,
                        StoreId = storeInfo.Id,

                        MatSN = this.InStoreData.materialBar,
                        MatCode = this.InStoreData.materialCode,
                        MatName = this.InStoreData.materialName,
                        MatSpec = this.InStoreData.materialSpec,
                        MatBatch = this.InStoreData.batchNo,
                        MatQty = (int)this.InStoreData.materialQty,
                        MatCustomer = this.InStoreData.customer,
                        MatSupplier = this.InStoreData.supplier,

                        InstoreTime = DateTime.Now,
                        InstoreUser = ""
                    };

                    //出入库记录表
                    var inOutRecord = new InOutRecord()
                    {
                        StoreCode = storeInfo.StoreCode,
                        StoreId = storeInfo.Id,
                        StoreInfo = storeInfo,

                        MatSN = this.InStoreData.materialBar,
                        MatCode = this.InStoreData.materialCode,
                        MatName = this.InStoreData.materialName,
                        MatSpec = this.InStoreData.materialSpec,
                        MatBatch = this.InStoreData.batchNo,
                        MatQty = (int)this.InStoreData.materialQty,
                        MatCustomer = this.InStoreData.customer,
                        MatSupplier = this.InStoreData.supplier,

                        OperateUser = this.InStoreData.InstoreUser,
                        Direction = DirectionEnum.入库,
                    };

                    //库位表
                    storeInfo.CurrentMatSn = this.InStoreData.materialBar;

                    //保存and更新数据
                    DbHelp.db.Insertable(inventoryDetail).ExecuteCommand();
                    DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
                    DbHelp.db.Updateable(storeInfo).ExecuteCommand();
                    DbHelp.db.CommitTran();

                    //清空扫码信息
                    this.InStoreData = null;

                    //实际入库位置亮灯1S，报警灯同时进行亮绿灯并鸣叫一次提示。
                    Thread.Sleep(20);
                    Task.Run(() =>
                    {
                        //确认入库（硬件入库位置亮灯1秒）
                        module.ComfirmInstore(TcpCleint);
                        //报警灯亮绿灯 鸣叫一次提示
                        WarningLight.SuccessLightBlueEnd(TcpCleint);
                        //SuccessLightBlueEnd(shelfStatus.ClientIp, shelfStatus.LightId);
                    });
                }
                catch (Exception ex)
                {
                    DbHelp.db.RollbackTran();
                    Logs.Write($"入库保存数据异常，异常信息为{ex.Message}");
                    //报警灯报警
                    WarningLight.WaringLightBlueEnd(TcpCleint);
                    //WaringLightBlueEnd(shelfStatus.ClientIp, shelfStatus.LightId);
                }
            }
            #endregion
        }

        /// <summary>
        /// 入库模式中异常处理
        /// </summary>
        /// <param name="data"></param>
        /// <param name="boardId"></param>
        /// <param name="lightNumber"></param>
        public void InStoreExceptionReturnProcess(byte[] data, int boardId, int lightNumber)
        {
            lightNumber = (int)data[TcpCleint.PreFixLength + 4];
            var store = DbHelp.db.Queryable<StoreInfo>()
                                 .Where(t => t.BoardId == boardId && t.LightNumber == lightNumber)
                                 .First();
            if (store == null)
            {
                //TO DO 库位未找到
                return;
            }
            //已放物料丢失了  物料多放了  储位恢复正常
            switch (data[TcpCleint.PreFixLength + 3])
            {
                case 0x00:
                    {
                        var exceptionMessage = store.StoreCode + "恢复正常！";
                        WebSoceketManager.TrySendMessage("127.0.0.1", exceptionMessage);

                        ProcessingExceptions.RemoveAll(t => t.BoardId == boardId);
                    }
                    break;
                case 0x01:
                    {
                        var exceptionMessage = store.StoreCode + "入库过程中存在物料未扫描上架！";
                        WebSoceketManager.TrySendMessage("127.0.0.1", exceptionMessage);

                        ProcessingExceptions.Add(new ProcessingExceptionType()
                        {
                            BoardId = boardId,
                            LightNumber = lightNumber,
                            ExceptionMessage = store.StoreCode + "入库过程中存在物料未扫描上架！"
                        });
                    }
                    break;
                case 0x02:
                    {
                        var exceptionMessage = store.StoreCode + "物料被取出！";
                        WebSoceketManager.TrySendMessage("127.0.0.1", exceptionMessage);

                        ProcessingExceptions.Add(new ProcessingExceptionType()
                        {
                            BoardId = boardId,
                            LightNumber = lightNumber,
                            ExceptionMessage = store.StoreCode + "入库过程中物料丢失！"
                        });
                    }
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 进入出库模式协议返回
        /// </summary>
        /// <param name="data"></param>
        /// <param name="boardId"></param>
        /// <param name="lightNumber"></param>
        public void GoInOutstoreProcess(byte[] data, int boardId, int lightNumber)
        {
            //库存物料与实际情况匹配
            if (data[TcpCleint.PreFixLength + 3] == 0x01)
            {
                var module = this.Modules.Where(t => t.BoardId == boardId)
                         .FirstOrDefault();
                if (module == null)
                {
                    //TO DO 报错
                    return;
                }
                else
                {
                    module.CurrentMode = Mode.出库模式;
                }
            }
            //库存物料与实际情况不匹配
            else if (data[TcpCleint.PreFixLength + 3] == 0x00)
            {
                var module = this.Modules.Where(t => t.BoardId == boardId).FirstOrDefault();
                if (module == null)
                {
                    //TO DO 报错
                    return;
                }
                else
                {
                    module.CurrentMode = Mode.出库模式;
                }
                //获取当前板所有库位
                var storeInfos = DbHelp.db.Queryable<StoreInfo>()
                                          .Where(t => t.BoardId == boardId)
                                          .ToList();
                //当前板子的灯数量
                var boardStoreNumber = storeInfos.Count();

                List<char> dataTemp = new List<char>();
                int index11 = 0;
                while (boardStoreNumber > 0)
                {
                    if (boardStoreNumber >= 4)
                    {
                        dataTemp.AddRange(Convert.ToString(data[TcpCleint.PreFixLength + 4 + index11], 2).PadLeft(8, '0').Reverse().ToList());
                        boardStoreNumber = boardStoreNumber - 4;
                    }
                    else
                    {
                        dataTemp.AddRange(Convert.ToString(data[TcpCleint.PreFixLength + 4 + index11], 2).PadLeft(2 * boardStoreNumber, '0').Reverse().ToList());
                        boardStoreNumber = 0;
                    }
                    index11++;
                }
                //当前板子的灯数量
                boardStoreNumber = storeInfos.Count();
                for (int index = 0; index <= boardStoreNumber - 1; index++)
                {
                    //当前库位异常
                    if (dataTemp[2 * index + 1] == '1')
                    {
                        if (dataTemp[2 * index] == '1')
                        {
                            var storeInfo = storeInfos.Where(t => t.LightNumber == index + 1).First();
                            if (storeInfo != null)
                            {
                                #region 缓存记录异常信息
                                ExceptionMessages.Add($"{storeInfo.StoreCode}物料{storeInfo.CurrentMatSn}丢失,库存数据已删除，请重新扫码后入库");
                                #endregion

                                #region 【后台】丢失的数据处理
                                Task.Run(() =>
                                {
                                    try
                                    {
                                        DbHelp.db.BeginTran();
                                        //库位表字段清空
                                        storeInfo.CurrentMatSn = string.Empty;
                                        DbHelp.db.Updateable(storeInfo).ExecuteCommand();

                                        //库存表记录删除、插入出入记录
                                        var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>().Where(t => t.StoreId == storeInfo.Id).First();
                                        if (inventoryDetail != null)
                                        {
                                            var inOutRecord = new InOutRecord()
                                            {
                                                StoreCode = storeInfo.StoreCode,
                                                StoreId = storeInfo.Id,
                                                StoreInfo = storeInfo,

                                                MatSN = inventoryDetail.MatSN,
                                                MatCode = inventoryDetail.MatCode,
                                                MatName = inventoryDetail.MatName,
                                                MatBatch = inventoryDetail.MatBatch,
                                                MatQty = inventoryDetail.MatQty,
                                                MatSpec = inventoryDetail.MatSpec,
                                                MatCustomer = inventoryDetail.MatCustomer,
                                                MatSupplier = inventoryDetail.MatSupplier,

                                                Direction = DirectionEnum.丢失,
                                            };
                                            DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
                                            DbHelp.db.Deleteable(inventoryDetail).ExecuteCommand();
                                        }
                                        DbHelp.db.CommitTran();
                                    }
                                    catch (Exception e)
                                    {
                                        DbHelp.db.RollbackTran();
                                    }
                                });
                                #endregion

                                WarningLight.WaringLightAlwaysRed(TcpCleint);
                            }
                            //库位未配置、返回数据异常
                            else
                            {
                                //Logs.Write($"[进入入库模式异常]板Id{boardIds},库位号{index + 1}找不到对应库位！");
                            }
                        }
                        else if (dataTemp[2 * index] == '0')
                        {
                            var storeInfo = storeInfos.Where(t => t.LightNumber == index + 1).First();
                            if (storeInfo != null)
                            {
                                #region 缓存记录异常信息
                                ExceptionMessages.Add($"库位{storeInfo.StoreCode}:存在物料未扫描上架");
                                #endregion
                                WarningLight.WaringLightAlwaysRed(TcpCleint);
                            }
                            else
                            {
                                Logs.Write($"[进入入库模式异常]板Id{boardId},库位号{index + 1}找不到对应库位！");
                            }
                        }
                    }
                }
            }
        }

        public void OutstoreReturnProcess(byte[] data, int boardId, int lightNumber)
        {
            if (CurentMode != Mode.出库模式)
            {
                //TO DO 未在出库模式 要报错
                //Logs.Write($"[{guid}]出库错误：该货架模式不是出库模式或盘点模式{storeInfo.ShelfCode}！");
                return;
            }
            lightNumber = Convert.ToInt32(data[TcpCleint.PreFixLength + 3]);
            var storeInfo = DbHelp.db.Queryable<StoreInfo>().Where(t => t.BoardId == boardId
                                                                     && t.LightNumber == lightNumber)
                                                            .First();
            if (storeInfo == null)
            {
                //TO DO 报错
                return;
            }
            var module = this.Modules.Where(t => t.BoardId == boardId)
                                     .FirstOrDefault();
            if (module == null)
            {
                //TO DO 报错
                return;
            }
            //当前库位未记录MatSn
            if (string.IsNullOrEmpty(storeInfo.CurrentMatSn))
            {
                //该库位是需要出库的库位，物料被多次取出or给了多个正常出库信号
                Logs.Write($"该库位是需要出库的库位，物料被反复取出or给了多个正常出库信号,库位{storeInfo.StoreCode}");
                //暂不进行处理
                return;
            }

            //不是本次出库需要出的物料
            if (!CurrentOutStoreMatSNs.Contains(storeInfo.CurrentMatSn))
            {
                //Logs.Write($"{storeInfo.CurrentMatSN}不是本次需要出库的物料");
                //报警灯报警
                WarningLight.WaringLightAlwaysRed(TcpCleint);
                return;
            }

            //获取当前的库存信息
            var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>().Where(t => t.MatSN == storeInfo.CurrentMatSn).First();
            if (inventoryDetail == null)
            {
                //Logs.Write($"{storeInfo.CurrentMatSN}库存信息不存在");
                //报警灯报警
                WarningLight.WaringLightAlwaysRed(TcpCleint);
                return;
            }
            //获取对应的出库单明细
            var orderOrderDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
                                .Where(t => t.OrderId == CurrentOutOrder.Id)
                                .Where(t => t.MatSN == inventoryDetail.MatSN)
                                .ToList();
            if (orderOrderDetails == null || orderOrderDetails.Count == 0)
            {
                //Logs.Write($"{storeInfo.CurrentMatSN},OrderDetail出库明细信息不存在");
                //报警灯报警
                WarningLight.WaringLightAlwaysRed(TcpCleint);
                return;
            }

            #region 校验项通过 处理出库逻辑
            //当前库位的SN
            var matSN = storeInfo.CurrentMatSn;
            try
            {
                DbHelp.db.BeginTran();
                //库存明细表 删除
                ;
                //出入库记录表 新增
                var inOutRecord = new InOutRecord()
                {
                    StoreCode = storeInfo.StoreCode,
                    StoreId = storeInfo.Id,
                    StoreInfo = storeInfo,

                    MatSN = inventoryDetail.MatSN,
                    MatCode = inventoryDetail.MatCode,
                    MatName = inventoryDetail.MatName,
                    MatBatch = inventoryDetail.MatBatch,
                    MatQty = inventoryDetail.MatQty,
                    MatSpec = inventoryDetail.MatSpec,
                    MatCustomer = inventoryDetail.MatCustomer,
                    MatSupplier = inventoryDetail.MatSupplier,

                    Direction = DirectionEnum.出库,
                };
                //库位表 修改
                storeInfo.CurrentMatSn = string.Empty;

                //发料单明细表 更新为已出库
                orderOrderDetails.ForEach(x =>
                {
                    x.IsSended = true;
                });
                //TO DO 发料需求表增加数量
                
                //保存数据
                DbHelp.db.Deleteable(inventoryDetail).ExecuteCommand();
                DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
                DbHelp.db.Updateable(storeInfo).ExecuteCommand();
                DbHelp.db.Updateable(orderOrderDetails).ExecuteCommand();
                DbHelp.db.CommitTran();

                //报警灯同时亮绿灯并鸣叫一次提示。
                WarningLight.SuccessLightGreenEnd(TcpCleint);

                //确认本次出库
                module.ComfirmOutstore(TcpCleint, data[TcpCleint.PreFixLength + 3]);
                //shelfStatus.SetCurrentModeTime = DateTime.Now;
                //LocalStatic.IsRefreshOrderDetail = true;

                //当前柜子是否还存在未出库的
                CurrentOutStoreMatSNs.RemoveAll(t => t == matSN);//删除本次已出的物料SN

                var isExsistOut = CurrentOutStoreMatSNs.Any();
                if (!isExsistOut)
                {
                    //Logs.Write($"货架[{shelfStatus.ShelfCode}]:不存在待出物料，退出出库模式");
                    //退出出库模式
                    GoOutOutstore();
                    WarningLight.CloseLight(TcpCleint);

                    var currentPickBillNumber = CurrentOutOrder.OrderNumber;
                    CurrentOutOrder = null;
                    Task.Run(() =>
                    {
                        //LocalStatic.UpdatOutOrderStatus(currentPickBillNumber);
                        //给信号通知出库页面更新页面的状态
                    });
                }
            }
            catch (Exception ex)
            {
                DbHelp.db.RollbackTran();
                //报警灯报警
                WarningLight.WaringLightAlwaysRed(TcpCleint);
            }
            #endregion
        }

        /// <summary>
        /// 退出出库模式返回信号处理
        /// </summary>
        /// <param name="data"></param>
        public void GoOutOutstoreProcess(byte[] data, int boardId, int lightNumber)
        {
            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == Mode.出库模式).FirstOrDefault();
            if (module == null)
            {
                return;
            }
            else
            {
                module.CurrentMode = Mode.待机模式;
            }
        }

        public void ResetReturnProcess(byte[] data, int boardId, int lightNumber)
        {
            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == Mode.入库模式).FirstOrDefault();
            if (module == null)
            {
                return;
            }
            else
            {
                module.CurrentMode = Mode.待机模式;
            }
        }


        #endregion
    }

    /// <summary>
    /// 过程中异常类型
    /// </summary>
    public class ProcessingExceptionType
    {
        public int BoardId { get; set; }

        public int LightNumber { get; set; }

        public string ExceptionMessage { get; set; }
    }
}