using log4net;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
//using FuBaRobot.LoadCSVLibrary;


namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 康奈德IO控制模块
    /// </summary>
    public class KNDAIManager
    {

        public static ushort DefaultAILength = 8;
        public static byte DefualtSlaveID = 255;
        private static string AIStartAddress = "0258";
        public static readonly ILog LOGGER = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        public static Dictionary<string, AITcpClient> mastMap = new Dictionary<string, AITcpClient>();
        public static Dictionary<string, List<KNDAI>> AIValueMap = new Dictionary<string, List<KNDAI>>();
        private static object AIMapLock = "";

        public static System.Timers.Timer timer = null;
        private static ushort port = 502;

        //public static bool IsNeedReadAI = true;
        public static void ConnectionIP(string ioIp)
        {
            if (timer == null)
            {
                timer = new System.Timers.Timer();
                timer.Interval = 300;
                timer.AutoReset = true;
                timer.Elapsed += timer_Elapsed;
                timer.Enabled = true;
            }
            AITcpClient MBmaster = null;
            if (mastMap.ContainsKey(ioIp))
            {
                MBmaster = mastMap[ioIp];

                if (null != MBmaster)
                {
                    MBmaster.disconnect();
                    MBmaster.Dispose();
                    MBmaster = null;
                    lock (AIMapLock)
                    {
                        if (AIValueMap.ContainsKey(ioIp))
                        {
                            AIValueMap.Remove(ioIp);
                        }
                    }
                }
                mastMap.Remove(ioIp);
            }
            try
            {
                // Create new modbus master and add event functions
                MBmaster = new AITcpClient(ioIp, port);
                MBmaster.OnResponseData += new AITcpClient.ResponseData(MBmaster_OnResponseData);
                MBmaster.OnException += new AITcpClient.ExceptionData(MBmaster_OnException);
                MBmaster.autoConnectOfBreak = false;
                mastMap.Add(ioIp, MBmaster);
                LogUtil.info(LOGGER, "连接AI模块[" + ioIp + "]成功");
                Thread.Sleep(10);
                WriteAIScope(ioIp, 1);
                Thread.Sleep(10);
                ReadAll(ioIp);
            }
            catch (Exception error)
            {
                LogUtil.error(LOGGER, "连接AI模块[" + ioIp + "]出错：" + error.ToString());
            }
        }

        private static void ReadAll(string ioIp)
        {
            //读取所有的DO
            ReadMultipleAI(ioIp, DefualtSlaveID, AIStartAddress, DefaultAILength);
        }

        /// <summary>
        /// 判断Io模块是否连接
        /// </summary> 
        public static bool IsConnection(string ip)
        {
            try
            {
                List<string> list = new List<string>(mastMap.Keys);
                foreach (string io in list)
                {
                    if (io.Equals(ip))
                    {
                        //判断是否连接，如果没有连接自动重连
                        AITcpClient clinet = mastMap[io];

                        if (clinet.ISConnection())
                        {
                            return true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(LOGGER, "出错啦：" + ex.ToString());
            }
            return false;
        }
        private static DateTime PreCheckTime = DateTime.Now;
        private static bool isProcess = false;
        public static bool NeedShow = false;
        private static void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (isProcess)
            {
                return;
            }
            try
            {
                isProcess = true;
                bool IsNeedReadAI = IOManager.IOValue(IO_Type.TrayCheck_Door).Equals(IO_VALUE.HIGH) || NeedShow;
                TimeSpan span = DateTime.Now - PreCheckTime;
                List<string> list = new List<string>(mastMap.Keys);
                foreach (string IP in list)
                {
                    //判断是否连接，如果没有连接自动重连
                    AITcpClient clinet = mastMap[IP];
                    if (!IsNeedReadAI)
                    {
                        ClearAIData(IP);
                        continue;
                    }

                    if (clinet.ISConnection())
                    {
                        ReadAll(clinet.IP);
                    }
                    else if (span.TotalSeconds > 3)
                    {
                        LogUtil.error(LOGGER, "AI模块" + IP + "当前没有连上，重连" + IP);
                        ConnectionIP(IP);
                        PreCheckTime = DateTime.Now;
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(LOGGER, "出错啦：" + ex.ToString());
            }
            Thread.Sleep(2);
            isProcess = false;
        }

        private static void WriteAIScope(string ioIp, int value)
        {
            // 0 表示 0 - 10V， 1 表示 0 - 5V
            WriteAIScope(ioIp, DefualtSlaveID, "03EA", value);
        }
        private static void WriteAIScope(string ioIp, byte slaveId, string Adress, int value)
        {
            //     写 AI 模块采样范围，可以往寄存器里面写入 0 或 1。 0 表示 0 - 10V， 1 表示 0 - 5V。默
            //认 0，写 AI 模块采样范围为 0 - 5V
            ushort ID = 1;
            AITcpClient MBmaster = null;
            if (mastMap.ContainsKey(ioIp))
            {
                MBmaster = mastMap[ioIp];
                MBmaster.WriteAIScope(ID, slaveId, Adress, value);
            }
            else
            {
                LogUtil.error(LOGGER, "WriteAIScope出错没有连接AI模块：" + ioIp);
            }
        }
        private static void ReadMultipleAI(string ioIp, byte slaveId, string StartAddress, int length)
        {
            ushort ID = 1;
            AITcpClient MBmaster = null;
            if (mastMap.ContainsKey(ioIp))
            {
                MBmaster = mastMap[ioIp];
                MBmaster.ReadAllAI(ID, StartAddress, length * 2, slaveId);
            }
            else
            {
                LogUtil.error(LOGGER, "ReadMultipleAI出错没有连接AI模块：" + ioIp);
            }
        }
        public static void CloseAllConnection()
        {
            List<AITcpClient> list = new List<AITcpClient>();
            foreach (AITcpClient tcp in list)
            {
                tcp.disconnect();
            }
            mastMap.Clear();
        }
        public static double ConvertAI(double aiValue, double defaultValue)
        {
            double xishu = (double)ConfigAppSettings.GetNumValue(Setting_Init.AI_ConvertPosition);
            double result = Math.Round((aiValue - defaultValue) / xishu, 2);
            return result;
        }
        public static double GetAIValue(string ioiP, int index)
        {
            double aiValue = GetAIValue(ioiP, DefualtSlaveID, index - 1);

            return Math.Round(aiValue, 2);
        }

        public static double GetAIValue(string ioIP, byte slaveId, int index)
        {
            double value = 0;
            try
            {
                lock (AIMapLock)
                {
                    if (AIValueMap.ContainsKey(ioIP))
                    {
                        List<KNDAI> allIo = new List<KNDAI>(AIValueMap[ioIP]);
                        List<KNDAI> list = (from m in allIo where m.SlaveId.Equals(slaveId) && m.AIIndex.Equals(index) select m).ToList<KNDAI>();
                        if (list.Count > 0)
                        {
                            value = list[0].AIValue;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("GetAIValue  出错了 :ioIP[" + ioIP + "]index[" + index + "]：" + ex);
            }
            return value;
        }
        private static void ClearAIData(string ioIp)
        {
            byte[] datas = new byte[32];
            for (int i = 0; i < datas.Length; i++)
            {
                datas[i] = 0;
            }
            SaveAIData(ioIp, 3, datas);
        }
        private static void SaveAIData(string ioIp, ushort ID, byte[] values)
        {
            try
            {
                if (values.Length.Equals(DefaultAILength * 4))
                {
                    List<KNDAI> kndList = new List<KNDAI>();

                    string strFromat = "{0:X2}";

                    string msg = "";
                    for (int index = 0; index < DefaultAILength; index++)
                    {
                        string str1 = String.Format(strFromat, values[index * 4 + 2]) + String.Format(strFromat, values[index * 4 + 3])
                            + String.Format(strFromat, values[index * 4 + 1]) + String.Format(strFromat, values[index * 4]);

                        double value = BitToFloat(str1);
                        KNDAI io = new KNDAI(ioIp, (byte)DefualtSlaveID, index, value);
                        if (value > 0)
                        {
                            Console.WriteLine(str1 + " float convert = {0}", value);
                        }
                        msg += "【" + index + "=" + value + "】";
                        kndList.Add(io);
                    }
                    //LogUtil.info(msg);
                    lock (AIMapLock)
                    {
                        if (AIValueMap.ContainsKey(ioIp))
                        {
                            AIValueMap.Remove(ioIp);
                        }
                        AIValueMap.Add(ioIp, kndList);
                    }
                    try
                    {
                        if (StoreManager.Store != null && IOManager.IOValue(IO_Type.TrayCheck_Door).Equals(IO_VALUE.HIGH))
                        {
                            if (StoreManager.Config.AIDI1_Addr > 0 && StoreManager.Config.AIDI2_Addr > 0)
                            {    //每次上传后验证下
                                int v1 = (int)GetAIValue(ioIp, StoreManager.Config.AIDI1_Addr);
                                int v2 = (int)GetAIValue(ioIp, StoreManager.Config.AIDI2_Addr);
                                if (v1.Equals(0) && v2.Equals(0))
                                {
                                    LogUtil.info(msg);
                                    string value = AcSerialBean.ByteToString(values);
                                    LogUtil.error("收到【" + ioIp + "】的数据【" + value + "】，2个高度都为0");
                                    // ConnectionIP(ioIp);
                                }
                            }
                            else if (StoreManager.Config.AIDI3_Addr > 0 && StoreManager.Config.AIDI4_Addr > 0)
                            {    //每次上传后验证下
                                int v1 = (int)GetAIValue(ioIp, StoreManager.Config.AIDI3_Addr);
                                int v2 = (int)GetAIValue(ioIp, StoreManager.Config.AIDI4_Addr);
                                if (v1.Equals(0) && v2.Equals(0))
                                {
                                    LogUtil.info(msg);
                                    string value = AcSerialBean.ByteToString(values);
                                    LogUtil.error("收到【" + ioIp + "】的数据【" + value + "】，2个高度都为0");
                                    // ConnectionIP(ioIp);
                                }
                            }
                        }

                    }
                    catch (Exception ex)
                    {
                        LogUtil.error("验证数据出错：" + ex.StackTrace);
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(LOGGER, "SaveAIData出错：" + ex.ToString());
            }
        }

        private static float BitToFloat(string hexString)
        {
            uint num = uint.Parse(hexString, System.Globalization.NumberStyles.AllowHexSpecifier);
            byte[] floatVals = BitConverter.GetBytes(num);
            float f = BitConverter.ToSingle(floatVals, 0);
            return f;
        }
        private static void MBmaster_OnResponseData(string ioIp, ushort ID, byte function, byte[] values, byte[] reviceData)
        {
            try
            {
                if (ioIp.IndexOf(":") > 0)
                {
                    ioIp = ioIp.Substring(0, ioIp.IndexOf(":"));
                }
                string strFromat = "{0:X2}";
                string reviceMsg = "";
                foreach (byte data in reviceData)
                {
                    reviceMsg = reviceMsg + " " + String.Format(strFromat, data);
                    if (reviceMsg.Length > 200)
                    {
                        break;
                    }
                }
                //   LOGGER.Info ("Read data：【" + reviceMsg + "】  ");
                if (ID == 0xFF)
                {
                    return;
                }
                // ------------------------------------------------------------------------
                // Identify requested data
                ushort Func = ID;

                if (Func == 0 && reviceData.Length > 8)
                {
                    Func = reviceData[7];
                }
                byte SlaveId = 0xFF;
                if (reviceData.Length >= 7)
                {
                    SlaveId = reviceData[6];
                }
                switch (function)
                {
                    case 1:
                        //LOGGER.Info("Read coils end：【" + reviceMsg + "】 ");

                        break;
                    case 2:
                        //LOGGER.Info("Read discrete inputs end：【" + reviceMsg + "】  ");
                        //SaveAIData(ioIp, SlaveId, values);
                        break;
                    case 3:

                        SaveAIData(ioIp, ID, values);
                        break;
                    case 4:
                        //LOGGER.Info("读入(多个)寄存器完成 end：【" + reviceMsg + "】 ");
                        break;
                    case 5:
                        //LOGGER.Info("Write single coil：【" + reviceMsg + "】 ");
                        break;

                }
            }
            catch (Exception ex)
            {
                LogUtil.error(LOGGER, "处理接受数据出错：" + ex.ToString());
            }
        }
        private static void MBmaster_OnException(string ioIp, ushort id, byte function, byte exception, byte[] reviceData)
        {
            string exc = "Modbus says error: ";
            switch (exception)
            {
                case AITcpClient.excIllegalFunction: exc += "Illegal function!"; break;
                case AITcpClient.excIllegalDataAdr: exc += "Illegal data adress!"; break;
                case AITcpClient.excIllegalDataVal: exc += "Illegal data value!"; break;
                case AITcpClient.excSlaveDeviceFailure: exc += "Slave device failure!"; break;
                case AITcpClient.excAck: exc += "Acknoledge!"; break;
                case AITcpClient.excSlaveIsBusy: exc += "Slave is busy!"; break;
                case AITcpClient.excGatePathUnavailable: exc += "Gateway path unavailbale!"; break;
                case AITcpClient.excExceptionTimeout: exc += "Slave timed out!"; break;
                case AITcpClient.excExceptionConnectionLost: exc += "Connection is lost!"; break;
                case AITcpClient.excExceptionNotConnected: exc += "Not connected!"; break;
                default:
                    break;
            }
            LOGGER.Error("接收数据出错：" + exc);
        }
    }

    public class KNDAI
    {

        public KNDAI(string ioIp, byte ID, int index, double value)
        {
            this.IoIP = ioIp;
            this.SlaveId = ID;
            this.AIIndex = index;
            this.AIValue = value;
            UpdateTime = DateTime.Now;
        }
        /// <summary>
        /// AI模块IP
        /// </summary>
        public string IoIP { get; set; }
        /// <summary>
        /// 地址
        /// </summary>
        public byte SlaveId { get; set; }
        /// <summary>
        /// 第几个AI
        /// </summary>
        public int AIIndex { get; set; }
        /// <summary>
        /// 值
        /// </summary>
        public double AIValue { get; set; }
        /// <summary>
        /// 更新时间
        /// </summary>
        public DateTime UpdateTime { get; set; }
    }
}