protected internal void ProcessMessageEndOfStats(IrcMessage message)
        {
            Debug.Assert(message.Parameters[0] == localUser.NickName);

            OnServerStatsReceived(new IrcServerStatsReceivedEventArgs(listedStatsEntries));
            listedStatsEntries = new List<IrcServerStatisticalEntry>();
        }

 public static void HandleWhoIsEnd(IrcClient client, IrcMessage message)
 {
     var request = client.RequestManager.DequeueOperation("WHOIS " + message.Parameters[1]);
     if(request.Callback != null)
         request.Callback(request);
     client.OnWhoIsReceived(new Events.WhoIsReceivedEventArgs((WhoIs)request.State));
 }

 public override void Run(IIrcUser client, IrcMessage message)
 {
     IrcChannel[] channels;
     if (message.Params.Length == 0)
     {
         channels = client.IrcServer.Channels.ToArray();
     }
     else
     {
         string[] channelList = message.Params[0].ToLower().Split(',');
         channels = client.IrcServer.Channels.Where(channel =>
             channelList.Contains(channel.Name.Replace(",", "").ToLower())
             ).ToArray();
     }
     channels.ForEach(channel =>
     {
         client.Write(new IrcNumericResponce
         {
             NumericId = IrcNumericResponceId.RPL_NAMEREPLY,
             Extra = "= " + channel.Name,
             Message = string.Join(" ",
                 channel.Users
                 .Where(user => !user.Mode.IsInvisible || channel.Users.Contains(client) || client.Mode.IsOperator)
                 .Select(user => string.Format("{0}{1}", user.ChannelModes[channel].NickPrefix, user.Nick)))
         });
     });
     client.Write(new IrcNumericResponce
     {
         NumericId = IrcNumericResponceId.RPL_ENDOFNAMES,
         Extra = client.Nick,
         Message = "End of names"
     });
 }

        public void IrcMsg_ToStringNoPrefixNoArgs()
        {
            var expected = "PING";

            var actual = new IrcMessage("PING", "");
            Assert.AreEqual(expected, actual.ToString());
        }

 public override void Run(IIrcUser client, IrcMessage message)
 {
     if (message.Params.Length != 1)
     {
         SendMessage(IrcNumericResponceId.ERR_NONICKNAMEGIVEN, client, "No nickname given");
         return;
     }
     if (!IRC.CheckString(message.Params[0], IRC.NICKNAME))
     {
         SendMessage(IrcNumericResponceId.ERR_ERRONEUSNICKNAME, client, "Erroneous nickname");
         return;
     }
     if (!client.IrcServer.CheckNick(message.Params[0]))
     {
         SendMessage(IrcNumericResponceId.ERR_NICKNAMEINUSE, client, "Nickname is already in use");
         return;
     }
     string oldNick = client.Nick;
     client.Channels.ForEach(channel => channel.Nick(client, message.Params[0]));
     if (!string.IsNullOrEmpty(client.User))
     {
         Say(client, "NICK", message.Params[0]);
     }
     client.Nick = message.Params[0];
 }

 public override void Run(IIrcUser client, IrcMessage message)
 {
     if (message.Params.Length != 1)
     {
         SendMessage(IrcNumericResponceId.ERR_NEEDMOREPARAMS, client, "Not enough parameters");
         return;
     }
     if (IRC.IsChannel(message.Params[0]))
     {
         IrcChannel channel = client.IrcServer.Channels.Where(ch => ch.Name == message.Params[0]).FirstOrDefault();
         if (channel == null)
         {
             return;
         }
         channel.Users.ForEach(cli => cli.Write(new IrcNumericResponce()
         {
             NumericId = IrcNumericResponceId.RPL_WHOREPLY,
             Message = cli.UserString
         }));
         client.Write(new IrcNumericResponce()
         {
             NumericId = IrcNumericResponceId.RPL_ENDOFWHO,
             Message = "End of who"
         });
     }
 }

        public void IrcMsg_ToStringArgWithSpace()
        {
            var expected = ":prefix PRIVMSG blabla :string with a lot of spaces";
            var actual = new IrcMessage("PRIVMSG", "prefix", "blabla", "string with a lot of spaces");

            Assert.AreEqual(expected, actual.ToString());
        }

        // Syntax: INVITE <nick> <channel>
        public override void Run(IIrcUser client, IrcMessage message)
        {
            if (message.Params.Length != 2)
            {
                NeedMoreParamsError(client);
                return;
            }
            if (client.IrcServer.CheckNick(message.Params[0]))
            {
                NotFoundError(client, false);
                return;
            }
            if (!IRC.IsChannel(message.Params[1]) || !client.IrcServer.ChannelExists(message.Params[1]))
            {
                NotFoundError(client, true);
                return;
            }

            IrcChannel channel = client.IrcServer.GetChannel(message.Params[1]);
            IIrcUser user = client.IrcServer.Clients.Find(cli => cli.Nick == message.Params[0]);
            if (!user.ChannelModes.ContainsKey(channel))
            {
                user.ChannelModes.Add(channel, new IrcChannelUserMode());
            }
            IrcChannelUserMode mode = user.ChannelModes[channel];
            mode.IsInvited = true;
            channel.Command(client, "INVITE", user.Nick);
            client.Write(new IrcNumericResponce
            {
                NumericId = IrcNumericResponceId.RPL_INVITING,
                To = channel.Name,
                Extra = client.Nick,
                Message = "invited."
            });
        }

 public static void HandleGetEmptyTopic(IrcClient client, IrcMessage message)
 {
     var channel = client.Channels.GetOrAdd(message.Parameters[1]);
     var old = channel._Topic;
     channel._Topic = message.Parameters[2];
     client.OnChannelTopicReceived(new ChannelTopicEventArgs(channel, old, channel._Topic));
 }

 public static void HandleUserListPart(IrcClient client, IrcMessage message)
 {
     var channel = client.Channels[message.Parameters[2]];
     var users = message.Parameters[3].Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
     foreach (var nick in users)
     {
         if (string.IsNullOrWhiteSpace(nick))
             continue;
         var mode = client.ServerInfo.GetModeForPrefix(nick[0]);
         if (mode == null)
         {
             var user = client.Users.GetOrAdd(nick);
             if (!user.Channels.Contains(channel))
                 user.Channels.Add(channel);
             if (!user.ChannelModes.ContainsKey(channel))
                 user.ChannelModes.Add(channel, null);
             else
                 user.ChannelModes[channel] = null;
         }
         else
         {
             var user = client.Users.GetOrAdd(nick.Substring(1));
             if (!user.Channels.Contains(channel))
                 user.Channels.Add(channel);
             if (!user.ChannelModes.ContainsKey(channel))
                 user.ChannelModes.Add(channel, mode.Value);
             else
                 user.ChannelModes[channel] = mode.Value;
         }
     }
 }

        public IrcMessenger()
        {
            var server = Config.Get("Irc.Server");
            var nick = Config.Get("Irc.Nick", Config.Get("Name", "gambot"));
            var user = Config.Get("Irc.User", nick);
            var password = Config.Get("Irc.Password");
            var ssl = Config.GetBool("Irc.Ssl");
            client = new IrcClient(server, new IrcUser(nick, user, password),
                                   ssl);

            client.SetHandler("372", (c, m) => { }); // Ignore MOTD

            client.PrivateMessageRecieved += (sender, args) =>
            {
                if (MessageReceived != null)
                {
                    var message = new IrcMessage(args.PrivateMessage);
                    MessageReceived(this,
                                    new MessageEventArgs
                                    {
                                        Message = message,
                                        Addressed =
                                            (!args.PrivateMessage
                                                  .IsChannelMessage ||
                                             String.Equals(message.To, nick,
                                                           StringComparison
                                                               .CurrentCultureIgnoreCase))
                                    });
                }
            };

            client.ConnectAsync();
        }

 public static void HandleUserListEnd(IrcClient client, IrcMessage message)
 {
     var channel = client.Channels[message.Parameters[1]];
     client.OnChannelListRecieved(new ChannelEventArgs(channel));
     if (client.Settings.ModeOnJoin)
         client.GetMode(channel.Name, c => Console.WriteLine(c.Mode));
 }

	public static void HandleMOTDNotFound(IrcClient client, IrcMessage message)
	{
            client.OnMOTDRecieved(new ServerMOTDEventArgs(MOTD));
            client.OnConnectionComplete(new EventArgs());

            VerifyOurIdentity(client);
	}

 public static void HandleMOTD(IrcClient client, IrcMessage message)
 {
     if (message.Parameters.Length != 2)
         throw new IrcProtocolException("372 MOTD message is incorrectly formatted.");
     var part = message.Parameters[1].Substring(2);
     MOTD += part + Environment.NewLine;
     client.OnMOTDPartRecieved(new ServerMOTDEventArgs(part));
 }

 public static void HandleInviteListPart(IrcClient client, IrcMessage message)
 {
     var parameterString = message.RawMessage.Substring(message.RawMessage.IndexOf(' ') + 1);
     var parameters = parameterString.Substring(parameterString.IndexOf(' ') + 1).Split(' ');
     var request = client.RequestManager.PeekOperation("GETMODE I " + parameters[1]);
     var list = (MaskCollection)request.State;
     list.Add(new Mask(parameters[2], new IrcUser(parameters[3]), IrcClient.DateTimeFromIrcTime(int.Parse(parameters[4]))));
 }

 public override void Run(IIrcUser client, IrcMessage message)
 {
     client.Write(new IrcMessage
     {
         Command = "PONG",
         Params = message.Params
     });
 }

 public static void HandleEndOfMOTD(IrcClient client, IrcMessage message)
 {
     client.OnMOTDRecieved(new ServerMOTDEventArgs(MOTD));
     client.OnConnectionComplete(new EventArgs());
     // Verify our identity
     VerifyOurIdentity(client);
     
 }

 public static void HandlePart(IrcClient client, IrcMessage message)
 {
     if (client.User.Match(message.Prefix)) // We've parted this channel
         client.Channels.Remove(client.Channels[message.Parameters[0]]);
     else // Someone has parted a channel we're already in
         client.Channels[message.Parameters[0]].Users.Remove(new IrcUser(message.Prefix).Nick);
     client.OnUserPartedChannel(new ChannelUserEventArgs(client.Channels[message.Parameters[0]], new IrcUser(message.Prefix)));
 }

 public static void HandleWhoIsUser(IrcClient client, IrcMessage message)
 {
     var whois = (WhoIs)RequestOperation.PeekOperation("WHOIS " + message.Parameters[1]).State;
     whois.User.Nick = message.Parameters[1];
     whois.User.User = message.Parameters[2];
     whois.User.Hostname = message.Parameters[3];
     whois.User.RealName = message.Parameters[5];
 }

 public static void HandleQuietListPart(IrcClient client, IrcMessage message)
 {
     var parameterString = message.RawMessage.Substring(message.RawMessage.IndexOf(' ') + 1);
     var parameters = parameterString.Substring(parameterString.IndexOf(' ') + 1).Split(' ');
     var request = RequestOperation.PeekOperation("QLIST " + parameters[1]);
     var list = (List<Mask>)request.State;
     list.Add(new Mask(parameters[2], new IrcUser(parameters[3]), IrcClient.DateTimeFromIrcTime(int.Parse(parameters[4]))));
 }