using System;
using System.Collections;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Diagnostics;
using log4net;
using System.Reflection;
using OnlineStore.Common;

namespace OnlineStore.DeviceLibrary
{
   
    public class AITcpClient
    {
        public static readonly ILog LOGGER = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        // ------------------------------------------------------------------------
        // Constants for access
        private const byte fctReadCoil = 1;
        private const byte fctReadDiscreteInputs = 2;
        private const byte fctReadHoldingRegister = 3;
        private const byte fctReadInputRegister = 4;
        private const byte fctWriteSingleCoil = 5;
        private const byte fctWriteSingleRegister = 6;
        private const byte fctWriteMultipleCoils = 15;
        private const byte fctWriteMultipleRegister = 16;
        private const byte fctReadWriteMultipleRegister = 23;

        /// <summary>Constant for exception illegal function.</summary>
        public const byte excIllegalFunction = 1;
        /// <summary>Constant for exception illegal data address.</summary>
        public const byte excIllegalDataAdr = 2;
        /// <summary>Constant for exception illegal data value.</summary>
        public const byte excIllegalDataVal = 3;
        /// <summary>Constant for exception slave device failure.</summary>
        public const byte excSlaveDeviceFailure = 4;
        /// <summary>Constant for exception acknowledge.</summary>
        public const byte excAck = 5;
        /// <summary>Constant for exception slave is busy/booting up.</summary>
        public const byte excSlaveIsBusy = 6;
        /// <summary>Constant for exception gate path unavailable.</summary>
        public const byte excGatePathUnavailable = 10;
        /// <summary>Constant for exception not connected.</summary>
        public const byte excExceptionNotConnected = 253;
        /// <summary>Constant for exception connection lost.</summary>
        public const byte excExceptionConnectionLost = 254;
        /// <summary>Constant for exception response timeout.</summary>
        public const byte excExceptionTimeout = 255;
        /// <summary>Constant for exception wrong offset.</summary>
        private const byte excExceptionOffset = 128;
        /// <summary>Constant for exception send failt.</summary>
        private const byte excSendFailt = 100;

        // ------------------------------------------------------------------------
        // Private declarations
        private static ushort _timeout = 500;
        private static ushort _refresh = 10;
        private static bool _connected = false;
        private static bool _autoConnectOfBreak = false;

        private Socket socketClient;
        private int M281_A_Len = 0;
        private byte[] tcpSocketReviceBuffer = new byte[2048];

        //private Socket tcpSynCl;
        //private byte[] tcpSynClBuffer = new byte[2048];

        // ------------------------------------------------------------------------
        /// <summary>Response data event. This event is called when new data arrives</summary>
        public delegate void ResponseData(string ip, ushort id, byte function, byte[] data,byte[] reviceData);
        /// <summary>Response data event. This event is called when new data arrives</summary>
        public event ResponseData OnResponseData;
        /// <summary>Exception data event. This event is called when the data is incorrect</summary>
        public delegate void ExceptionData(string ip, ushort id, byte function, byte exception, byte[] reviceData);
        /// <summary>Exception data event. This event is called when the data is incorrect</summary>
        public event ExceptionData OnException;

        /// <summary>
        /// autoConnectOfBreak
        /// </summary>
        public bool autoConnectOfBreak
        {
            get { return _autoConnectOfBreak; }
            set { _autoConnectOfBreak = value;  }
        } 
        public static ushort timeout
        {
            get { return _timeout; }
            set { _timeout = value; }
        }
         
        public ushort refresh
        {
            get { return _refresh; }
            set { _refresh = value; }
        }
         
        public bool connected
        {
            get { return _connected; }
        }
         
