using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;

namespace DeviceLib
{

    partial class ACServerManager
    {

        private static Dictionary<int, Dictionary<string, RegisterInfo>> LastDataMap = new Dictionary<int, Dictionary<string, RegisterInfo>>();

        //private static SerialBean bean = null;
        private static string strFromat = "{0:X2}";
        private static Dictionary<string, AcSerialBean> serialBeanMap = new Dictionary<string, AcSerialBean>();

        private static AcSerialBean GetSerialBean(string portName)
        {
            if (serialBeanMap.ContainsKey(portName))
            {
                return serialBeanMap[portName];
            }
            return null;
        }


        private static bool SendStrAndSleep(string portName, string str, int sleepS)
        {
            byte[] data = AcSerialBean.StringToByte(str);
            data[data.Length - 1] = 0x00;
            data[data.Length - 2] = 0x00;
            data = ACCMDManager.buildCheckData(data, data.Length - 2);
            bool result = SendData(portName, data);
            System.Threading.Thread.Sleep(sleepS);
            return result;
        }

        private static void SaveData(string portName, byte slvAddr, string regAddr, int value)
        {
            if (LastDataMap.ContainsKey(slvAddr))
            {
                if (LastDataMap[slvAddr].ContainsKey(regAddr))
                {
                    LastDataMap[slvAddr][regAddr] = new RegisterInfo(slvAddr, regAddr, value);
                }
                else
                {
                    LastDataMap[slvAddr].Add(regAddr, new RegisterInfo(slvAddr, regAddr, value));
                }
            }
            else
            {
                Dictionary<string, RegisterInfo> map = new Dictionary<string, RegisterInfo>();
                map.Add(regAddr, new RegisterInfo(slvAddr, regAddr, value));
                LastDataMap.Add(slvAddr, map);
            }
        }
        private static RegisterInfo GetData(string portName, byte slvAddr, string regAddr)
        {
            if (LastDataMap.ContainsKey(slvAddr))
            {
                if (LastDataMap[slvAddr].ContainsKey(regAddr))
                {
                    return LastDataMap[slvAddr][regAddr];
                }
            }
            return null;
        }

