namespace LSServerService
{
    using LSUtils;
    using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Threading;

    public abstract class LSASyncSocket
    {
        private byte _HandledCloseEventCounter = 0;
        private int _LastExchangeStamp = 0;
        protected int _ReceivedLen = 0;
        private int _SendedLen = 0;
        protected Socket _socket;
        protected int _socketstate = 0;
        private object[] _source;
        private int nSendLength = 0;
        public object ObjClient2Server = 2;
        public object ObjServer2Client = 1;
        protected const uint PACKETMAXLEN = 102400;
        private AutoResetEvent RevDone_Event = new AutoResetEvent(true);
        private AutoResetEvent SendDone_Event = new AutoResetEvent(true);
        protected StateObject StateObj = new StateObject();

        public event SocketCloseEventHandle SocketCloseEvent;

        protected LSASyncSocket()
        {
        }

        protected void CheckCloseState(int ErrorCode)
        {
            LSWriteLog.WriteString("RecordSocketCloseReason.log", "socket.Handle= {0},_socket.Connected= {1},ErrorCode= {2}", new object[] { this._socket.Handle, this._socket.Connected, ErrorCode });
            switch (ErrorCode)
            {
                case 10053:
                case 10054:
                case 10057:
                case 10058:
                    this.CloseSocket();
                    break;
            }
        }

        public void CloseSocket()
        {
            if (this._socketstate != 2)
            {
                try
                {
                    this._socketstate = 2;
                    if ((this._socket != null) && this._socket.Connected)
                    {
                        string str = ((IPEndPoint) this._socket.RemoteEndPoint).Port.ToString();
                        LSWriteLog.WriteLog("SocketCloseInfo.log", true, "closesocket : socketid={0}  _socketstate={1},RemotePort= {2}  ", new object[] { this._socket.Handle.ToString(), this._socketstate, str });
                        this._socket.Shutdown(SocketShutdown.Receive);
                        Thread.Sleep(1);
                        this._socket.Close();
                    }
                }
                catch (SocketException exception)
                {
                    PubUtils.WriteLog("LSASyncSocket.CloseSocket SOCKET errorcode: {0}  errormsg: {1}  _socketstate={2}", new object[] { exception.SocketErrorCode, exception, this._socketstate });
                }
                catch (Exception exception2)
                {
                    PubUtils.WriteLog("LSASyncSocket.CloseSocket error: {0}", new object[] { exception2 });
                }
                if (this.SocketCloseEvent != null)
                {
                    this.SocketCloseEvent(this);
                }
            }
        }

        protected void ContinueReceive()
        {
            try
            {
                if (((this._socket != null) && this._socket.Connected) && (this._socketstate != 2))
                {
                    this._ReceivedLen = 0;
                    if (this.StateObj.buffer.Length > this.StateObj.BufferSize)
                    {
                        this.StateObj.buffer = new byte[this.StateObj.BufferSize];
                    }
                    this.SetLastStamp();
                    this._socket.BeginReceive(this.StateObj.buffer, 0, this.StateObj.BufferSize, SocketFlags.None, new AsyncCallback(this.ReceiveCallback), this._socket);
                }
            }
            catch (Exception exception)
            {
                PubUtils.WriteLog("ReceiveCallback error: {0}", new object[] { exception });
            }
        }

        ~LSASyncSocket()
        {
            if (this.SendDone_Event != null)
            {
                this.SendDone_Event.Close();
                this.SendDone_Event = null;
            }
            if (this.RevDone_Event != null)
            {
                this.RevDone_Event.Close();
                this.RevDone_Event = null;
            }
        }

        public void HandledCloseEvent()
        {
            this._HandledCloseEventCounter = (byte) (this._HandledCloseEventCounter + 1);
        }