        public AITcpClient()
        {
        }
        public string IP = "";
        public int Port = 0;
        public int TimeOutTime = 0;
        public AITcpClient(string ip, ushort port)
        {
            TimeOutTime = 2000;
            connect(ip, port);
        }
        private System.Timers.Timer reviceTimer = new System.Timers.Timer();
        public void connect(string ip, ushort port)
        {
            try
            {
                this.IP = ip;
                this.Port = port;
                OnResponseData = null;
                // Connect asynchronous client
                socketClient = new Socket(IPAddress.Parse(ip).AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                if (TimeOutTime <= 0)
                {
                    socketClient.Connect(new IPEndPoint(IPAddress.Parse(ip), port));
                    socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, _timeout);
                    socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, _timeout);
                    socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, 1);

                }
                else
                {
                    socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, _timeout);
                    socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, _timeout);
                    socketClient.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, 1);
                    IAsyncResult connResult = socketClient.BeginConnect(ip, port, null, null);
                    connResult.AsyncWaitHandle.WaitOne(this.TimeOutTime, true);  //等待2秒 
                    if (!connResult.IsCompleted)
                    {
                        LogUtil.info(LOGGER, "Connect to " + ip + ":" + port + " fail!");
                        return;
                    }
                    else
                    {
                        _connected = true;
                        LogUtil.info(LOGGER, "Connect to " + ip + ":" + port + " success!");
                    }
                }
                //Thread threadReceive = new Thread(new ThreadStart(ReceiveHandle));
                //threadReceive.Start();
                reviceTimer.AutoReset = true;
                reviceTimer.Elapsed += reviceTimer_Elapsed;
                reviceTimer.Interval = 130;
                reviceTimer.Enabled = true;
                _connected = true;
            }
            catch (Exception error)
            {
                LogUtil.info(LOGGER, "Connect to " + ip + ":" + port + " fail!");
                _connected = false;
            }
        }

        public void WriteAIScope(ushort id, byte slaveId, string address, int value)
        {
            //0x000100000006FF0603EA0001
            byte function = 0x06;
            byte[] data = new byte[12];

            byte[] _id = BitConverter.GetBytes((short)id);
            data[0] = _id[0];				// Slave id high byte
            data[1] = _id[1];				// Slave id low byte 
            data[2] = 0x00;
            data[3] = 0x00;
            data[4] = 0x00;
            data[5] = 6;					// Message size
            data[6] = slaveId;					// Slave address    //必须设置为"1": 2012.04-24 覃发光;
            data[7] = function; ;				// Function code
            byte[] _adr = SerialBean.StringToByte(address);
            data[8] = _adr[0];				// Start address
            data[9] = _adr[1];				// Start address
            byte[] _length =   BitConverter.GetBytes((short)1);
            data[10] = _length[0];			// Number of data to read
            data[11] = _length[1];			// Number of data to read
              WriteAsyncData( data,id);
        }

        public void ReadAllAI(ushort id, string startAddress, int length, byte slaveId)
        {
            //0x 000100000006FF0302580010
            byte function = 0x03;
            byte[] data = CreateData(id, startAddress,(ushort) length, function, slaveId); 
            WriteAsyncData(data, id);
        }

        private byte[] CreateData(ushort id, string  startAddress, ushort length, byte function, byte SlaveID)
        {
            byte[] data = new byte[12];

            byte[] _id = BitConverter.GetBytes((short)id);
            data[0] = _id[0];				// Slave id high byte
            data[1] = _id[1];				// Slave id low byte
            data[5] = 6;					// Message size
            data[6] = SlaveID;					// Slave address    //必须设置为"1": 2012.04-24 覃发光;
            data[7] = function;				// Function code
            byte[] _adr = SerialBean.StringToByte(startAddress);
            if (_adr.Length .Equals( 2))
            {
                data[8] = _adr[0];              // Start address
                data[9] = _adr[1];              // Start address
            }else if (_adr.Length.Equals(1))
            {
                data[8] = 0x00;
                data[9] = _adr[0];              // Start address
            }
            else
            {
                data[8] = 0x00;
                data[9] = 0x00;
            }
            byte[] _length = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)length));
            data[10] = _length[0];			// Number of data to read
            data[11] = _length[1];			// Number of data to read
            return data;
        }
        void reviceTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            try
            {
                ReviceDataProcess(); 
                Thread.Sleep(10);
            }
            catch (Exception ex)
            {
                LOGGER.Error("出错：" + ex.ToString());
            }
        }

        private void ReviceDataProcess()
        {
            int lengthIndex = 5;
            byte[] rdata = Receive();
            if (rdata != null)
            {
                string str = "";
                foreach (byte by in rdata)
                {
                    str = str + " " + by;
                    //if (str.Length > 200)
                    //{
                    //    break;
                    //}
                }

                //这里rdata就是接收到的数据，
                IPEndPoint clientipe = (IPEndPoint)socketClient.RemoteEndPoint;
                //ushort id = BitConverter.ToUInt16(rdata, 0); 
                //byte function = rdata[7];
                byte dataLength = rdata[lengthIndex];

                int allLength = lengthIndex + 1 + dataLength;
              
                if (rdata.Length > allLength)
                {
                    //LogUtil.info(clientipe.ToString() + "收到数据(需要分包)：" + str);
                    int currStartIndex = 0;
                    for (int i = 0; i < 100; i++)
                    {
                        try
                        {

                            if (rdata.Length < currStartIndex + lengthIndex)
                            {
                                LogUtil.error(clientipe.ToString() + "收到数据：" + str + "分包出错 [" + currStartIndex + "]");
                                break;
                            }
                            else
                            { 
                                dataLength = rdata[currStartIndex + lengthIndex];
                                allLength = lengthIndex + 1 + dataLength;

                                byte[] thisData = new byte[allLength];
                                Array.Copy(rdata, currStartIndex, thisData, 0, allLength);
                                ushort id = BitConverter.ToUInt16(thisData, 0);
                                byte function = thisData[7];
                                DataProcess(clientipe.ToString(), id, function, thisData);
                                //剩余的数据处理

                                if (rdata.Length <= currStartIndex + allLength)
                                {
                                    break;
                                }
                                currStartIndex = currStartIndex + allLength;
                            }
                        }
                        catch (Exception ex)
                        {
                            LogUtil.error(clientipe.ToString() + "收到数据：" + str + "分包出错 [" + currStartIndex + "]：" + ex.ToString());
                        }
                      
                    }
                }
                else
                {
                    LogUtil.debug(LOGGER, clientipe.ToString() + "收到数据(无需分包)：" + str);
                    ushort id = BitConverter.ToUInt16(rdata, 0);
                    byte function = rdata[7];
                    DataProcess(clientipe.ToString(),id,function,rdata);
                }
            }
        }

        private void DataProcess(string clientIp, ushort id, byte function, byte[] rdata)
        {
            byte[] data;

            if ((function >= fctWriteSingleCoil) && (function != fctReadWriteMultipleRegister))
            {
                data = new byte[2];
                Array.Copy(rdata, 10, data, 0, 2);
            }
            // ------------------------------------------------------------
            // Read response data
            else
            { 
                data = new byte[rdata[8]];
                Array.Copy(rdata, 9, data, 0, rdata[8]);
            }
            // ------------------------------------------------------------
            // Response data is slave exception
            if (function > excExceptionOffset)
            {
                function -= excExceptionOffset;
                CallException(id, function, rdata[8], rdata);
            }
            // ------------------------------------------------------------
            // Response data is regular data
            else if (OnResponseData != null)
            {  //收到的数据打印出来
                
                OnResponseData(clientIp, id, function, data, rdata);
            }
        }
      
        private byte[] Receive()
        {
            try
            {
                if (socketClient == null || !socketClient.Connected || socketClient.Available < 1)
                {
                    return null;
                }
                
                int size = socketClient.Available;
                byte[] rData = new byte[size]; 
                socketClient.Receive(rData, size, SocketFlags.None); 
                return rData;

            }
            catch (SocketException e)
            {
                if (socketClient != null)
                {
                    socketClient.Close();
                    socketClient = null;
                }

                return null;
            }
        }  
        
       
        public void disconnect()
        {
            Dispose();
        }
 
        ~AITcpClient()
        {
            Dispose();
        }
 
        public void Dispose()
        {
            reviceTimer.Enabled = false;
            if (socketClient != null)
            {
                if (socketClient.Connected)
                {
                    try { socketClient.Shutdown(SocketShutdown.Both); }
                    catch { }
                    socketClient.Close();
                }
                socketClient = null;
            } 
        }

        internal void CallException(ushort id, byte function, byte exception, byte[] rdata)
        {

            reviceTimer.Enabled = false;
            if ((socketClient == null))
            {
                return;
            }
            if (exception == excExceptionConnectionLost)
            {
                //tcpSynCl = null;
                socketClient = null;
                return;
            }
            if (OnException != null)
            {
                OnException(socketClient.RemoteEndPoint.AddressFamily.ToString(), id, function, exception, rdata);
            }
        }
          
        public void WriteAsyncData(byte[] write_data, ushort id)
        {
            try
            {
                if (socketClient == null)
                {
                    LOGGER.Error("发送数据时发现socketClient=null");
                    return;
                }
                IPEndPoint clientipe = (IPEndPoint)socketClient.RemoteEndPoint;
                if ((socketClient != null) && (socketClient.Connected))
                {
                    try
                    {
                        //发送的数据打印出来
                        string str = "";
                        foreach (byte by in write_data)
                        {
                            str = str + " " + by;

                        }
                        //LogUtil.info( clientipe.ToString()+"发送数据：" + str);
                        socketClient.BeginSend(write_data, 0, write_data.Length, SocketFlags.None, new AsyncCallback(OnSend), null);
                        //socketClient.BeginReceive(tcpSocketReviceBuffer, 0, tcpSocketReviceBuffer.Length, SocketFlags.None, new AsyncCallback(OnReceive), socketClient);
                        ReviceDataProcess();
                    }
                    catch (SystemException error)
                    {
                        CallException(id, write_data[7], excExceptionConnectionLost, tcpSocketReviceBuffer);
                    }
                }
                else CallException(id, write_data[7], excExceptionConnectionLost, tcpSocketReviceBuffer);
            }
            catch (Exception ex)
            {
                LOGGER.Error("出错："+ex.ToString());
            }
        }
         
        // ------------------------------------------------------------------------
        // Write asynchronous data acknowledge
        private void OnSend(System.IAsyncResult result)
        {
            if (result.IsCompleted == false) CallException(0xFFFF, 0xFF, excSendFailt, tcpSocketReviceBuffer);
        } 
        internal bool ISConnection()
        { 
            if (socketClient == null)
            {
                return false;
            }
            if (socketClient.Connected == false)
            {
                return false;
            }
            return true;
        }
    }
}