        private static void SendData(string portName, byte[] data, int reviceLength)
        {
            if (data == null)
            {
                return;
            }

            byte[] returnData = SendCommand(portName, data, ReviceOutTimeMS, reviceLength);
            string strSend = "";
            for (int i = 0; i < returnData.Length; i++)
            {
                strSend += string.Format("{0:X2} ", returnData[i]);
            }
            if (IsShowMsg)
            {
                Log(InfoType.Info, "串口" + portName + " 收到数据：" + strSend + "");
            }
        }
        private static bool SendData(string portName, byte[] data)
        {

            if (data == null)
            {
                return false;
            }
            int timeOut = ReviceOutTimeMS;
            //if (data[1].Equals((byte)10))
            //{
            //    timeOut = 1000;
            //}
            bool result = false;
            byte[] returnData = SendCommand(portName, data, timeOut, 8, out result);
            if (returnData != null)
            {
                string strSend = "";
                for (int i = 0; i < returnData.Length; i++)
                {
                    strSend += string.Format("{0:X2} ", returnData[i]);
                }
                if (IsShowMsg)
                {
                    Log(InfoType.Info,"串口" + portName + " 收到数据：" + strSend + "");
                }
            }
            return result;
        }
        /// <summary>
        /// 发送数据并获取返回值
        /// </summary>
        /// <param name="data">发送的数据</param>
        /// <param name="outTime">超时时间</param>
        /// <returns>返回值的长度</returns>
        private static byte[] SendCommand(string portName, byte[] data, int outTime, int reviceLength)
        {
            if (outTime <100)
            {
                outTime = 100;
            }
            byte[] returnData = null;

            try
            {
                if (data == null)
                {
                    return returnData;
                }
                string strSend = "";
                for (int i = 0; i < data.Length; i++)
                {
                    strSend += string.Format("{0:X2} ", data[i]);
                }
                if (strSend.Equals(""))
                {
                    return returnData;
                }
                if (IsShowMsg)
                {
                    Log(InfoType.Info, "串口" + portName + " 写入数据：" + strSend + "");
                }
                AcSerialBean bean = GetSerialBean(portName);
                if (bean == null)
                {
                    Log(InfoType.Debug,"ACServerManager SendCommand  试图向未打开串口【" + portName + "】写入数据：" + strSend + "。");
                }
                else
                {
                   int ret= bean.SendCommand(data, ref returnData, outTime, reviceLength);
                    string rDataStr = AcSerialBean.ByteToString(returnData);
                    if (!ret.Equals(reviceLength))
                    {
                        Log(InfoType.Error,"串口" + portName + " 写入数据：" + strSend + "，预计返回字节数【"+reviceLength+"】实际返回【"+ret+"】【"+rDataStr+"】");
                    }
                    System.Threading.Thread.Sleep(2);
                }
            }
            catch (Exception ex)
            {
                Log(InfoType.Info,ex.ToString());
            }
            return returnData;
        }
        /// <summary>
        /// 发送数据并获取返回值
        /// </summary>
        /// <param name="data">发送的数据</param>
        /// <param name="outTime">超时时间</param>
        /// <param name="result">返回结果，是否发送成功</param>
        /// <returns>返回值的长度</returns>
        private static byte[] SendCommand(string portName, byte[] data, int outTime, int reviceLength, out bool result)
        {
            if (outTime < 100)
            {
                outTime = 100;
            }
            byte[] returnData = null;
            result = false;
            try
            {
                if (data == null)
                {
                    return returnData;
                }
                string strSend = "";
                for (int i = 0; i < data.Length; i++)
                {
                    strSend += string.Format("{0:X2} ", data[i]);
                }
                if (strSend.Equals(""))
                {
                    return returnData;
                }
                if (IsShowMsg)
                {
                    Log(InfoType.Info,"串口" + portName + " 写入数据：" + strSend + "");
                }
                AcSerialBean bean = GetSerialBean(portName);
                if (bean == null)
                {
                    Log(InfoType.Debug,"ACServerManager SendCommand  试图向未打开串口【" + portName + "】写入数据：" + strSend + "。");
                }
                else
                {
                    int ret = bean.SendCommand(data, ref returnData, outTime, reviceLength);

                    if (!ret.Equals(reviceLength))
                    {
                        string datastr = AcSerialBean.ByteToString(returnData);
                        Log(InfoType.Error,"串口" + portName + " 写入数据：" + strSend + "，预计返回字节数【" + reviceLength + "】实际返回【" + ret + "】:"+ datastr);
                    }
                    else
                    {
                        result = true;
                    }
                    System.Threading.Thread.Sleep(2);
                }
            }
            catch (Exception ex)
            {
                Log(InfoType.Info,ex.ToString());
            }
            return returnData;
        }

        private static void WriteData(string portName, int slvAddr, string addr, string data, byte cmd, int length)
        {
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, cmd, addr, data, length);
            SendData(portName, dataArray);
        }
        private static void SendStr(string portName, int slvAddr, string str)
        {
            //string str = txtSendStr.Text;
            byte[] data = AcSerialBean.StringToByte(str);
            data[data.Length - 1] = 0x00;
            data[data.Length - 2] = 0x00;
            data = ACCMDManager.buildCheckData(data, data.Length - 2);
            SendData(portName, data);
        }

        private static void Stop(string portName, int slvAddr)
        {
            //RunBlock(6);
            string addr = ACCMDManager.Stop_Addr;
            string data = "FF00";
            //byte cmd = 0x05;
            int length = 2;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            SendData(portName, dataArray);

            System.Threading.Thread.Sleep(1000);
            data = "0000";
            dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            SendData(portName, dataArray);
        }