        protected abstract void ParseReceiveData(byte[] byteData);
        protected abstract void ReceiveCallback(IAsyncResult ar);
        protected void ReceiveReady()
        {
            this._socketstate = 1;
            this._ReceivedLen = 0;
            try
            {
                this._socket.BeginReceive(this.StateObj.buffer, 0, this.StateObj.BufferSize, SocketFlags.None, new AsyncCallback(this.ReceiveCallback), this._socket);
            }
            catch (SocketException exception)
            {
                PubUtils.WriteLog("LSASyncSocket.ReceiveReady socket error: {0}", new object[] { exception });
                this.CheckCloseState(exception.ErrorCode);
            }
            catch (Exception exception2)
            {
                PubUtils.WriteLog("LSASyncSocket.ReceiveReady error: {0}", new object[] { exception2 });
            }
        }

        public bool Send(object structObj)
        {
            byte[] byteData = PubUtils.StructToBytes(structObj);
            return this.Send(byteData);
        }

        public bool Send(byte[] byteData)
        {
            return this.Send(byteData, byteData.Length);
        }

        public bool Send(byte[] byteData, int sendLength)
        {
            int tickCount = Environment.TickCount;
            if (((this._socket == null) || !this._socket.Connected) || (this._socketstate == 2))
            {
                if (this._socket == null)
                {
                    PubUtils.WriteLog(this.ToString() + ".send 过程即将要发送数据,但是不能发出去,socket = null, _socketstate=={0}, 要发送的数据内容是:\n{1}", new object[] { this._socketstate, byteData });
                }
                else
                {
                    PubUtils.WriteLog(this.ToString() + ".send 过程即将要发送数据,但是不能发出去,socket id= {0}, socket.Connected=={1},_socketstate=={2}, 要发送的数据内容是:\n{3}", new object[] { this._socket.Handle, this._socket.Connected, this._socketstate, byteData });
                }
                return false;
            }
            this.SendDone_Event.WaitOne();
            if (((this._socket == null) || !this._socket.Connected) || (this._socketstate == 2))
            {
                this.SendDone_Event.Set();
                return false;
            }
            LSWriteLog.WriteString("SocketSendDataWaitOneTime.log", "Socket Send Data WaitOne过程等待周期  =  {0}", new object[] { Environment.TickCount - tickCount });
            this.SetLastStamp();
            this._SendedLen = 0;
            this.nSendLength = sendLength;
            try
            {
                this._socket.BeginSend(byteData, 0, sendLength, SocketFlags.None, new AsyncCallback(this.SendCallback), tickCount);
                return true;
            }
            catch (SocketException exception)
            {
                this.SendDone_Event.Set();
                PubUtils.WriteLog("LSASyncSocket.Sen SOCKET errorcode: {0}  errormsg: {1}", new object[] { exception.SocketErrorCode, exception });
                this.CheckCloseState(exception.ErrorCode);
            }
            catch (Exception exception2)
            {
                this.SendDone_Event.Set();
                PubUtils.WriteLog("LSASyncSocket.Send error: {0}", new object[] { exception2 });
            }
            return false;
        }

