public bool handleURL(string url, IrcClient ctx, CtcpClient ctpcclient = null, IIrcMessageSource source = null )
        {
            var title = GetPageTitle(url).Trim();
            if (!string.IsNullOrWhiteSpace(title))
            {
                if(title.ToLower().Contains("Domainpark - Bitte den Rasen nicht betreten".ToLower()))
                {
                    int roll = random.Next(0, 101);
                    if(roll < 5)
                    {
                        if(ctpcclient != null)
                        {
                            string textMessage = "slaps " + source.Name + " and screamed:";
                            BotDeathmicMessageTarget target = new BotDeathmicMessageTarget();
                            target.Name = Properties.Settings.Default.Channel.ToString();
                            ctpcclient.SendAction(target, textMessage);
                            ctx.LocalUser.SendMessage(Properties.Settings.Default.Channel, "Runter vom Rasen!");
                        }
                    }
                }
                else
                {
                    if(title.ToLower() == "Imgur: The most awesome images on the Internet".ToLower())
                    {

                    }
                    else
                    {
                        ctx.LocalUser.SendMessage(Properties.Settings.Default.Channel, title);
                    }

                }
            }
            return true;
        }

 public IrcMessageCommand(
     IrcBot bot, 
     IrcBotUser user,
     IrcClient client, 
     string[] parameters, 
     IIrcMessageTarget target, 
     IIrcMessageSource source
 )
     : base(bot, user, client, parameters, target, source)
 {
 }

        private void ProcessChatCommandHelp(IrcClient client, IIrcMessageSource source,
            IList<IIrcMessageTarget> targets, string command, IList<string> parameters)
        {
            if (parameters.Count != 0)
                throw new InvalidCommandParametersException(0);

            // List all commands recognized by this bot.
            var replyTarget = GetDefaultReplyTarget(client, source, targets);
            client.LocalUser.SendMessage(replyTarget, "Commands recognized by bot:");
            client.LocalUser.SendMessage(replyTarget, string.Join(", ",
                this.ChatCommandProcessors.Select(kvPair => kvPair.Key)));
        }

        public bool handleURL(string url, IrcDotNet.IrcClient ctx, CtcpClient ctpcclient = null, IIrcMessageSource source = null)
        {
            var match = _imgurreg.Match(url);

            if (match.Success)
            {
                var id = match.Groups[2].Value;
                url = "http://imgur.com/gallery/" + id;
                website.handleURL(url, ctx, ctpcclient, source);
                return true;
            }
            return false;
        }

        public void Run(IrcClient client, IIrcMessageSource source, IList<IIrcMessageTarget> targets, string command, IList<string> parameters)
        {
            Client = client;
            SourceUser = (IrcUser)source;
            Command = command;
            Parameters = parameters;

            if (targets.Contains(Client.LocalUser) && source != null)
                ReplyTargets = new[] { (IIrcMessageTarget)source };
            else
            {
                ReplyTargets = targets;
            }

            Run();
        }

 public bool AddUser(string username, Channels ChannelWatch, IIrcMessageTarget target, IIrcMessageSource source, IrcClient ircConnection)
 {
     ModifyingConfig = true;
     bool returnvalue = false;
     IrcChannel findChannel = null;
     foreach (IrcChannel ircChannel in ircConnection.Channels)
     {
         if(ircChannel.Name == target.Name)
         {
             findChannel = ircChannel;
         }
     }
     if (Utilities.CheckOp(source.Name, findChannel))
     {
         try
         {
             Channels Watch = new Channels();
             foreach (Channels c in TwitchChannels)
             {
                 if (findChannel.Name == c.ChannelName)
                 {
                     Watch = c;
                 }//if (findChannel.Name == c.ChannelName)
             }//foreach (Channels c in TwitchChannels)
             // config writing
             XElement newStreamer = new XElement("streamer");
             newStreamer.SetAttributeValue("value", username);
             XElement xElem = ConfigDocument.Descendants("servers").FirstOrDefault().Descendants("server").FirstOrDefault().Elements("channel").First(x => x.Attribute("id").Value == Watch.ChannelName);
             xElem.Descendants("streamers").FirstOrDefault().Add(newStreamer);
             TwitchStuff twitchInfo = new TwitchStuff();
             twitchInfo.UpdateInfo(username,this);
             Watch.Streamers.Add(username);
             Watch.StreamInfo.Add(twitchInfo);
             returnvalue = true;
             ConfigDocument.Save(FileName);
         }//try
         catch (Exception ex)
         {
             Console.ForegroundColor = ConsoleColor.Red;
             Console.WriteLine("ERROR: " + ex.Message);
             Console.ForegroundColor = ConsoleColor.Gray;
             returnvalue = false;
         }
     }
     ModifyingConfig = false;
     return returnvalue;
 }

        public IrcCommand(
            IrcBot bot, 
            IrcBotUser user,
            IrcClient client, 
            string[] parameters, 
            IIrcMessageTarget target, 
            IIrcMessageSource source
        )
        {
            this.Bot = bot;
            this.User = user;
            this.Client = client;
            this.Target = target;
            this.Source = source;

            ParseParameters(parameters);
        }

        private void ProcessChatCommandSend(IrcClient client, IIrcMessageSource source,
            IList<IIrcMessageTarget> targets, string command, IList<string> parameters)
        {
            var sourceUser = (IrcUser)source;
            var twitterBotUser = GetTwitterBotUser(sourceUser);

            if (parameters.Count != 1)
                throw new InvalidCommandParametersException(1);

            // Send tweet from user.
            var tweetStatus = twitterBotUser.SendTweet(parameters[0].TrimStart());
            var replyTargets = GetDefaultReplyTarget(client, sourceUser, targets);
            client.LocalUser.SendMessage(replyTargets, "Tweet sent by {0} at {1}.", tweetStatus.User.ScreenName,
                tweetStatus.CreatedDate.ToLongTimeString());
        }

        private void ProcessChatCommandLogIn(IrcClient client, IIrcMessageSource source,
            IList<IIrcMessageTarget> targets, string command, IList<string> parameters)
        {
            var sourceUser = (IrcUser)source;
            var twitterUser = this.twitterUsers.SingleOrDefault(tu => tu.IrcUser == sourceUser);
            if (twitterUser != null)
                throw new InvalidOperationException(string.Format(
                    "User '{0}' is already logged in to Twitter as {1}.", sourceUser.NickName,
                    twitterUser.TwitterUser.ScreenName));

            if (parameters.Count != 2)
                throw new InvalidCommandParametersException(1);

            // Create new Twitter user and log in.
            var twitterBotUser = new TwitterBotUser(sourceUser);
            twitterBotUser.LogIn(parameters[0], parameters[1]);
            this.twitterUsers.Add(twitterBotUser);

            var replyTargets = GetDefaultReplyTarget(client, sourceUser, targets);
            client.LocalUser.SendMessage(replyTargets, "You are now logged in as {0} / '{1}'.",
                twitterBotUser.TwitterUser.ScreenName, twitterBotUser.TwitterUser.Name);
        }

        /// <summary>
        /// </summary>
        /// <param name="client">
        /// </param>
        /// <param name="source">
        /// </param>
        /// <param name="targets">
        /// </param>
        /// <param name="command">
        /// </param>
        /// <param name="parameters">
        /// </param>
        private void ReadChatCommand(
            IrcClient client,
            IIrcMessageSource source,
            IList<IIrcMessageTarget> targets,
            string command,
            string[] parameters)
        {
            IList<IIrcMessageTarget> defaultReplyTarget = this.GetDefaultReplyTarget(client, source, targets);

            ChatCommandProcessor processor;
            if (this.chatCommandProcessors.TryGetValue(command, out processor))
            {
                try
                {
                    processor(client, source, targets, command, parameters);
                }
                catch (InvalidCommandParametersException exInvalidCommandParameters)
                {
                    client.LocalUser.SendNotice(defaultReplyTarget, exInvalidCommandParameters.GetMessage(command));
                }
                catch (Exception ex)
                {
                    if (source is IIrcMessageTarget)
                    {
                        client.LocalUser.SendNotice(
                            defaultReplyTarget,
                            "Error processing '{0}' command: {1}",
                            command,
                            ex.Message);
                    }
                }
            }
            else
            {
                if (source is IIrcMessageTarget)
                {
                    client.LocalUser.SendNotice(defaultReplyTarget, "Command '{0}' not recognized.", command);
                }
            }
        }

 internal void HandleNoticeReceived(IIrcMessageSource source, IList<IIrcMessageTarget> targets, string text)
 {
     var previewEventArgs = new IrcPreviewMessageEventArgs(source, targets, text, this.Client.TextEncoding);
     OnPreviewNoticeReceived(previewEventArgs);
     if (!previewEventArgs.Handled)
         OnNoticeReceived(new IrcMessageEventArgs(source, targets, text, this.Client.TextEncoding));
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="IrcMessageEventArgs"/> class.
        /// </summary>
        /// <param name="source">The source of the message.</param>
        /// <param name="targets">A list of the targets of the message.</param>
        /// <param name="text">The text of the message.</param>
        /// <param name="encoding">The encoding of the message text.</param>
        /// <exception cref="ArgumentNullException"><paramref name="targets"/> is <see langword="null"/>.</exception>
        /// <exception cref="ArgumentNullException"><paramref name="text"/> is <see langword="null"/>.</exception>
        public IrcMessageEventArgs(IIrcMessageSource source, IList<IIrcMessageTarget> targets, string text,
            Encoding encoding)
            : base()
        {
            if (targets == null)
                throw new ArgumentNullException("target");
            if (text == null)
                throw new ArgumentNullException("text");
            if (encoding == null)
                throw new ArgumentNullException("textEncoding");

            this.Source = source;
            this.Targets = new ReadOnlyCollection<IIrcMessageTarget>(targets);
            this.Text = text;
            this.Encoding = encoding;
        }

        private void ProcessChatCommandZoneInfo(
            IrcClient client,
            IIrcMessageSource source,
            IList<IIrcMessageTarget> targets,
            string command,
            IList<string> parameters)
        {
            if (!this.executingRequestPlayfieldList)
            {
                this.executingRequestPlayfieldList = true;
                int numberOfZoneEnginesConnected = Program.ISCom.ClientCount;
                List<string> addressList = Program.ISCom.GetZoneEngineIds();

                Program.ISCom.BroadCast(new RequestPlayfieldList());

                StringBuilder sb = new StringBuilder();
                var sourceUser = (IrcUser)source;
                IList<IIrcMessageTarget> replyTargets = this.GetDefaultReplyTarget(client, sourceUser, targets);

                DateTime startWait = DateTime.UtcNow;

                bool timeOut = true;
                while ((DateTime.UtcNow - startWait < TimeSpan.FromSeconds(10) && timeOut))
                {
                    lock (this.replyQueuePlayfieldList)
                    {
                        if (this.replyQueuePlayfieldList.Count == Program.ISCom.ClientCount)
                        {
                            timeOut = false;
                        }
                    }
                }
                if (timeOut)
                {
                    client.LocalUser.SendMessage(replyTargets, "{0}", "Not all ZoneEngines replied.");
                }

                client.LocalUser.SendMessage(
                    replyTargets,
                    "{0}",
                    "Number of ZoneEngines connected: " + numberOfZoneEnginesConnected);

                while (this.replyQueuePlayfieldList.Count > 0)
                {
                    RequestPlayfieldList r = this.replyQueuePlayfieldList.Dequeue();
                    client.LocalUser.SendMessage(
                        replyTargets,
                        "{0}: Playfields {1}",
                        r.ZoneEngineAddress,
                        string.Join(
                            ", ",
                            r.PlayfieldIds.Select(
                                x => PlayfieldLoader.PFData[x.Instance].Name.Trim() + " (" + x.Instance + ")")
                                .ToArray()));
                }
                this.executingRequestPlayfieldList = false;
            }
        }

        /// <summary>
        /// </summary>
        /// <param name="client">
        /// </param>
        /// <param name="source">
        /// </param>
        /// <param name="targets">
        /// </param>
        /// <param name="command">
        /// </param>
        /// <param name="parameters">
        /// </param>
        private void ProcessChatCommandSend(
            IrcClient client,
            IIrcMessageSource source,
            IList<IIrcMessageTarget> targets,
            string command,
            IList<string> parameters)
        {
            var sourceUser = (IrcUser)source;
            // var twitterBotUser = GetTwitterBotUser(sourceUser);
            if (parameters.Count != 1)
                throw new InvalidCommandParametersException(1);

            //Send System Message.
            //TODO: Add GM Check and Sending System Message Code here

            //Twitter Code Delete this crap after new code is written.
            // var tweetStatus = twitterBotUser.SendTweet(parameters[0].TrimStart());
            // var replyTargets = GetDefaultReplyTarget(client, sourceUser, targets);
            // client.LocalUser.SendMessage(replyTargets, "Tweet sent by {0} at {1}.", tweetStatus.User.ScreenName,
            // tweetStatus.CreatedDate.ToLongTimeString());
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="client"></param>
 /// <param name="source"></param>
 /// <param name="targets"></param>
 /// <param name="command"></param>
 /// <param name="parameters"></param>
 private void ProcessChatCommandRegister(
     IrcClient client,
     IIrcMessageSource source,
     IList<IIrcMessageTarget> targets,
     string command,
     IList<string> parameters)
 {
     //TODO: Add Command to register user for CellAO
 }

        /// <summary>
        /// </summary>
        /// <param name="client">
        /// </param>
        /// <param name="source">
        /// </param>
        /// <param name="targets">
        /// </param>
        /// <param name="command">
        /// </param>
        /// <param name="parameters">
        /// </param>
        private void ProcessChatCommandLogIn(
            IrcClient client, 
            IIrcMessageSource source, 
            IList<IIrcMessageTarget> targets, 
            string command, 
            IList<string> parameters)
        {
            var sourceUser = (IrcUser)source;

            // var sourceUser = (IrcUser)source;
            // var twitterUser = this.twitterUsers.SingleOrDefault(tu => tu.IrcUser == sourceUser);
            // if (twitterUser != null)
            // throw new InvalidOperationException(string.Format(
            // "User '{0}' is already logged in to Twitter as {1}.", sourceUser.NickName,
            // twitterUser.TwitterUser.ScreenName));

            // if (parameters.Count != 2)
            // throw new InvalidCommandParametersException(1);

            // // Create new Twitter user and log in to service.
            // var twitterBotUser = new TwitterBotUser(sourceUser);
            // var success = twitterBotUser.LogIn(parameters[0], parameters[1]);

            // var replyTargets = GetDefaultReplyTarget(client, sourceUser, targets);
            // if (success)
            // {
            // // Log-in succeeded.

            // this.twitterUsers.Add(twitterBotUser);

            // client.LocalUser.SendMessage(replyTargets, "You are now logged in as {0} / '{1}'.",
            // twitterBotUser.TwitterUser.ScreenName, twitterBotUser.TwitterUser.Name);
            // }
            // else
            // {
            // // Log-in failed.

            // client.LocalUser.SendMessage(replyTargets, "Invalid log-in username/password.");
            // }
        }

        /// <summary>
        /// Need to change Some Information in this code. Probably a Seperate MOTD for IRC or something to have the bot read and send for
        /// connection Info.
        /// </summary>
        /// <param name="client">
        /// </param>
        /// <param name="source">
        /// </param>
        /// <param name="targets">
        /// </param>
        /// <param name="command">
        /// </param>
        /// <param name="parameters">
        /// </param>
        private void ProcessChatCommandServerInfo(
            IrcClient client, 
            IIrcMessageSource source, 
            IList<IIrcMessageTarget> targets, 
            string command, 
            IList<string> parameters)
        {
            IList<IIrcMessageTarget> replyTarget = this.GetDefaultReplyTarget(client, source, targets);

            client.LocalUser.SendMessage(replyTarget, "A How to Setup Connection to CellAO can be found here: TBA");
            client.LocalUser.SendMessage(
                replyTarget,
                "This is the address for the server: " + Config.Instance.CurrentConfig.ListenIP + "  On Port: "
                + Config.Instance.CurrentConfig.LoginPort);
        }

 internal void HandleMessageReceived(IIrcMessageSource source, IList<IIrcMessageTarget> targets, string text)
 {
     var previewEventArgs = new IrcPreviewMessageEventArgs(source, targets, text);
     OnPreviewMessageReceived(previewEventArgs);
     if (!previewEventArgs.Handled)
         OnMessageReceived(new IrcMessageEventArgs(source, targets, text));
 }

 /// <inheritdoc/>
 public IrcPreviewMessageEventArgs(IIrcMessageSource source, IList<IIrcMessageTarget> targets, string text,
     Encoding encoding)
     : base(source, targets, text, encoding)
 {
     this.Handled = false;
 }

 private void ProcessChatCommandTalk(IrcClient client, IIrcMessageSource source,
     IList<IIrcMessageTarget> targets, string command, IList<string> parameters)
 {
     // Send reply containing random message text (generated from Markov chain).
     int numSentences = -1;
     if (parameters.Count >= 1)
         numSentences = int.Parse(parameters[0]);
     string higlightNickName = null;
     if (parameters.Count >= 2)
         higlightNickName = parameters[1] + ": ";
     SendRandomMessage(client, GetDefaultReplyTarget(client, source, targets),
         higlightNickName, numSentences);
 }