using System;
using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using Lskj.Util;

namespace Lskj.AttachStart.Service
{
    public class LSSocket : LSASyncSocket
    {
        private int _selDirectoryId = 0;
        private string _ServerIP = "";
        private uint _ServerPort = 0;
        private const int FIONREAD = 1074030207;
        private uint m_dwUserId = 0;
        private string m_remoteIP;
        private int m_remotePort;

        public event ParseReceiveDataEventHandle ParseReceiveDataEvent;

        public LSSocket()
        {
            base._socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }

        public void clientAdd(Socket s)
        {
            base._socket = s;
            base.ReceiveReady();
        }

        public void Connect(string strHost, uint nPort)
        {
            try
            {
                this.ServerIP = strHost;
                this.ServerPort = nPort;
                IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse(strHost), (int)nPort);
                LogHelper.Instance.WriteLog(string.Format("begin connect server ip={0}, port={1}.", strHost, nPort));
                base._socket.BeginConnect(remoteEP, new AsyncCallback(this.ConnectCallback), base._socket);
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
            }
        }

        private void ConnectCallback(IAsyncResult ar)
        {
            try
            {
                ((Socket)ar.AsyncState).EndConnect(ar);
                LogHelper.Instance.WriteLog(string.Format("connected server ip={0} port={1} success.", this.ServerIP, this.ServerPort));
                base.ReceiveReady();
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
            }
        }

        protected override void ParseReceiveData(byte[] byteData)
        {
            this.ParseReceiveDataEvent(this, byteData);
        }

        protected override void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                LogHelper.Instance.WriteLog(this.ToString() + ".ReceiveCallback is running socketid = " + base._socket.Handle);
                if (!((base._socket != null) && base._socket.Connected))
                {
                    base.CloseSocket();
                    return;
                }
                LogHelper.Instance.WriteLog(this.ToString() + ".ReceiveCallback socketid = " + base._socket.Handle + "  bytesAvailable is " + base._socket.Available.ToString() + "  _socketstate=" + this._socketstate.ToString());
                if ((base._socket.Available == 0) && (base._socketstate == 2))
                {
                    return;
                }
                int count = base._socket.EndReceive(ar);
                byte[] dst = new byte[count];
                Buffer.BlockCopy(base.StateObj.buffer, 0, dst, 0, count);
                if (count > 0)
                {
                    int num3;
                    base._ReceivedLen += count;
                    for (int i = 0; i < base._ReceivedLen; i += num3)
                    {
                        bool flag = (base._ReceivedLen - i) <= 8;
                    Label_0158:
                        if (flag)
                        {
                            if ((base._ReceivedLen - i) < base.StateObj.buffer.Length)
                            {
                                Buffer.BlockCopy(base.StateObj.buffer, i, base.StateObj.buffer, 0, base._ReceivedLen - i);
                            }
                            else
                            {
                                base.StateObj.ExtentBuffer();
                            }
                            base._ReceivedLen -= i;
                            base._socket.BeginReceive(base.StateObj.buffer, base._ReceivedLen, base.StateObj.buffer.Length - base._ReceivedLen, SocketFlags.None, new AsyncCallback(this.ReceiveCallback), base._socket);
                            return;
                        }
                        num3 = BitConverter.ToInt32(base.StateObj.buffer, 4 + i);
                        if ((num3 + i) > base._ReceivedLen)
                        {
                            flag = true;
                            goto Label_0158;
                        }
                        byte[] buffer2 = new byte[num3];
                        Buffer.BlockCopy(base.StateObj.buffer, i, buffer2, 0, num3);
                        if (num3 > 102400)
                        {
                            byte[] buffer3 = new byte[base._ReceivedLen];
                            Buffer.BlockCopy(base.StateObj.buffer, 0, buffer3, 0, base._ReceivedLen);
                            LogHelper.Instance.WriteLog(string.Format("received proxy data is unnormal! socketid= {0} and a packet data is :{1} and whole data is :{2}", base._socket.Handle, buffer2, buffer3));
                        }
                        else
                        {
                            this.ParseReceiveData(buffer2);
                        }
                    }
                }
                else
                {
                    base.CloseSocket();
                }
            }
            catch (Exception ex)
            {
                LogHelper.Instance.WriteError(ex);
            }
            base.ContinueReceive();
        }

        public void reConnect()
        {
            base._socketstate = 0;
            this.Connect(this.m_remoteIP, (uint)this.m_remotePort);
        }

        public uint dwUserId
        {
            get
            {
                return this.m_dwUserId;
            }
            set
            {
                this.m_dwUserId = value;
            }
        }

        public string remoteIP
        {
            get
            {
                return this.m_remoteIP;
            }
            set
            {
                this.m_remoteIP = value;
            }
        }

        public int remotePort
        {
            get
            {
                return this.m_remotePort;
            }
            set
            {
                this.m_remotePort = value;
            }
        }

        public int selDirectoryId
        {
            get
            {
                return this._selDirectoryId;
            }
            set
            {
                this._selDirectoryId = value;
            }
        }

        public string ServerIP
        {
            get
            {
                return this._ServerIP;
            }
            set
            {
                this._ServerIP = value;
            }
        }

        public uint ServerPort
        {
            get
            {
                return this._ServerPort;
            }
            set
            {
                this._ServerPort = value;
            }
        }

        public delegate void ParseReceiveDataEventHandle(LSSocket ProxySocket, byte[] byteData);
    }
}