        private void SendCallback(IAsyncResult ar)
        {
            if (((this._socket == null) || !this._socket.Connected) || (this._socketstate == 2))
            {
                LSWriteLog.WriteTrace("{0}.SendCallback send state,_socket= {1} ,_socket.Connected= {2}, _socketstate= {3}", new object[] { this, this._socket.Handle, this._socket.Connected, this._socketstate });
                this.SendDone_Event.Set();
            }
            else
            {
                int asyncState = 2147483647;
                try
                {
                    asyncState = (int) ar.AsyncState;
                    int num2 = this._socket.EndSend(ar);
                    this._SendedLen += num2;
                    if (this.nSendLength != this._SendedLen)
                    {
                        PubUtils.WriteLog("严重错误!!!需要发送的长度是= {0},但实际发送的长度为= {1}", new object[] { this._SendedLen, this.nSendLength });
                        this.CloseSocket();
                    }
                }
                catch (SocketException exception)
                {
                    PubUtils.WriteLog("LSASyncSocket.SendCallback SOCKET errorcode: {0}  errormsg: {1}, ", new object[] { exception.SocketErrorCode, exception.Message.ToString() });
                    this.CheckCloseState(exception.ErrorCode);
                }
                catch (Exception exception2)
                {
                    if (this._socket == null)
                    {
                        PubUtils.WriteLog("LSASyncSocket.SendCallback error: {0}, _socket=null,this={1}", new object[] { exception2, this });
                    }
                    else
                    {
                        PubUtils.WriteLog("LSASyncSocket.SendCallback error: {0}, socket id={1},_socket.Connected={2},_socketstate={3},this={4}", new object[] { exception2, this._socket.Handle, this._socket.Connected, this._socketstate, this });
                    }
                }
                asyncState = Environment.TickCount - asyncState;
                LSWriteLog.WriteString("SocketSendDataCostTime.log", "Socket Send Data周期(包含WaitOne)  =  {0}", new object[] { asyncState });
                this.SendDone_Event.Set();
            }
        }

        public void SetLastStamp()
        {
            this._LastExchangeStamp = Environment.TickCount;
        }

        private void SetOptBuffer(int SendBufSize, int RevBufSize)
        {
            if (SendBufSize <= 0)
            {
                this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendBuffer, 1024);
            }
            else
            {
                this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendBuffer, SendBufSize);
            }
            if (RevBufSize <= 0)
            {
                this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, 1024);
            }
            else
            {
                this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, RevBufSize);
            }
        }

        private void SetOptKeepAlive()
        {
            uint num = 10000;
            uint num2 = 2000;
            uint structure = 0;
            byte[] array = new byte[Marshal.SizeOf(structure) * 3];
            BitConverter.GetBytes((uint) 1).CopyTo(array, 0);
            BitConverter.GetBytes(num).CopyTo(array, Marshal.SizeOf(structure));
            BitConverter.GetBytes(num2).CopyTo(array, (int) (Marshal.SizeOf(structure) * 2));
            this._socket.IOControl(IOControlCode.KeepAliveValues, array, null);
        }

        private void SetOptLinger(int nMilliSecond)
        {
            LingerOption optionValue = null;
            if (nMilliSecond <= 0)
            {
                optionValue = new LingerOption(true, 1000);
            }
            else
            {
                optionValue = new LingerOption(true, nMilliSecond);
            }
            this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, optionValue);
        }

        private void SetOptTimeOut(int nMilliSecond)
        {
            if (nMilliSecond <= 0)
            {
                this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 1000);
            }
            else
            {
                this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, nMilliSecond);
            }
        }

        public bool TimeOutCheck(int TimeOutValue)
        {
            return ((Environment.TickCount - this._LastExchangeStamp) > TimeOutValue);
        }

        public bool HandledCloseEventCounter
        {
            get
            {
                return (this._HandledCloseEventCounter > 0);
            }
        }

        public int ReceivedLen
        {
            get
            {
                return this._ReceivedLen;
            }
        }

        public int SendedLen
        {
            get
            {
                return this._SendedLen;
            }
        }

        public Socket socket
        {
            get
            {
                return this._socket;
            }
        }

        public int SocketState
        {
            get
            {
                return this._socketstate;
            }
        }

        public object[] source
        {
            get
            {
                return this._source;
            }
            set
            {
                this._source = value;
            }
        }

        public delegate void SocketCloseEventHandle(LSASyncSocket AsyncSocket);

        protected class StateObject
        {
            private const int _BufferSize = 10240;
            public byte[] buffer = new byte[10240];

            public void ExtentBuffer()
            {
                int num = this.buffer.Length * 2;
                byte[] dst = new byte[num];
                Buffer.BlockCopy(this.buffer, 0, dst, 0, this.buffer.Length);
                this.buffer = dst;
            }

            public int BufferSize
            {
                get
                {
                    return 10240;
                }
            }
        }
    }
}