using System;
using System.Threading;								// Sleeping
using System.Net;									// Used to local machine info
using System.Net.Sockets;							// Socket namespace
using System.Collections;
using System.Text;

#region Socketcommunication
namespace NetworkClient
{
    class CommunicationClient
    {
        public delegate void mEventHandler(byte[] Message);
        public delegate void mLogEventHandler(string Message);
        public event mLogEventHandler NewLogEvent;
        public event mEventHandler NewMessageEvent;
        public event EventHandler DisconnectEvent;
        public event EventHandler ConnectEvent;

        //private Timer LivecheckTimer = new Timer(();
        private Socket m_sock;						// Server connection
        private byte[] m_byBuff = new byte[10000];	// Recieved data buffer
        private int _Port = 1230;
        private string _ClientIP = "127.0.0.1";
        private string _myIP;
        private int _AliveTimeout;
        private Thread LiveCheckThread = null;
        private bool _Livecheck = true;
        private bool Exit = false;
        public int Port
        {
            set { _Port = value; }
            get { return _Port; }
        }
        public int AliveTimOut
        {
            set  { _AliveTimeout = value; }
        }
        public string myIP
        {
            set { _myIP = value; }
            get { return _myIP; }
        }
        public string ServerIP
        {
            set { _ClientIP = value; }
            get { return _ClientIP; }
        }

        public bool LiveCheck
        {
            set { _Livecheck = value; }
        }
        public bool EndClient
        {
            set { Exit = value; }
        }


        public void StartClient()
        {
            try
            {
                // Close the socket if it is still open
                if (m_sock != null && m_sock.Connected)
                {
                    m_sock.Shutdown(SocketShutdown.Both);
                    System.Threading.Thread.Sleep(10);
                    m_sock.Close();
                }

                // Create the socket object
                m_sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
      
                // Define the Server address and port
                IPEndPoint epServer = new IPEndPoint(IPAddress.Parse(_ClientIP), Port);

                // Connect to the server blocking method and setup callback for recieved data
                // m_sock.Connect( epServer );
                // SetupRecieveCallback( m_sock );

                // Connect to server non-Blocking method
                m_sock.Blocking = false;
                m_sock.NoDelay = true;
                AsyncCallback onconnect = new AsyncCallback(OnConnect);
                m_sock.BeginConnect(epServer, onconnect, m_sock);
                LiveCheckThread = new Thread(new ThreadStart(LiveCheckWorkerThread));

                // Ermittlúng der eigenen IP-Adresse
                //IPHostEntry IPCheck = Dns.GetHostByName(Dns.GetHostName());
                IPHostEntry IPCheck = Dns.GetHostEntry(Dns.GetHostName());
                _myIP = IPCheck.AddressList[0].ToString();

            }
            catch (Exception ex)
            {

                OnNewLog("Error", "Server Connect failed!" + ex.Message);
                RestartServer();
            }
        }

        private void OnConnect(IAsyncResult ar)
        {
            // Socket was the passed in object
            Socket sock = (Socket)ar.AsyncState;

            // Check if we were sucessfull
            try
            {
                //sock.EndConnect( ar );
                if (sock.Connected)
                {
                    SetupRecieveCallback(sock);
                    OnNewLog("", "Connected to Server...");
                    onConnect();
                    Thread.Sleep(500);

                }
                else
                {
                    OnNewLog("Socket", "Unable to connect to remote machine Connect Failed!");
                    RestartServer();
                }
            }
            catch (Exception ex)
            {
                OnNewLog("Socket", "Unusual error during Connect! " + ex.Message);
                RestartServer();
            }
        }


        public void OnRecievedData(IAsyncResult ar)
        {
            // Socket was the passed in object
            Socket sock = (Socket)ar.AsyncState;

            // Check if we got any data
            try
            {
                int nBytesRec = sock.EndReceive(ar);
                if (nBytesRec > 0)
                {
                    _Livecheck = true;
                    byte[] MessageArray = new byte[nBytesRec];
                    Array.Copy(m_byBuff, 0, MessageArray, 0, nBytesRec);
                    // Wrote the data to the Queue
                    OnNewMessage(MessageArray);

                    // If the connection is still usable restablish the callback
                    SetupRecieveCallback(sock);
                }
                else
                {
                    // If no data was recieved then the connection is probably dead
                    OnNewLog("Socket", String.Format("Client {0}, disconnected", sock.RemoteEndPoint));
                    sock.Shutdown(SocketShutdown.Both);
                    onDisconnect();
                    //sock.Close();
                    RestartServer();
                }
            }
            catch (Exception ex)
            {
                OnNewLog("Socket", "Unusual error druing Recieve! " + ex.Message);
                onDisconnect();
                RestartServer();
            }
        }

        /// <summary>
        /// Setup the callback for recieved data and loss of conneciton
        /// </summary>
        public void SetupRecieveCallback(Socket sock)
        {
            try
            {
                AsyncCallback recieveData = new AsyncCallback(OnRecievedData);
                sock.BeginReceive(m_byBuff, 0, m_byBuff.Length, SocketFlags.None, recieveData, sock);
            }
            catch (Exception ex)
            {
                OnNewLog("Socket", "Setup Recieve Callback failed! " + ex.Message);
                onDisconnect();
                RestartServer();
            }
        }
        private void RestartServer()
        {
            if (!m_sock.Connected)
            {
                OnNewLog("Comunication", "Restart Connection ");
                try
                {
                    Exit = true;
                    try
                    {
                        m_sock.Disconnect(true);
                    }
                    catch { };
                    Thread.Sleep(10000);
                    LiveCheckThread = null;
                    this.StartClient();
                }
                catch (SocketException se)
                {
                    OnNewLog("RestartServer", "Error: " + se.Message);
                }
            }
        }
        private void LiveCheckWorkerThread()
        {
            int counter = 0;
            while (!Exit)
            {
                counter += 1;
                if (Exit) break;
                if (counter >= 120)
                {
                    if (!_Livecheck) RestartServer();
                    counter = 0;
                    _Livecheck = false;
                    OnNewLog("Livecheckthread", "Set Livecheck = false");
                }
                Thread.Sleep(500);
            }
            OnNewLog("Livecheck", "Thread stopped");
        }
        protected virtual void OnNewLog(string LogArg, string Message)
        {
            mLogEventHandler newLogMessage = NewLogEvent;
            if (newLogMessage != null)
            {
                newLogMessage(LogArg + ": " + Message);
            }
        }
        protected virtual void OnNewMessage(byte[] Message)
        {
            mEventHandler newMessage = NewMessageEvent;
            if (newMessage != null)
            {
                newMessage(Message);
            }
        }

        protected virtual void onDisconnect()
        {
            EventHandler Disconnect = DisconnectEvent;
                ;
                if (DisconnectEvent != null)
            {
                Disconnect(null,null);
            }
        }

        protected virtual void onConnect()
        {
            EventHandler Connect = ConnectEvent;
            ;
            if (ConnectEvent != null)
            {
                Connect(null, null);
            }
        }

        public bool Send_Data(byte[] OutByte)
        {
            try
            {
                if (m_sock != null) m_sock.Send(OutByte);
                return true;
            }
            catch (SocketException se)
            {
                OnNewLog("Socket", se.Message);
                return false;
            }
        }
        public bool Send_Data(string OutString)
        {
            byte[] SendData = Encoding.UTF8.GetBytes(OutString + "\n");
            try
            {
                if (m_sock != null) m_sock.Send(SendData);
                return true;
            }
            catch (SocketException se)
            {
                OnNewLog("Socket", se.Message);
                return false;
            }
        }

   }
}
#endregion