        private static void OpenAndCloseSTB(string portName, int slvAddr)
        {

            if (GetBusyStatus(portName, slvAddr).Equals(1))
            {
                Log(InfoType.Error, "伺服【" + portName + "_" + slvAddr + "】OpenSTB时发现 busy=1，直接返回");
                return;
            }
            System.Threading.Thread.Sleep(SleepMSendons);
            if (GetSTBState(portName, slvAddr).Equals(1))
            {
                Log(InfoType.Error, "伺服【" + portName + "_" + slvAddr + "】OpenSTB时发现 STB=ON，先关闭STB");
                CloseSTB(portName, slvAddr);
                System.Threading.Thread.Sleep(SleepMSendons);
                if (GetSTBState(portName, slvAddr).Equals(1))
                {
                    Log(InfoType.Error, "伺服【" + portName + "_" + slvAddr + "】OpenSTB时发现 STB=ON，先关闭STB 后发现STB仍为ON，直接返回");
                    return;
                }
            }

            System.Threading.Thread.Sleep(SleepMSendons);
            OnlyOpenSTB(portName, slvAddr);
            if (NeedCloseSTB)
            {
                System.Threading.Thread.Sleep(200);
                CloseSTB(portName, slvAddr);
                System.Threading.Thread.Sleep(SleepMSendons);
            }
        }

        private static void OnlyOpenSTB(string portName, int slvAddr)
        {
            string addr = ACCMDManager.STB_Addr;
            string data = "FF00";
            int length = 2;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            SendData(portName, dataArray);
        }
        private static void CloseSTB(string portName, int slvAddr)
        {
            string addr = ACCMDManager.STB_Addr;
            string data = "0000";
            int length = 2;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            SendData(portName, dataArray);
        }

