using System;
using System.Threading;
using System.Net;
using System.Net.Sockets;

using IMDrawLibrary;
using IMDrawServer;

namespace IMDrawServer
{
    public class SocketServer
    {
        TcpListener listener;
        IPAddress ipaAddress;
        int iPort;

        public delegate void ListenForMessageDelegate(Client client);
        public delegate void ClientConnectedEventHandler(object sender, Client client);
        public delegate void ClientDisconnectingEventHandler(object sender, string clientName);
        public delegate void MessageReceivedEventHandler(object sender, Message clientMessage);

        public event ClientConnectedEventHandler ClientConnected;
        public event ClientDisconnectingEventHandler ClientDisconnecting;
        public event MessageReceivedEventHandler MessageReceived;

        Thread thrListenForClients;

        ListenForMessageDelegate listenForMessageDelegate;

        bool bListenForClients;

        public SocketServer(string ipAddress, string port)
        {
            ipaAddress = IPAddress.Parse(ipAddress);
            iPort = int.Parse(port);

            IPEndPoint endPoint
                = new IPEndPoint(ipaAddress, iPort);

            listener = new TcpListener(endPoint);
            listener.Start();
        }

        public IPAddress SocketIPAddress
        {
            get { return ipaAddress; }
        }
        public int Port
        {
            get { return iPort; }
        }

        public void Listen()
        {
            thrListenForClients = new Thread(new ThreadStart(ListenForClients));
            thrListenForClients.Start();
        }

        public void Stop()
        {
            listener.Stop();
        }

        private void ListenForClients()
        {
            bListenForClients = true;

            while (bListenForClients)
            {
                Client acceptClient = new Client();
                try
                {
                    acceptClient.Socket = listener.AcceptTcpClient();

                    listenForMessageDelegate
                        = new ListenForMessageDelegate(ListenForMessages);

                    listenForMessageDelegate.BeginInvoke
                        (acceptClient, new AsyncCallback(ListenForMessagesCallback), "Completed");
                }
                catch (Exception)
                {
                    bListenForClients = false;
                }
            }
        }

        private void ListenForMessages(Client client)
        {
            bool connected = false;
            bool stop = false;
            while (!stop)
            {
                if (client.Socket.Connected)
                {
                    NetworkStream stream = client.Socket.GetStream();
                    byte[] bytAcceptMessage = new byte[IMDrawLibrary.Message.Size];
                    stream.Read(bytAcceptMessage, 0, bytAcceptMessage.Length);

                    Message message = new IMDrawLibrary.Message(bytAcceptMessage, IMDrawLibrary.Version.Server);
                    if (message.MessageCommand.Equals(Command.Login))
                    {
                        if (ClientConnected != null)
                        {
                            client.Name = message.Sender;
                            connected = true;
                            ClientConnected(this, client);
                        }
                    }
                    if (message.MessageCommand.Equals(Command.Message))
                    {
                        if (MessageReceived != null)
                        {
                            MessageReceived(this, message);
                        }
                    }
                    if (message.MessageCommand.Equals(Command.Logout))
                    {
                        if (ClientDisconnecting != null)
                        {
                            ClientDisconnecting(this, message.Sender);
                        }
                    }
                }
                else
                {
                    if (connected)
                    {
                        ClientDisconnecting(this, client.Name);
                        stop = true;
                    }
                }
            }
        }

        private void ListenForMessagesCallback(IAsyncResult ar)
        {
//            try
//            {
//                listenForMessageDelegate.EndInvoke(ar);
//            }
//            catch (Exception ex)
//            {
//                Console.WriteLine("Error in ListenForMessagesCallback: " + ex.Message);
//                Thread.CurrentThread.Abort();
//            }
        }
    }
}