LoginClient.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace CMP
{
    public delegate void ProcessCompleteDel(Headers header, ErrorCodes errorCode);
    public delegate void ProcessCompleteDelLogin(Headers header, ErrorCodes errorCode, String userid);
    public delegate void ProcessCompleteDel1(Headers header, ErrorCodes errorCode, string[] friendL);
    public delegate void ProcessChatWindow(Headers header, ErrorCodes errorCode);
    internal struct LoginArgs
    {
        public string Username;
        public string Password;
        public Headers Header;
        public ProcessCompleteDelLogin Callback;


        public LoginArgs(Headers header, string username, string password, ProcessCompleteDelLogin callback)
        {
            Username = username;
            Password = password;
            Header = header;
            Callback = callback;
        }

    }

    internal struct messageFriendArgs
    {
        public string Username;
        public Headers Header;
        public ProcessChatWindow Callback;
        public string Text;

        public messageFriendArgs(Headers header, string username, string text, ProcessChatWindow callback)
        {
            Username = username;
            Header = header;
            Text = text;
            Callback = callback;
        }

    }

    internal struct sendHBArgs
    {
        public string Username;
        public Headers Header;
        public ProcessCompleteDel Callback;

        public sendHBArgs(Headers header, string username, ProcessCompleteDel callback)
        {
            Username = username;
            Header = header;
            Callback = callback;
        }

    }

    internal struct friendsArgs
    {
        public string Userid;
        public Headers Header;
        public ProcessCompleteDel1 Callback;

        public friendsArgs(Headers header, string userid, ProcessCompleteDel1 callback)
        {
            Userid = userid;
            Header = header;
            Callback = callback;
        }

    }


    internal struct registerArgs
    {
        public string Username;
        public string Password;
        public string Email;
        public Headers Header;
        public ProcessCompleteDel Callback;

        public registerArgs(Headers header, string username, string password, string email, ProcessCompleteDel callback)
        {
            Username = username;
            Password = password;
            Email = email;
            Header = header;
            Callback = callback;
        }

    }

    internal struct LogoutArgs
    {
        public string Username;
        public Headers Header;
        public ProcessCompleteDel Callback;
        public LogoutArgs(Headers header, string username, ProcessCompleteDel callback)
        {
            Username = username;
            Header = header;
            Callback = callback;
        }
    }

    public class LoginClient
    {
        public const int PORT = 25327;
        Socket sck;
        //Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        private byte[] buffer = new byte[512];
        public LoginClient()
        {
            //sck.Connect(ServerInfo.Server, ServerInfo.Port);

            Listener listener = new Listener();
            listener.Accepted += listener_Accepted;
            listener.Start(PORT);


        }

        private void listener_Accepted(object sender, Socket e)
        {
            Console.WriteLine("Message Recieved");
        }

        public void Login(string username, string password, ProcessCompleteDelLogin callback)
        {
            LoginArgs args = new LoginArgs(Headers.Login, username, password, callback);
            ThreadPool.QueueUserWorkItem(new WaitCallback(process), args);
        }

        public void chatFriend(string username, string text, ProcessChatWindow callback)
        {
            Console.WriteLine("U: {0}", username);
            messageFriendArgs args = new messageFriendArgs(Headers.sendMessage, username, text, callback);
            ThreadPool.QueueUserWorkItem(new WaitCallback(sendMsg), args);
        }

        public void sendHeartBeat(string username, ProcessCompleteDel callback)
        {
            Console.WriteLine("U111: {0}", username);
            sendHBArgs args = new sendHBArgs(Headers.sendHeartBeat, username, callback);
            ThreadPool.QueueUserWorkItem(new WaitCallback(heartbeatProc), args);
        }

        public void friendsList(string userid, ProcessCompleteDel1 callback)
        {
            friendsArgs args = new friendsArgs(Headers.friendsList, userid, callback);
            ThreadPool.QueueUserWorkItem(new WaitCallback(processF), args);
        }
        /**
        public void StatusUpdate(string username, string status, ProcessCompleteDel callback)
        {
            LoginArgs args = new LoginArgs(Headers.statusUpdate, username, status, callback);
            ThreadPool.QueueUserWorkItem(new WaitCallback(process), args);
        } **/

        public void Register(string username, string password, string email, ProcessCompleteDel callback)
        {

            registerArgs args = new registerArgs(Headers.Register, username, password, email, callback);
            ThreadPool.QueueUserWorkItem(new WaitCallback(processRegister), args);
        }

        public void Logout(string username, ProcessCompleteDel callback)
        {
            LogoutArgs args = new LogoutArgs(Headers.Logout, username, callback);
            ThreadPool.QueueUserWorkItem(new WaitCallback(processL), args);
        }

        private void processRegister(object o)
        {
            registerArgs args = (registerArgs)o;

            //Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                //sck.Connect(ServerInfo.Server, ServerInfo.Port);

                PacketWriter pw = new PacketWriter();
                pw.Write((ushort)args.Header);
                pw.Write(args.Username);
                pw.Write(args.Password);
                pw.Write(args.Email);

                byte[] data = pw.GetBytes();

                sck.Send(data, 0, data.Length, SocketFlags.None);

                sck.ReceiveTimeout = 18000;

                sck.Receive(buffer, 0, buffer.Length, SocketFlags.None);

                PacketReader pr = new PacketReader(buffer);

                Headers header = (Headers)pr.ReadUInt16();
                ErrorCodes error = (ErrorCodes)pr.ReadUInt16();

                args.Callback(header, error);

            }
            catch
            {
                args.Callback(args.Header, ErrorCodes.Error);
            }
            finally
            {
                //sck.Close();
            }
        }

        private void sendMsg(object o)
        {
            messageFriendArgs args = (messageFriendArgs)o;
            //Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                //sck.Connect(ServerInfo.Server, ServerInfo.Port);

                Client server = new Client(sck);
                PacketWriter pw = new PacketWriter();
                pw.Write((ushort)args.Header);
                pw.Write(args.Username);
                pw.Write(args.Text);

                Console.WriteLine("User: {0}", args.Username);

                byte[] data = pw.GetBytes();

                sck.Send(data, 0, data.Length, SocketFlags.None);

                sck.ReceiveTimeout = 18000;

                sck.Receive(buffer, 0, buffer.Length, SocketFlags.None);

                PacketReader pr = new PacketReader(buffer);

                Headers header = (Headers)pr.ReadUInt16();
                ErrorCodes error = (ErrorCodes)pr.ReadUInt16();


                switch (header)
                {
                    case Headers.recieveMessage:
                        {
                            recieveMsg(server, pr.ReadString(), pr.ReadString());
                        }
                        break;
                }



                args.Callback(header, error);

            }
            catch
            {
                args.Callback(args.Header, ErrorCodes.Error);
            }
            finally
            {
                //sck.Close();
            }

        }

        private void process(object o)
        {
            LoginArgs args = (LoginArgs)o;

            //Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                //sck.Connect(ServerInfo.Server, ServerInfo.Port);

                PacketWriter pw = new PacketWriter();
                pw.Write((ushort)args.Header);
                pw.Write(args.Username);
                pw.Write(args.Password);

                byte[] data = pw.GetBytes();

                sck.Send(data, 0, data.Length, SocketFlags.None);

                sck.ReceiveTimeout = 180000;

                sck.Receive(buffer, 0, buffer.Length, SocketFlags.None);

                PacketReader pr = new PacketReader(buffer);

                Headers header = (Headers)pr.ReadUInt16();
                ErrorCodes error = (ErrorCodes)pr.ReadUInt16();
                String Userid = pr.ReadString();
                args.Callback(header, error, Userid);

            }
            catch
            {
                args.Callback(args.Header, ErrorCodes.Error,null);
            }
            finally
            {
                //sck.Close();
            }
        }

        public void heartbeatProc(object o)
        {
            Thread heartbeatThread = new Thread(heartbeatProc) { IsBackground = true };

            while (true)
            {
                //Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                sendHBArgs args = (sendHBArgs)o;
                try
                {

                    //sck.Connect(ServerInfo.Server, ServerInfo.Port);

                    Client server = new Client(sck);
                    PacketWriter pw = new PacketWriter();
                    pw.Write((ushort)args.Header);
                    pw.Write(args.Username);

                    Console.WriteLine("User: {0}", args.Username);

                    byte[] data = pw.GetBytes();

                    sck.Send(data, 0, data.Length, SocketFlags.None);

                    sck.ReceiveTimeout = 18000;

                    sck.Receive(buffer, 0, buffer.Length, SocketFlags.None);

                    PacketReader pr = new PacketReader(buffer);

                    Headers header = (Headers)pr.ReadUInt16();
                    ErrorCodes error = (ErrorCodes)pr.ReadUInt16();

                    args.Callback(header, error);

                }
                catch
                {

                    args.Callback(args.Header, ErrorCodes.Error);
                }
                finally
                {

                }

                Thread.Sleep(TimeSpan.FromMinutes(1)); //Or just 60000
            }
        }

        private void processF(object o)
        {
            friendsArgs args = (friendsArgs)o;

            //Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                //sck.Connect(ServerInfo.Server, ServerInfo.Port);

                PacketWriter pw = new PacketWriter();
                pw.Write((ushort)args.Header);
                pw.Write(args.Userid);

                Console.WriteLine("Sending FL Request. "+ (ushort)args.Header);

                byte[] data = pw.GetBytes();

                sck.Send(data, 0, data.Length, SocketFlags.None);

                sck.ReceiveTimeout = 18000;

                sck.Receive(buffer, 0, buffer.Length, SocketFlags.None);

                PacketReader pr = new PacketReader(buffer);

                Headers header = (Headers)pr.ReadUInt16();
                ErrorCodes error = (ErrorCodes)pr.ReadUInt16();

                string[] username = pr.ReadStringArray(); //Read the

                args.Callback(header, error, username);

            }
            catch
            {
                args.Callback(args.Header, ErrorCodes.Error, null);
            }
            finally
            {
                //sck.Close();
            }
        }

        static void recieveMsg(Client client, string username, string text)
        {
            Console.WriteLine("Message recieved from users !!!!");
        }

        private void processL(object o)
        {
            LogoutArgs args = (LogoutArgs)o;

            //Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            try
            {
                //sck.Connect(ServerInfo.Server, ServerInfo.Port);

                PacketWriter pw = new PacketWriter();
                pw.Write((ushort)args.Header);
                pw.Write(args.Username);

                byte[] data = pw.GetBytes();

                sck.Send(data, 0, data.Length, SocketFlags.None);

                sck.ReceiveTimeout = 8000;

                sck.Receive(buffer, 0, buffer.Length, SocketFlags.None);

                PacketReader pr = new PacketReader(buffer);

                Headers header = (Headers)pr.ReadUInt16();
                ErrorCodes error = (ErrorCodes)pr.ReadUInt16();

                args.Callback(header, error);

            }
            catch
            {
                args.Callback(args.Header, ErrorCodes.Error);
            }
            finally
            {
                //sck.Close();
            }
        }

    }
}