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

namespace WhisperServer
{
    class Program
    {
        static Socket sv = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        static IPEndPoint ep = new IPEndPoint(IPAddress.Any, 9647);
        static Hashtable users = new Hashtable();
        static List<string> queue = new List<string>();
        static string motd = "";
        static bool newmotd = false;
        static bool closing = false;
        static bool newusers = false;
        static Thread lst;
        static Thread msg;
        static void Main(string[] args)
        {
            Info("Starting server.");
            sv.Bind(ep);
            sv.Listen(5);
            lst = new Thread(new ThreadStart(Listener));
            lst.Start();
            msg = new Thread(new ThreadStart(MsgHandler));
            msg.Start();
            motd = GetMOTD();
            Info("Ready!");
            while (true)
            {
                ServerCommand com = new ServerCommand(Console.ReadLine());
                switch (com.CommandName.ToLower())
                {
                    case "stop":
                        closing = true;
                        break;
                    case "say":
                        ServerCommand c2 = new ServerCommand(com.CommandString, 0);
                        queue.Add("[CONSOLE] " + c2.Parameters[0]);
                        Chat("[CONSOLE] " + c2.Parameters[0]);
                        break;
                    case "topic":
                        #region Topic
                            ServerCommand c3 = new ServerCommand(com.CommandString, 0);
                            motd = c3.Parameters[0];
                            SaveMOTD(motd);
                            newmotd = true;
                        #endregion
                        break;
                    case "users":
                        #region Userlist
                        if (users.Count > 0)
                        {
                            string people = "";
                            foreach (Client c in users)
                            {
                                people += c.name + ", ";
                            }
                            people = Split(people, 0, people.Length - 3);
                            Info("User list: " + people);
                        }
                        else
                        {
                            Info("There are no users currently connected.");
                        }
                        #endregion
                        break;
                    default:
                        Error("Invalid command.");
                        break;
                }
            }
        }
        static void Info(string message)
        {
            Console.WriteLine("[INFO] " + message);
        }
        static void Error(string message)
        {
            Console.WriteLine("[ERROR] " + message);
        }
        static void Warning(string message)
        {
            Console.WriteLine("[WARNING] " + message);
        }
        static void Chat(string message)
        {
            Console.WriteLine("[CHAT] " + message);
        }
        static void Listener()
        {
            while (true)
            {
                if (sv.Poll(-1, SelectMode.SelectRead))
                {
                    Thread a = new Thread(new ParameterizedThreadStart(Accepter));
                    a.Start(sv.Accept());
                }
            }
        }
        static void MsgHandler()
        {
            while (true)
            {
                while (!closing && queue.Count == 0 && !newusers && !newmotd)
                {
                    Thread.Sleep(1);
                }
                if (closing)
                {
                    Info("Shutting down server.");
                    Thread.Sleep(1000);
                    if (users.Count > 0)
                    {
                        foreach (Client c in users)
                        {
                            try
                            {
                                byte[] packet = CreatePacket(ServerPacketType.Shutdown, "");
                                c.sock.Send(packet);
                                DisconnectUser(c);
                            }
                            catch
                            {
                                Error("Couldn't disconnect user " + c.name + ".");
                            }
                            finally
                            {
                            }
                        }
                        users.Clear();
                    }
                    Environment.Exit(0);
                }
                if (queue.Count > 0)
                {
                    foreach (Client c in users)
                    {
                        try
                        {
                            foreach (string s in queue)
                            {
                                byte[] m = CreatePacket(ServerPacketType.ChatPost, s);
                                c.sock.Send(m);
                                Chat(s);
                            }
                        }
                        catch (Exception e)
                        {
                            Error("Server error occured with user " + c.name + ". Exception data: " + e);
                            Info("Disconnecting user " + c.name + " from server.");
                            queue.Add("[INFO] " + c.name + " has been disconnected due to an internal server error.");
                            DisconnectUser(c);
                            users.Remove(c.name);
                            newusers = true;
                        }
                        finally
                        {
                        }
                    }
                    queue.Clear();
                }
                if (newusers)
                {
                    newusers = false;
                    string temp = "";
                    foreach (Client c in users)
                    {
                        temp += GetRankSymbol(c.rank) + c.name;
                        temp += " ";
                    }
                    temp = Split(temp, 0, temp.Length - 2);
                    byte[] u = CreatePacket(ServerPacketType.UserList, temp);
                    foreach (Client c in users)
                    {
                        try
                        {
                            c.sock.Send(u);
                        }
                        catch (Exception e)
                        {
                            Error("Server error occured with user " + c.name + ". Exception data: " + e);
                            Info("Disconnecting user " + c.name + " from server.");
                            queue.Add("[INFO] " + c.name + " has been disconnected due to an internal server error.");
                            DisconnectUser(c);
                            users.Remove(c.name);
                            newusers = true;
                        }
                        finally
                        {
                        }
                    }
                }
                if (newmotd)
                {
                    newmotd = false;
                    foreach (Client c in users)
                    {
                        try
                        {
                                byte[] m = CreatePacket(ServerPacketType.MOTD, motd);
                                c.sock.Send(m);
                        }
                        catch (Exception e)
                        {
                            Error("Server error occured with user " + c.name + ". Exception data: " + e);
                            Info("Disconnecting user " + c.name + " from server.");
                            queue.Add("[INFO] " + c.name + " has been disconnected due to an internal server error.");
                            DisconnectUser(c);
                            users.Remove(c.name);
                            newusers = true;
                        }
                        finally
                        {
                        }

                    }
                    Info("The topic has been changed to \"" + motd + "\".");
                }

            }
        }
        static void Accepter(object socket)
        {
            Socket sock = (Socket)socket;
            Client c = new Client();
            IPAddress sockip = ((IPEndPoint)sock.RemoteEndPoint).Address;
            string error = "";
            try
            {
                bool invalid = false;
                byte[] req1 = CreatePacket(ServerPacketType.RequestUsername, " ");
                sock.Send(req1);
                if (sock.Poll(5000000, SelectMode.SelectRead))
                {
                    if (sock.Available > 0)
                    {
                        int len = 0;
                        byte[] data = new byte[sock.Available];
                        sock.Receive(data);
                        MemoryStream ns = new MemoryStream(data);
                        if (ns.Length > 4)
                        {
                            byte[] l = new byte[4];
                            ns.Read(l, 0, 4);
                            len = BitConverter.ToInt32(l, 0);
                            byte[] dat = new byte[len + 4];
                            ns.Position -= 4;
                            ns.Read(dat, 0, len);
                            ClientPacket cp = ClientPacket.Parse(dat);
                            if (cp != null)
                            {
                                if (cp.PacketType == ClientPacketType.Username && cp.Data.Length > 0)
                                {
                                    c.name = cp.Data;
                                }
                                else
                                {
                                    invalid = true;
                                    error = "Wrong packet signature";
                                }
                            }
                            else
                            {
                                invalid = true;
                                error = "Corrupt packet";
                            }
                        }
                        else
                        {
                            invalid = true;
                            error = "Corrupt packet";
                        }
                        ns.Close();
                    }
                    else
                    {
                        invalid = true;
                        error = "No data available";
                    }
                    // Check if this user is banned?
                    if (!invalid)
                    {
                        List<Ban> banlist = GetBanlist();
                        if (banlist != null)
                        {
                            foreach (Ban b in banlist)
                            {
                                if (sockip == b.IP || c.name == b.UserName)
                                {
                                    // The 6 lines of code sure to piss anybody off
                                    byte[] rejban = CreatePacket(ServerPacketType.Rejected, "[ERROR] Rejected: You are banned from this server!");
                                    sock.Send(rejban);
                                    sock.Shutdown(SocketShutdown.Both);
                                    sock.Close();
                                    invalid = true;
                                    error = "Banned user";
                                    break;
                                }
                            }
                        }
                    }
                    //Check user rank
                    if (!invalid)
                    {
                        List<UserSpec> userlist = GetUserSpeclist();
                        if (userlist != null)
                        {
                            foreach (UserSpec spec in userlist)
                            {
                                if (sockip == IPAddress.Parse("127.0.0.1") || sockip == IPAddress.Parse("192.168.1.1"))
                                {
                                    c.rank = Rank.Host;
                                }
                                else if (sockip == spec.IP)
                                {
                                    c.rank = spec.r;
                                    break;
                                }
                            }
                        }
                        c.sock = sock;
                        string nn = c.name;
                        while (users.ContainsKey(nn))
                        {
                            nn += "_";
                        }
                        c.name = nn;
                        c.sock.Send(CreatePacket(ServerPacketType.Accepted, ""));
                        users.Add(c.name, c);
                        newusers = true;
                    }
                }
                else
                {
                    invalid = true;
                    error = "Userame request not answered after 5 seconds";
                }
                if (invalid)
                {
                    Warning(sockip.ToString() + " failed to connect to the server. (" + error + ")");
                    sock.Shutdown(SocketShutdown.Both);
                    sock.Close();

                }
            }
            catch (Exception ex)
            {
                Error(sockip.ToString() + " could not be connected to the server. Exception: " + ex.Message);
                sock.Shutdown(SocketShutdown.Both);
                sock.Close();
            }
        }
        static void ClientThread(object cl)
        {
            Client c = (Client)cl;
            while (true)
            {
                try
                {
                    bool invalid = false;
                    if (c.sock.Poll(-1, SelectMode.SelectRead))
                    {
                        if (c.sock.Available > 0)
                        {
                            int len = 0;
                            byte[] data = new byte[c.sock.Available];
                            c.sock.Receive(data);
                            MemoryStream ns = new MemoryStream(data);
                            if (ns.Length > 4)
                            {
                                while (ns.Position < ns.Length)
                                {
                                    if (invalid)
                                    {
                                        break;
                                    }
                                    byte[] l = new byte[4];
                                    ns.Read(l, 0, 4);
                                    len = BitConverter.ToInt32(l, 0);
                                    byte[] dat = new byte[len + 4];
                                    ns.Position -= 4;
                                    ns.Read(dat, 0, len + 4);
                                    ClientPacket cp = ClientPacket.Parse(dat);
                                    if (cp != null)
                                    {
                                        //Process packet here
                                        switch (cp.PacketType)
                                        {
                                            case ClientPacketType.ChatPost:
                                                ChatCommand com = new ChatCommand(cp.Data);
                                                if (!com.Invalid)
                                                {
                                                    switch (com.CommandName.ToLower())
                                                    {
                                                        case "me":
                                                            #region /me
                                                            if (c.rank != Rank.Troll)
                                                            {
                                                                ChatCommand c2 = new ChatCommand(cp.Data, 0);
                                                                queue.Add(c.name + " " + c2.Parameters[0]);
                                                            }
                                                            else
                                                            {
                                                                SendMessage(c, "[ERROR] You are a troll!");
                                                            }
                                                            #endregion
                                                            break;
                                                        case "kick":
                                                            #region Kick
                                                            if ((byte)c.rank > 4)
                                                            {
                                                                if (com.Parameters.Count == 1)
                                                                {
                                                                    if (users.ContainsKey(com.Parameters[0]))
                                                                    {
                                                                        ((Client)(users[com.Parameters[0]])).state = PenaltyState.Kicked;
                                                                        try
                                                                        {
                                                                            byte[] kickmsg = CreatePacket(ServerPacketType.Kicked, "");
                                                                            ((Client)(users[com.Parameters[0]])).sock.Send(kickmsg);
                                                                            DisconnectUser(((Client)(users[com.Parameters[0]])));
                                                                            users.Remove(com.Parameters[0]);
                                                                            newusers = true;
                                                                            queue.Add("[INFO] " + c.name + " has kicked " + com.Parameters[0] + " from the server.");
                                                                        }
                                                                        catch
                                                                        {
                                                                            ((Client)(users[com.Parameters[0]])).error = true;
                                                                        }
                                                                    }
                                                                    else
                                                                    {
                                                                        SendMessage(c, "[ERROR] No user with the name \"" + com.Parameters[0] + "\" exists.");
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    SendMessage(c, "[ERROR] Invalid parameter count '" + com.Parameters.Count + "'. This command takes 1 parameter.");
                                                                }
                                                            }
                                                            else
                                                            {
                                                                SendMessage(c, "[ERROR] Your current rank does not allow you to kick users.");
                                                            }
                                                            #endregion
                                                            break;
                                                        case "ban":
                                                            #region Ban
                                                            if ((byte)c.rank > (byte)Rank.VIP)
                                                            {
                                                                if (com.Parameters.Count == 1)
                                                                {
                                                                    if (users.ContainsKey(com.Parameters[0]))
                                                                    {
                                                                        ((Client)(users[com.Parameters[0]])).state = PenaltyState.Banned;
                                                                        try
                                                                        {
                                                                            byte[] kickmsg = CreatePacket(ServerPacketType.Banned, "");
                                                                            ((Client)(users[com.Parameters[0]])).sock.Send(kickmsg);
                                                                            DisconnectUser(((Client)(users[com.Parameters[0]])));
                                                                            Ban b = new Ban();
                                                                            b.UserName = com.Parameters[0];
                                                                            b.IP = ((IPEndPoint)(((Client)(users[com.Parameters[0]])).sock.RemoteEndPoint)).Address;
                                                                            try
                                                                            {
                                                                                List<Ban> current = GetBanlist();
                                                                                StreamWriter writer = new StreamWriter("banned.txt");
                                                                                if (current != null)
                                                                                {
                                                                                    foreach (Ban ban in current)
                                                                                    {
                                                                                        writer.WriteLine(ban.UserName + "|" + ban.IP.ToString());
                                                                                    }
                                                                                    writer.WriteLine(b.UserName + "|" + b.IP.ToString());
                                                                                }
                                                                                writer.Close();
                                                                            }
                                                                            catch
                                                                            {
                                                                                SendMessage(c, "[ERROR] A problem occured when trying to log the ban. The targeted user may still be able to reconnect.");
                                                                                Error("A problem occured when trying to log a ban issued by " + c.name + " for " + com.Parameters[0] + ". The targeted user may still be able to reconnect.");
                                                                            }
                                                                            users.Remove(com.Parameters[0]);
                                                                            newusers = true;
                                                                            queue.Add("[INFO] " + c.name + " has banned " + com.Parameters[0] + " from the server.");
                                                                        }
                                                                        catch
                                                                        {
                                                                            ((Client)(users[com.Parameters[0]])).error = true;
                                                                        }
                                                                    }
                                                                    else
                                                                    {
                                                                        SendMessage(c, "[ERROR] No user with the name \"" + com.Parameters[0] + "\" exists.");
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    SendMessage(c, "[ERROR] Invalid parameter count '" + com.Parameters.Count + "'. This command takes 1 parameter.");
                                                                }
                                                            }
                                                            else
                                                            {
                                                                SendMessage(c, "[ERROR] Your current rank does not allow you to ban users.");
                                                            }
                                                            #endregion
                                                            break;
                                                        case "mute":
                                                            #region Mute
                                                            if ((byte)c.rank > (byte)Rank.VIP)
                                                            {
                                                                if (com.Parameters.Count == 1)
                                                                {
                                                                    if (users.ContainsKey(com.Parameters[0]))
                                                                    {
                                                                        if ((byte)((Client)(users[com.Parameters[0]])).rank < (byte)Rank.VIP)
                                                                        {
                                                                            ((Client)(users[com.Parameters[0]])).state = PenaltyState.Muted;
                                                                            queue.Add("[INFO] " + c.name + " has muted " + com.Parameters[0] + ".");
                                                                        }
                                                                        else
                                                                        {
                                                                            SendMessage(c, "[ERROR] You may not mute moderators or the host.");
                                                                        }

                                                                    }
                                                                    else
                                                                    {
                                                                        SendMessage(c, "[ERROR] No user with the name \"" + com.Parameters[0] + "\" exists.");
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    SendMessage(c, "[ERROR] Invalid parameter count '" + com.Parameters.Count + "'. This command takes 1 parameter.");
                                                                }
                                                            }
                                                            else
                                                            {
                                                                SendMessage(c, "[ERROR] Your current rank does not allow you to mute users.");
                                                            }
                                                            #endregion
                                                            break;
                                                        case "unmute":
                                                            #region Unmute
                                                            if ((byte)c.rank > (byte)Rank.VIP)
                                                            {
                                                                if (com.Parameters.Count == 1)
                                                                {
                                                                    if (users.ContainsKey(com.Parameters[0]))
                                                                    {
                                                                        if ((byte)((Client)(users[com.Parameters[0]])).rank < (byte)Rank.VIP)
                                                                        {
                                                                            ((Client)(users[com.Parameters[0]])).state = PenaltyState.None;
                                                                            queue.Add("[INFO] " + c.name + " has unmuted " + com.Parameters[0] + ".");
                                                                        }
                                                                        else
                                                                        {
                                                                            SendMessage(c, "[ERROR] Moderators and the host cannot be muted anyway, so what are you playing at?!");
                                                                        }
                                                                    }
                                                                    else
                                                                    {
                                                                        SendMessage(c, "[ERROR] No user with the name \"" + com.Parameters[0] + "\" exists.");
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    SendMessage(c, "[ERROR] Invalid parameter count '" + com.Parameters.Count + "'. This command takes 1 parameter.");
                                                                }
                                                            }
                                                            else
                                                            {
                                                                SendMessage(c, "[ERROR] Your current rank does not allow you to unmute users.");
                                                            }
                                                            #endregion
                                                            break;
                                                        case "unban":
                                                            #region Unban
                                                            if ((byte)c.rank > (byte)Rank.VIP)
                                                            {
                                                                if (com.Parameters.Count == 1)
                                                                {
                                                                            try
                                                                            {
                                                                                List<Ban> current = GetBanlist();
                                                                                List<string> names = new List<string>();
                                                                                int ind = 0;
                                                                                if (current != null)
                                                                                {
                                                                                    for (int i = 0; i < current.Count; i++)
                                                                                    {
                                                                                        if (current[i].UserName == com.Parameters[0])
                                                                                        {
                                                                                            ind = i;
                                                                                        }
                                                                                        names.Add(current[i].UserName);
                                                                                    }
                                                                                    if (names.Contains(com.Parameters[0]))
                                                                                    {
                                                                                        current.RemoveAt(ind);
                                                                                        StreamWriter writer = new StreamWriter("banned.txt");
                                                                                        foreach (Ban b in current)
                                                                                        {
                                                                                            writer.WriteLine(b.UserName + "|" + b.IP.ToString());
                                                                                        }
                                                                                        writer.Close();
                                                                                        queue.Add("[INFO] " + c.name + " has unbanned " + com.Parameters[0] + ".");
                                                                                    }
                                                                                    else
                                                                                    {
                                                                                        SendMessage(c, "[ERROR] There is no banned user named " + com.Parameters[0] + ".");
                                                                                    }
                                                                                }
                                                                                else
                                                                                {
                                                                                    SendMessage(c, "[ERROR] There is no existing ban list.");
                                                                                }

                                                                            }
                                                                            catch
                                                                            {
                                                                                SendMessage(c, "[ERROR] A problem occured when trying to remove the ban. The targeted user may still be banned.");
                                                                                Error("A problem occured when trying to remove a ban issued to" + com.Parameters[0] + ". The targeted user may still be banned.");
                                                                            }
                                                                }
                                                                else
                                                                {
                                                                    SendMessage(c, "[ERROR] Invalid parameter count '" + com.Parameters.Count + "'. This command takes 1 parameter.");
                                                                }
                                                            }
                                                            else
                                                            {
                                                                SendMessage(c, "[ERROR] Your current rank does not allow you to unban users.");
                                                            }
                                                            #endregion
                                                            break;
                                                        case "getrank":
                                                            #region Getrank
                                                            if (com.Parameters.Count == 1)
                                                                {
                                                                    if (users.ContainsKey(com.Parameters[0]))
                                                                    {
                                                                        SendMessage(c, "[INFO] " + ((Client)(users[com.Parameters[0]])).name + " is a " + ((Client)(users[com.Parameters[0]])).rank.ToString() + ".");
                                                                    }
                                                                    else
                                                                    {
                                                                        SendMessage(c, "[ERROR] No user with the name \"" + com.Parameters[0] + "\" exists.");
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    SendMessage(c, "[ERROR] Invalid parameter count '" + com.Parameters.Count + "'. This command takes 1 parameter.");
                                                                }
                                                                #endregion
                                                            break;
                                                        case "rank":
                                                            #region Mute
                                                            if ((byte)c.rank > (byte)Rank.VIP)
                                                            {
                                                                if (com.Parameters.Count == 2)
                                                                {
                                                                    if (users.ContainsKey(com.Parameters[0]))
                                                                    {
                                                                        if ((byte)((Client)(users[com.Parameters[0]])).rank < (byte)Rank.Mod)
                                                                        {
                                                                            byte r;
                                                                            if (Byte.TryParse(com.Parameters[1], out r))
                                                                            {
                                                                                if (r == (byte)Rank.Troll || r == (byte)Rank.Noob || r == (byte)Rank.User || r == (byte)Rank.VIP || r == (byte)Rank.Mod)
                                                                                {
                                                                                    ((Client)(users[com.Parameters[0]])).rank = (Rank)r;
                                                                                    queue.Add("[INFO] " + c.name + " has ranked " + com.Parameters[0] + " as a " + ((Client)(users[com.Parameters[0]])).rank.ToString() + ".");
                                                                                }
                                                                                else
                                                                                {
                                                                                    SendMessage(c, "[ERROR] Invalid rank. Rank numbers are numbered by the power of 2 (i.e. 1, 2, 4, 8, 16, etc.)");
                                                                                }
                                                                            }
                                                                            else
                                                                            {
                                                                                SendMessage(c, "[ERROR] Invalid rank. Rank numbers are numbered by the power of 2 (i.e. 1, 2, 4, 8, 16, etc.)");
                                                                            }
                                                                        }
                                                                        else
                                                                        {
                                                                            SendMessage(c, "[ERROR] You may not change the ranks of moderators or the host.");
                                                                        }

                                                                    }
                                                                    else
                                                                    {
                                                                        SendMessage(c, "[ERROR] No user with the name \"" + com.Parameters[0] + "\" exists.");
                                                                    }
                                                                }
                                                                else
                                                                {
                                                                    SendMessage(c, "[ERROR] Invalid parameter count '" + com.Parameters.Count + "'. This command takes 2 parameters.");
                                                                }
                                                            }
                                                            else
                                                            {
                                                                SendMessage(c, "[ERROR] Your current rank does not allow you to rank users.");
                                                            }
                                                            #endregion
                                                            break;
                                                        case "topic":
                                                            #region Topic
                                                            if (c.rank == Rank.Host)
                                                            {
                                                                ChatCommand c2 = new ChatCommand(cp.Data, 0);
                                                                motd = c2.Parameters[0];
                                                                SaveMOTD(motd);
                                                                newmotd = true;
                                                            }
                                                            else
                                                            {
                                                                SendMessage(c, "[ERROR] Only the host can change the topic.");
                                                            }
                                                            #endregion
                                                            break;
                                                    }
                                                }
                                                else
                                                {
                                                    queue.Add(c.name + ": " + cp.Data);
                                                }
                                                break;
                                            case ClientPacketType.Leaving:
                                                queue.Add(c.name + " left the server.");
                                                DisconnectUser(c);
                                                users.Remove(c.name);
                                                newusers = true;
                                                invalid = true;
                                                break;
                                            default:
                                                break;
                                        }
                                    }
                                    else
                                    {
                                        invalid = true;
                                    }
                                }
                            }
                            else
                            {
                                invalid = true;
                            }
                            ns.Close();
                        }
                    }
                }
                catch
                {
                    c.error = true;
                }
            }
        }
        static void DisconnectUser(Client c)
        {
            c.sock.Shutdown(SocketShutdown.Both);
            c.sock.Close();
        }
        static void SendMessage(Client c, string message)
        {
            byte[] m = CreatePacket(ServerPacketType.ChatPost, message);
            c.sock.Send(m);
        }
        static byte[] CreatePacket(ServerPacketType type, string info)
        {
            byte[] a = new byte[] { (byte)type };
            byte[] b = Encoding.ASCII.GetBytes(info);
            byte[] c = info.Length > 0 ? a.Concat(b).ToArray() : a;
            MemoryStream ms = new MemoryStream();
            ms.Write(BitConverter.GetBytes(c.Length), 0, 4);
            ms.Write(c, 0, c.Length);
            ms.Position = 0;
            byte[] final = new byte[ms.Length];
            ms.Read(final, 0, (int)ms.Length);
            return final;
        }

        static List<Ban> GetBanlist()
        {
            if (File.Exists("banned.txt"))
            {
                List<Ban> list = new List<Ban>();
                StreamReader sr = new StreamReader("banned.txt");
                string raw = sr.ReadToEnd();
                sr.Close();
                string[] sl = raw.Split('\n');
                foreach (string s in sl)
                {
                    int ind = s.LastIndexOf("|");
                    if (ind > -1)
                    {
                        string n = Split(s, 0, ind);
                        IPAddress ip;
                        if (!IPAddress.TryParse(Split(s, ind + 1, s.Length), out ip))
                        {
                            continue;
                        }
                        else
                        {
                            Ban b = new Ban();
                            b.UserName = n;
                            b.IP = ip;
                            list.Add(b);
                        }
                    }
                }
                return list;
            }
            else
            {
                return null;
            }
        }
        static List<UserSpec> GetUserSpeclist()
        {
            if (File.Exists("users.txt"))
            {
                List<UserSpec> list = new List<UserSpec>();
                StreamReader sr = new StreamReader("users.txt");
                string raw = sr.ReadToEnd();
                sr.Close();
                string[] sl = raw.Split('\n');
                foreach (string s in sl)
                {
                    int ind = s.LastIndexOf("|");
                    if (ind > -1)
                    {
                        byte rank;
                        IPAddress ip;
                        if (!IPAddress.TryParse(Split(s, 0, ind), out ip) || !Byte.TryParse(Split(s, ind + 1, s.Length), out rank))
                        {
                            continue;
                        }
                        else
                        {
                            UserSpec b = new UserSpec();
                            if (rank > 0 && rank < 33)
                            {
                                b.r = (Rank)rank;
                            }
                            else
                            {
                                b.r = (Rank)4;
                            }
                            b.IP = ip;
                            list.Add(b);
                        }
                    }
                }
                return list;
            }
            else
            {
                return null;
            }
        }
        static string GetMOTD()
        {
            if (File.Exists("motd.txt"))
            {
                try
                {
                    StreamReader sr = new StreamReader("motd.txt");
                    string t = sr.ReadToEnd();
                    sr.Close();
                    return t;
                }
                catch
                {
                    return "No Topic";
                }
            }
            else
            {
                return "No Topic";
            }
        }
        static bool SaveMOTD(string str)
        {
            try
            {
                StreamWriter sr = new StreamWriter("motd.txt");
                sr.Write(str);
                sr.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }
        static string GetRankSymbol(Rank rank)
        {
            switch (rank)
            {
                case Rank.Troll:
                    return "#";
                case Rank.Noob:
                    return "?";
                case Rank.User:
                    return "";
                case Rank.VIP:
                    return "+";
                case Rank.Mod:
                    return "$";
                case Rank.Host:
                    return "@";
                default:
                    return "";
            }
        }
        public static string Split(string parent, int start, int end)
        {
            return parent.Substring(start, end - start);
        }
    }
    public enum Rank
    {
        Troll = 1,
        Noob = 2,
        User = 4,
        VIP = 8,
        Mod = 16,
        Host = 32
    }
    public enum ServerPacketType : byte
    {
        ChatPost = 0,
        Accepted = 1,
        Rejected = 2,
        Kicked = 3,
        Banned = 4,
        Shutdown = 5,
        MOTD = 6,
        UserList = 7,
        Muted = 8,
        Unmuted = 9,
        RequestPassword = 10,
        RequestUsername = 11
    }
    public enum ClientPacketType : byte
    {
        ChatPost = 0,
        Username = 1,
        Password = 2,
        Leaving = 3
    }
    public enum PenaltyState
    {
        None = 0,
        Muted = 1,
        Kicked = 2,
        Banned = 3
    }
    public class Client
    {
        public Socket sock;
        public PenaltyState state = PenaltyState.None;
        public bool error = false;
        public string name;
        public Rank rank;
    }
    public struct Ban
    {
        public string UserName;
        public IPAddress IP;
    }
    public struct UserSpec
    {
        public IPAddress IP;
        public Rank r;
    }
    public class ChatCommand
    {
        string cmd;
        string name;
        List<string> pmts;
        public bool Invalid = false;
        public ChatCommand(string command)
        {
            if (!command.StartsWith("/"))
            {
                Invalid = true;
            }
            else
            {
                cmd = command;
                List<string> pts = command.Split(' ').ToList();
                name = pts[0].Substring(1);
                pts.RemoveAt(0);
                pmts = pts;
            }
        }
        public ChatCommand(string command, int combineStart)
        {
            if (!command.StartsWith("/"))
            {
                Invalid = true;
            }
            else
            {
                cmd = command;
                List<string> pts = command.Split(' ').ToList();
                name = pts[0].Substring(1);
                pts.RemoveAt(0);
                string last = "";
                for (int i = pts.Count - 1; i >= combineStart; i--)
                {
                    last = pts[i] + " " + last;
                }
                last = last.Substring(0, last.Length - 1);
                pts.Clear();
                pts.Add(last);
                pmts = pts;
            }
        }
        public List<string> Parameters
        {
            get { return pmts; }
        }
        public string CommandName
        {
            get { return name; }
        }
        public string CommandString
        {
            get { return cmd; }
        }
    }

    public class ServerCommand
    {
        string cmd;
        string name;
        List<string> pmts;
        public ServerCommand(string command)
        {
            cmd = command;
            List<string> pts = command.Split(' ').ToList();
            name = pts[0];
            pts.RemoveAt(0);
            pmts = pts;
        }
        public ServerCommand(string command, int combineStart)
        {
            cmd = command;
            List<string> pts = command.Split(' ').ToList();
            name = pts[0].Substring(1);
            pts.RemoveAt(0);
            string last = "";
            for (int i = pts.Count - 1; i >= combineStart; i--)
            {
                last = pts[i] + " " + last;
            }
            last = last.Substring(0, last.Length - 1);
            pts.Clear();
            pts.Add(last);
            pmts = pts;
        }
        public List<string> Parameters
        {
            get { return pmts; }
        }
        public string CommandName
        {
            get { return name; }
        }
        public string CommandString
        {
            get { return cmd; }
        }
    }

    public class ClientPacket
    {
        static int ln = 0;
        static ClientPacketType type = ClientPacketType.Leaving;
        static string data = "";
        public static ClientPacket Parse(byte[] buffer)
        {
            if (buffer.Length > 4)
            {
                MemoryStream ms = new MemoryStream(buffer);
                byte[] a = new byte[4];
                ms.Read(a, 0, 4);
                ln = BitConverter.ToInt32(a, 0);
                byte[] b = new byte[1];
                ms.Read(b, 0, 1);
                byte bb = b[0];
                if (bb < 4)
                {
                    type = (ClientPacketType)bb;
                }
                else
                {
                    return null;
                }
                if (buffer.Length > 5)
                {
                    byte[] c = new byte[buffer.Length - 5];
                    ms.Read(c, 0, c.Length);
                    data = Encoding.ASCII.GetString(c);
                }
                ClientPacket packet = new ClientPacket();
                packet.Length = ln;
                packet.PacketType = type;
                packet.Data = data;
                return packet;
            }
            else
            {
                return null;
            }
        }
        public int Length
        {
            get { return ln; }
            set { ln = value; }
        }
        public ClientPacketType PacketType
        {
            get { return type; }
            set { type = value; }
        }
        public string Data
        {
            get { return data; }
            set { data = value; }
        }
    }

}