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;
using OnlineStore.LoadCSVLibrary;

namespace OnlineStore.DeviceLibrary
{

    public class MasterTcpClient
    {
        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 MasterTcpClient()
        {
        }

        public int TimeOutTime = 0;
        public MasterTcpClient(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
            {
                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;
                    }
                }
                //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;
            }
        }

        void reviceTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            try
            {
                //socketClient.BeginReceive(tcpSocketReviceBuffer, 0, tcpSocketReviceBuffer.Length, SocketFlags.None, new AsyncCallback(OnReceive), socketClient);
                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 + "]");
                            }

                            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;
            }
        }

        // ------------------------------------------------------------------------
        /// <summary>Stop connection to slave.</summary>
        public void disconnect()
        {
            Dispose();
        }

        // ------------------------------------------------------------------------
        /// <summary>Destroy master instance.</summary>
        ~MasterTcpClient()
        {
            Dispose();
        }

        // ------------------------------------------------------------------------
        /// <summary>Destroy master instance</summary>
        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 ReadCoils(ushort id, ushort startAddress, ushort numInputs, byte SlaveID)
        {
            WriteAsyncData(CreateReadHeader(id, startAddress, numInputs, fctReadCoil, SlaveID), id);
        }
        public void ReadDiscreteInputs(ushort id, ushort startAddress, ushort numInputs, byte SlaveID)
        {
            WriteAsyncData(CreateReadHeader(id, startAddress, numInputs, fctReadDiscreteInputs, SlaveID), id);
        }
        public void ReadHoldingRegister(ushort id, ushort startAddress, ushort numInputs, byte SlaveID)
        {
            WriteAsyncData(CreateReadHeader(id, startAddress, numInputs, fctReadHoldingRegister, SlaveID), id);
        }
        public void ReadInputRegister(ushort id, ushort startAddress, ushort numInputs, byte SlaveID)
        {
            WriteAsyncData(CreateReadHeader(id, startAddress, numInputs, fctReadInputRegister, SlaveID), id);
        }
        public void WriteSingleCoils(ushort id, ushort startAddress, IO_VALUE ioValue, byte SlaveID)
        {
            byte[] data;
            bool OnOff = ioValue.Equals(IO_VALUE.HIGH);
            data = CreateWriteHeader(id, startAddress, 1, 1, fctWriteSingleCoil, SlaveID);
            if (OnOff == true) data[10] = 255;
            else data[10] = 0;
            WriteAsyncData(data, id);
        }

        public void WriteMultipleCoils(ushort id, ushort startAddress, ushort numBits, byte[] values, byte SlaveID)
        {
            byte numBytes = Convert.ToByte(values.Length);
            byte[] data;
            data = CreateWriteHeader(id, startAddress, numBits, (byte)(numBytes + 2), fctWriteMultipleCoils, SlaveID);
            Array.Copy(values, 0, data, 13, numBytes);
            WriteAsyncData(data, id);
        }

        public void WriteSingleRegister(ushort id, ushort startAddress, byte[] values, byte SlaveID)
        {
            byte[] data;
            data = CreateWriteHeader(id, startAddress, 1, 1, fctWriteSingleRegister, SlaveID);
            data[10] = values[0];
            data[11] = values[1];
            WriteAsyncData(data, id);
        }

        public void WriteMultipleRegister(ushort id, ushort startAddress, byte[] values, byte SlaveID)
        {
            ushort numBytes = Convert.ToUInt16(values.Length);
            if (numBytes % 2 > 0) numBytes++;
            byte[] data;

            data = CreateWriteHeader(id, startAddress, Convert.ToUInt16(numBytes / 2), Convert.ToUInt16(numBytes + 2), fctWriteMultipleRegister, SlaveID);
            Array.Copy(values, 0, data, 13, values.Length);
            WriteAsyncData(data, id);
        }

        public void ReadWriteMultipleRegister(ushort id, ushort startReadAddress, ushort numInputs, ushort startWriteAddress, byte SlaveID, byte[] values)
        {
            ushort numBytes = Convert.ToUInt16(values.Length);
            if (numBytes % 2 > 0) numBytes++;
            byte[] data;

            data = CreateReadWriteHeader(id, startReadAddress, numInputs, startWriteAddress, Convert.ToUInt16(numBytes / 2), SlaveID);
            Array.Copy(values, 0, data, 17, values.Length);
            WriteAsyncData(data, id);
        }


        // ------------------------------------------------------------------------
        // Create modbus header for read action
        private byte[] CreateReadHeader(ushort id, ushort 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 = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)startAddress));
            data[8] = _adr[0];				// Start address
            data[9] = _adr[1];				// Start address
            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;
        }

        // ------------------------------------------------------------------------
        // Create modbus header for write action
        private byte[] CreateWriteHeader(ushort id, ushort startAddress, ushort numData, ushort numBytes, byte function, byte SlaveID)
        {
            byte[] data = new byte[numBytes + 11];

            byte[] _id = BitConverter.GetBytes((short)id);
            data[0] = _id[0];				// Slave id high byte
            data[1] = _id[1];				// Slave id low byte+
            byte[] _size = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)(5 + numBytes)));
            data[4] = _size[0];				// Complete message size in bytes
            data[5] = _size[1];				// Complete message size in bytes
            data[6] = SlaveID;				// Slave address   //必须设置为"1": 2012.04-24 覃发光;
            data[7] = function;				// Function code
            byte[] _adr = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)startAddress));
            data[8] = _adr[0];				// Start address
            data[9] = _adr[1];				// Start address
            if (function >= fctWriteMultipleCoils)
            {
                byte[] _cnt = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)numData));
                data[10] = _cnt[0];			// Number of bytes
                data[11] = _cnt[1];			// Number of bytes
                data[12] = (byte)(numBytes - 2);
            }
            return data;
        }

        // ------------------------------------------------------------------------
        // Create modbus header for write action
        private byte[] CreateReadWriteHeader(ushort id, ushort startReadAddress, ushort numRead, ushort startWriteAddress, ushort numWrite, byte SlaveID)
        {
            byte[] data = new byte[numWrite * 2 + 17];

            byte[] _id = BitConverter.GetBytes((short)id);
            data[0] = _id[0];						// Slave id high byte
            data[1] = _id[1];						// Slave id low byte+
            byte[] _size = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)(11 + numWrite * 2)));
            data[4] = _size[0];						// Complete message size in bytes
            data[5] = _size[1];						// Complete message size in bytes
            data[6] = SlaveID;							// Slave address    //必须设置为"1": 2012.04-24 覃发光;
            data[7] = fctReadWriteMultipleRegister;	// Function code
            byte[] _adr_read = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)startReadAddress));
            data[8] = _adr_read[0];					// Start read address
            data[9] = _adr_read[1];					// Start read address
            byte[] _cnt_read = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)numRead));
            data[10] = _cnt_read[0];				// Number of bytes to read
            data[11] = _cnt_read[1];				// Number of bytes to read
            byte[] _adr_write = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)startWriteAddress));
            data[12] = _adr_write[0];				// Start write address
            data[13] = _adr_write[1];				// Start write address
            byte[] _cnt_write = BitConverter.GetBytes((short)IPAddress.HostToNetworkOrder((short)numWrite));
            data[14] = _cnt_write[0];				// Number of bytes to write
            data[15] = _cnt_write[1];				// Number of bytes to write
            data[16] = (byte)(numWrite * 2);

            return data;
        }

        // ------------------------------------------------------------------------
        // Write asynchronous data
        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);
        }

        // ------------------------------------------------------------------------
        // Write asynchronous data response
        private void OnReceive(System.IAsyncResult result)
        {
            if (socketClient == null)
            {
                return;
            }
            IPEndPoint clientipe = (IPEndPoint)socketClient.RemoteEndPoint;
            if (result.IsCompleted == false)
            {
                CallException(0xFF, 0xFF, excExceptionConnectionLost, tcpSocketReviceBuffer);
            }

            ushort id = BitConverter.ToUInt16(tcpSocketReviceBuffer, 0); ;
            byte function = tcpSocketReviceBuffer[7];
            byte[] data;

            // ------------------------------------------------------------
            // Write response data
            if ((function >= fctWriteSingleCoil) && (function != fctReadWriteMultipleRegister))
            {
                data = new byte[2];
                Array.Copy(tcpSocketReviceBuffer, 10, data, 0, 2);
            }
            // ------------------------------------------------------------
            // Read response data
            else
            {
                data = new byte[tcpSocketReviceBuffer[8]];
                Array.Copy(tcpSocketReviceBuffer, 9, data, 0, tcpSocketReviceBuffer[8]);
            }
            // ------------------------------------------------------------
            // Response data is slave exception
            if (function > excExceptionOffset)
            {
                function -= excExceptionOffset;
                CallException(id, function, tcpSocketReviceBuffer[8], tcpSocketReviceBuffer);
            }
            // ------------------------------------------------------------
            // Response data is regular data
            else if (OnResponseData != null)
            {  //收到的数据打印出来
                string str = "";
                foreach (byte by in tcpSocketReviceBuffer)
                {
                    str = str + " " + by;
                    if (str.Length > 50)
                    {
                        break;
                    }
                }
                // LogUtil.info( clientipe.ToString()+"收到数据：" + str);
                OnResponseData(clientipe.ToString(), id, function, data, tcpSocketReviceBuffer);
            }
        }

        internal bool ISConnection()
        {
            if (socketClient == null)
            {
                return false;
            }
            if (socketClient.Connected == false)
            {
                return false;
            }
            return true;
        }
    }
}