        private static void UpdateBlock(string portName, int slvAddr, string blockNum)
        {
            int preNum = GetAddrValue(portName,slvAddr, ACCMDManager.BlockNo);
            if (preNum.Equals(-1) || (!preNum.ToString().Equals(blockNum)))
            {
                byte[] data = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteRegisters, ACCMDManager.BlockNo, blockNum , 2);
                SendData(portName, data);
                int value = Convert.ToInt16(blockNum);
                UpdateAddrValue(portName,slvAddr, ACCMDManager.BlockNo, value);
                Thread.Sleep(SleepMSendons);
            }
        }

        private static void CloseAlarmClear(string portName, int slvAddr)
        {
            string addr = ACCMDManager.Clear_Alarm_Addr;
            string data = "0000";
            //byte cmd = 0x05;
            int length = 2;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            SendData(portName, dataArray);
        }

        private static string PreReadAddr = "";
        private static string PreReadCoilAddr = "";

        private static int GetRegisterData(string portName, byte[] reviceData, string Address)
        {
            if (reviceData != null && reviceData.Length > 0)
            {
                string strSend = "";
                for (int i = 0; i < reviceData.Length; i++)
                {
                    strSend += string.Format("{0:X2} ", reviceData[i]);
                }
                if (IsShowMsg)
                {
                    Log(InfoType.Info, "串口" + portName + " 收到数据：" + strSend + "");
                }
                string strFromat = "{0:X2}";
                byte slvAddrR = reviceData[0];

                int lenth = reviceData[2];
                byte cmd = reviceData[1];
                if (cmd.Equals(ACCMDManager.CMD_ReadRegisters) && reviceData.Length > 6 && lenth == 4)
                {
                    string str = string.Format(strFromat, reviceData[5]) + string.Format(strFromat, reviceData[6]) + string.Format(strFromat, reviceData[3]) + string.Format(strFromat, reviceData[4]);
                    int value = Convert.ToInt32(str.Trim().Replace(" ", ""), 16);
                    SaveData(portName, slvAddrR, Address, value);
                    return value;
                }
            }
            return -1;
        }

      
        private static int GetCoilData(string portName, byte[] reviceData, string Address)
        {
            if (reviceData != null && reviceData.Length > 0)
            {
                string strSend = "";
                for (int i = 0; i < reviceData.Length; i++)
                {
                    strSend += string.Format("{0:X2} ", reviceData[i]);
                }

                if (IsShowMsg)
                {
                    Log(InfoType.Info, "串口" + portName + " 收到数据：" + strSend + "");
                }
                string strFromat = "{0:X2}";
                byte slvAddrR = reviceData[0];

                int lenth = reviceData[2];
                byte cmd = reviceData[1];
                if (cmd.Equals(ACCMDManager.CMD_ReadCoil) && reviceData.Length >= 6 && lenth == 1)
                {
                    string str = string.Format(strFromat, reviceData[3]);
                    int value = Convert.ToInt32(str.Trim().Replace(" ", ""), 16);
                    SaveData(portName, slvAddrR, Address, value);
                    return value;
                }
            }
            return -1;
        }

        /// <summary>
        /// 紧急停止运动
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        public static void SuddenStop(string portName, int slvAddr)
        {
            // RunBlock(7);
            string addr = ACCMDManager.SDStop_Addr;
            string data = "FF00";
            //byte cmd = 0x05;

            //int length = 2;
            //byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            //bool result = SendData(portName, dataArray); 
            //System.Threading.Thread.Sleep(500);
            //data = "0000";
            //dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            //SendData(portName, dataArray);

            int length = 2;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);

            for (int i = 1; i <= 3; i++)
            {
                bool result = SendData(portName, dataArray);
                if (result)
                {
                    System.Threading.Thread.Sleep(500);
                    data = "0000";
                    dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
                    result = SendData(portName, dataArray);
                    break;
                }
                else
                {
                    Log(InfoType.Error, "【" + portName + "_" + slvAddr + "】 , 第" + i + "次，SuddenStop 发送数据失败");
                    Thread.Sleep(180);
                }
            }
        }
        /// <summary>
        /// 获取伺服当前实际位置
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        /// <param name="rGetCount"></param>
        /// <returns></returns>
        public static int GetActualtPosition(string portName, int slvAddr, int rGetCount = 3)
        {
            PreReadAddr = ACCMDManager.ActualPosition;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadRegisters, ACCMDManager.ActualPosition, "0000", 2);
            //  SendData(portName,dataArray);

            int result = -1;
            for (int i = 1; i <= rGetCount; i++)
            {
                byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 9);
                result = GetRegisterData(portName, reviceData, ACCMDManager.ActualPosition);
                if (!result.Equals(-1))
                {
                    break;
                }
                else
                {
                    Log(InfoType.Error, "第" + i + "次获取" + portName + "_" + slvAddr + "的实时位置" + result);
                }
                Thread.Sleep(180);
            }
            return result;
        }

        /// <summary>
        /// 清理报警
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        public static void AlarmClear(string portName, int slvAddr)
        {
            string addr = ACCMDManager.Clear_Alarm_Addr;
            string data = "FF00";
            //byte cmd = 0x05;
            int length = 2;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            SendData(portName, dataArray);
            System.Threading.Thread.Sleep(200);
            data = "0000";
            dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_WriteCoil, addr, data, length);
            SendData(portName, dataArray);
        }
        /// <summary>
        /// 获取伺服目标位置
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        /// <returns></returns>
        public static int GetTargetPosition(string portName, int slvAddr)
        {
            PreReadAddr = ACCMDManager.TargetPostion;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadRegisters, ACCMDManager.TargetPostion, "0000", 2);
            //  SendData(portName,dataArray);
            byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 9);

            return GetRegisterData(portName, reviceData, ACCMDManager.TargetPostion);
        }
        /// <summary>
        /// 获取伺服报警状态，1=报警中
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        /// <returns></returns>
        public static int GetAlarmStatus(string portName, int slvAddr)
        {
            PreReadCoilAddr = ACCMDManager.Alarm_Status;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadCoil, PreReadCoilAddr, "0000", 1);
            //SendData(portName,dataArray); 
            byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 6);
            return GetCoilData(portName, reviceData, PreReadCoilAddr);
        }
        /// <summary>
        /// 获取伺服忙碌状态，1=忙碌中
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        /// <returns></returns>
        public static int GetBusyStatus(string portName, int slvAddr)
        {
            PreReadCoilAddr = ACCMDManager.BUSYStatus;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadCoil, ACCMDManager.BUSYStatus, "0000", 1);
            //SendData(portName,dataArray); 
            byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 6);
            return GetCoilData(portName, reviceData, ACCMDManager.BUSYStatus);
        }
        /// <summary>
        /// 获取原点返回是否完成的值，1=完成
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        /// <returns></returns>
        public static int GetHomeEndStatus(string portName, int slvAddr)
        {
            PreReadCoilAddr = ACCMDManager.HOME_CMP_Status;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadCoil, ACCMDManager.HOME_CMP_Status, "0000", 1);
            //SendData(portName,dataArray); 
            byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 6);
            return GetCoilData(portName, reviceData, ACCMDManager.HOME_CMP_Status);
        }
        /// <summary>
        /// 获取STB信号值，1=On,0=OFF
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        /// <returns></returns>
        public static int GetSTBState(string portName, int slvAddr)
        {
            PreReadCoilAddr = ACCMDManager.STB_State;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadCoil, ACCMDManager.STB_State, "0000", 1);
            byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 6);
            return GetCoilData(portName, reviceData, ACCMDManager.STB_State);
        }
        /// <summary>
        /// 获取原点信号值，1=原点亮
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        /// <returns></returns>
        public static int GetHomeSingle(string portName, int slvAddr)
        {
            PreReadCoilAddr = ACCMDManager.Home_Single;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadCoil, ACCMDManager.Home_Single, "0000", 1);
            byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 6);
            return GetCoilData(portName, reviceData, ACCMDManager.Home_Single);
        }
      /// <summary>
      /// 获取负极限值，1=负极限亮
      /// </summary>
      /// <param name="portName"></param>
      /// <param name="slvAddr"></param>
      /// <returns></returns>
        public static int GetLimitNegativeSingle(string portName, int slvAddr)
        {
            PreReadCoilAddr = ACCMDManager.Limit_Negative_Single;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadCoil, ACCMDManager.Limit_Negative_Single, "0000", 1);
            byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 6);
            return GetCoilData(portName, reviceData, ACCMDManager.Limit_Negative_Single);
        }
        
        /// <summary>
        /// 获取正极限值，2=正极限亮
        /// </summary>
        /// <param name="portName"></param>
        /// <param name="slvAddr"></param>
        /// <returns></returns>
        public static int GetLimitPositiveSingle(string portName, int slvAddr)
        {
            PreReadCoilAddr = ACCMDManager.Limit_Positive_Single;
            byte[] dataArray = ACCMDManager.GetWriteData(slvAddr, ACCMDManager.CMD_ReadCoil, ACCMDManager.Limit_Positive_Single, "0000", 1);
            byte[] reviceData = SendCommand(portName, dataArray, ReviceOutTimeMS, 6);
            return GetCoilData(portName, reviceData, ACCMDManager.Limit_Positive_Single);
        }
        private static int GetAddrValue(string portName, int slvAddr, string addr)
        {
            int value = -1;
            try
            {
                string name = portName + "_" + slvAddr;
                Dictionary<string, int> map = null;
                ComAddrValue.TryGetValue(name, out map);
                if (map == null)
                {
                    return -1;
                }
                if (map.ContainsKey(addr))
                {
                    return map[addr];
                }
            }
            catch (Exception ex)
            {
                Log(InfoType.Error, "UpdateAddrValue出错：" + ex.ToString());
            }
            return value;
        }
        private static void UpdateAddrValue(string portName, int slvAddr, string addr, int value)
        {
            try
            {
                lock (mapObj)
                {
                    string name = portName + "_" + slvAddr;
                    Dictionary<string, int> map = null;
                    ComAddrValue.TryGetValue(name, out map);
                    if (map == null)
                    {
                        map = new Dictionary<string, int>();
                        ComAddrValue.Add(name, map);
                    }

                    if (map.ContainsKey(addr))
                    {
                        ComAddrValue[name][addr] = value;
                    }
                    else
                    {
                        ComAddrValue[name].Add(addr, value);
                    }
                }
            }
            catch (Exception ex)
            {
                Log(InfoType.Error, "UpdateAddrValue出错：" + ex.ToString());
            }

        }
    }
    /// <summary>
    /// 记录最后一次获得的寄存器的值
    /// </summary>
    public class RegisterInfo
    {
        public RegisterInfo(int slv, string addr, int data)
        {
            this.SlvAddr = slv;
            this.RegisterAddr = addr;
            this.LastData = data;
            this.LastTime = new DateTime();
        }
        public int SlvAddr { get; set; }

        public string RegisterAddr { get; set; }

        public int LastData { get; set; }

        public DateTime LastTime { get; set; }
    }

}