using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace OnlineStore.DeviceLibrary
{
    public class TrayManager
    {
        /// <summary>
        /// 出库时，可以不下降直接放料盘的宽度
        /// </summary>
        public const int CanPushBagWidth = 7; 
        /// <summary>
        /// 放在公共地方，方便存取，夹料编码盘列表，key=编码（1-6），value=是否有物品，true=有物品
        /// </summary>
        private static Dictionary<int, TrayInfo> fixtureCodeFullMap = new Dictionary<int, TrayInfo>();
        private static object fixtureMapLock = "";
        /// <summary>
        /// 流水线需要的空盘数量
        /// </summary>
        internal static int LineNeedEmptyTrayNum = 0;
        /// <summary>
        /// 最大托盘号，必须按照顺序从1到6走过
        /// </summary>
        internal static int MaxTrayNum = 0;
        /// <summary>
        /// 托盘错误消息
        /// </summary>
        public static string TrayErrorMsg = "";
        /// <summary>
        /// 盘错乱的StoreID
        /// </summary>
        public static int ErrorStoreId = -1;

        public static bool LineRunTest = false;
        static TrayManager()
        {
            LineRunTest = ConfigAppSettings.GetIntValue(Setting_Init.LineRunTest).Equals(1); 
        } 
        internal static void AddNeedEmptyTrayNum()
        {
            Interlocked.Increment(ref LineNeedEmptyTrayNum);
        }

        internal static void DelNeedEmptyTrayNum()
        {
            Interlocked.Decrement(ref LineNeedEmptyTrayNum);
        }


        /// <summary>
        /// 对应的盘号（1-6）是否有料盘
        /// </summary>
        /// <param name="trayNum">盘号1-6</param>
        /// <returns>盘上是否有料盘</returns>
        internal static bool TrayIsFull(int trayNum)
        {
            lock (fixtureMapLock)
            {
                if (fixtureCodeFullMap.ContainsKey(trayNum))
                {
                    return fixtureCodeFullMap[trayNum].IsFull;
                }
            }
            return false;
        }

        internal static TrayInfo GetTrayInfo(int trayNum)
        {
            lock (fixtureMapLock)
            {
                if (fixtureCodeFullMap.ContainsKey(trayNum))
                {
                    return fixtureCodeFullMap[trayNum];
                }
            }
            return null;
        }
      
        
        internal static void UpdateTrayInfo(int trayNum, bool isFull=false, int inOrOut=0, string wareCode = "", string posId = "", int plateH = 0, int plateW = 0)
        {
            lock (fixtureMapLock)
            {
                if (fixtureCodeFullMap.ContainsKey(trayNum))
                {
                    fixtureCodeFullMap[trayNum].IsFull = isFull;
                    fixtureCodeFullMap[trayNum].InOrOutStore = inOrOut;

                    fixtureCodeFullMap[trayNum].WareCode = wareCode;
                    fixtureCodeFullMap[trayNum].PosId = posId;
                    fixtureCodeFullMap[trayNum].PlateH = plateH;
                    fixtureCodeFullMap[trayNum].PlateW = plateW;

                }
                else
                {
                    TrayInfo fixture = new TrayInfo(trayNum, isFull, inOrOut, wareCode, posId, plateH, plateW);
                    fixtureCodeFullMap.Add(trayNum, fixture);
                }
            }
        }

        internal static void UpdateTrayCode(int trayNum, string wareCode = "" )
        {
            LogUtil.info(  "更新托盘【" + trayNum + "】的条码为【" + wareCode + "】");
            lock (fixtureMapLock)
            {
                if (fixtureCodeFullMap.ContainsKey(trayNum))
                {
                    fixtureCodeFullMap[trayNum].WareCode = wareCode; 

                }
            }
        }
        internal static void UpdateInStoreNG(int trayNum,   bool isNg = false)
        {
            LogUtil.info("更新托盘【" + trayNum + "】InStoreNG=【" + isNg + "】");
            lock (fixtureMapLock)
            {
                if (fixtureCodeFullMap.ContainsKey(trayNum))
                { 
                    fixtureCodeFullMap[trayNum].InStoreNG = isNg;

                }
            }
        }
        internal static void UpdateTrayPosId(int trayNum, string PosId = "")
        {
            lock (fixtureMapLock)
            {
                if (fixtureCodeFullMap.ContainsKey(trayNum))
                {
                    fixtureCodeFullMap[trayNum].PosId = PosId;
                }
            }
        }
        /// <summary>
        /// 是否还有有料仓的盘
        /// </summary> 
        internal static bool IsHasFullTray()
        {
            foreach (int key in fixtureCodeFullMap.Keys)
            {
                if (fixtureCodeFullMap[key].IsFull)
                {
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// 是否还有有料仓正在出库的盘
        /// </summary> 
        internal static bool IsHasFullOutFixture()
        {
            foreach (int key in fixtureCodeFullMap.Keys)
            {
                if (fixtureCodeFullMap[key].IsFull && fixtureCodeFullMap[key].InOrOutStore.Equals(2))
                {
                    return true;
                }
            }
            return false;
        }

        internal static bool RightTrayCode(int trayNum, int preTrayNum, bool isCanUpdateMax)
        {
            int defNext = preTrayNum + 1;
            if (preTrayNum.Equals(0) || MaxTrayNum.Equals(0) || trayNum.Equals(defNext))
            {
                if (isCanUpdateMax && trayNum > MaxTrayNum)
                {
                    MaxTrayNum = trayNum;
                    LogUtil.info("更新MaxTrayNum=" + preTrayNum);
                }
                return true;
            }
            else if (trayNum.Equals(1) && preTrayNum >= MaxTrayNum)
            {
                return true;
            } 
            return false;
        }

        internal static void UpdateTrayNumError(int errorStoreID, string errorMsg)
        {
            TrayErrorMsg = errorMsg;
            ErrorStoreId = errorStoreID;
        }
        /// <summary>
        /// 获取托盘编码
        /// </summary> 
        public static int GetTrayNum(int subType)
        {
            string ip = GetRFIP(subType);
            //获取盘号
            RFIDData data = RFIDManager.ReadRFIDData(ip);
            if (data != null)
            {
                if (data.RFType.Equals("E"))
                {

                    return data.Num;
                } else
                {
                    LogUtil.error("读取托盘RFID[" + subType + "][" + ip + "]的数据出错：" + data.ToStr());
                }
            }
            return 0;
        }
        public static int GetShelfNum(int subType)
        {
            string ip = GetRFIP(subType, 1);
            //获取盘号
            RFIDData data = RFIDManager.ReadRFIDData(ip);
            if (data != null)
            {
                if (data.RFType.Equals("B"))
                {
                    return data.Num;
                }
                else
                {
                    LogUtil.error("读取料架RFID[" + subType + "][" + ip + "]的数据出错：" + data.ToStr());
                }
            }
            return 0;
        }
        public static byte[] GetShelfData(int subType)
        {
            string ip = GetRFIP(subType, 1);
            //获取盘号
            byte[] data = RFIDManager.ReadData(ip);
            return data;
        }
        public  static string GetRFIP(int subType, int rtType = 0)
        {
            string ip = "";
            string rtName = DeviceConfig.RFIP_Str +"_"+ subType.ToString().PadLeft(3, '0');
            if (rtType > 0)
            {
                rtName += "-" + rtType.ToString();
            }  
            if (DeviceConfig.ProRFIpMap.ContainsKey(rtName))
            {
                ip = DeviceConfig.ProRFIpMap[rtName];  
            }
            return ip;
        }

        #region 横移状态缓存

        internal static Dictionary<int, int> SidesWayStateMap = new Dictionary<int, int>();
        internal static object swMapLock = "";
        internal static bool CanMoveSidesWay(int swNum)
        {
            if (SidesWayStateMap.ContainsKey(swNum))
            {
                if (SidesWayStateMap[swNum].Equals(1))
                {
                    return true;
                } 
                else if (swNum.Equals(1) || swNum.Equals(3))
                {
                    if (SidesWayStateMap[swNum].Equals(0))
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        /// <summary>
        /// 更新横移托盘的处理状态
        /// </summary>
        /// <param name="swNum">横移编号</param>
        /// <param name="value">0=未处理等待中，1=托盘处理完成，可处理横移，2=托盘检测处理中</param>
        internal static void UpdateSWState(int swNum,int value)
        {
            if (swNum <= 0)
            {
                return;
            }
            lock (swMapLock)
            {
                if (SidesWayStateMap.ContainsKey(swNum))
                {
                    SidesWayStateMap[swNum] = value;
                }
                else
                {
                    SidesWayStateMap.Add(swNum, value);
                }
            }
        }
        #endregion

    }
}