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 static void SayInChannels(IrcClient client, string msg)
 {
     foreach (var channel in client.Channels)
     {
         client.LocalUser.SendMessage(channel, msg);
     }
 }

        public void Execute(IrcClient Client, string channel, IrcUser Sender, string message)
        {
            message = message.Trim();
            if (message == "")
            {
                Client.LocalUser.SendMessage(channel, horoscopeHelpMsg());
            }
            else
            {

                if (!signs.ContainsKey(message))
                {
                    Client.LocalUser.SendMessage(channel, "Why won't you give me a sign~");
                    return;
                }

                string html = getHTML(signs[message]);

                string horoscope = dropHtmlPrecedingHoroscope(html, message);
                horoscope = dropHtmlTailingHoroscope(horoscope);
                horoscope = html2Txt(horoscope);

                Client.LocalUser.SendMessage(channel, horoscope);
            }
        }

        private static void HandleEventLoop(IrcClient client)
        {
            _ircLocaluser = client.LocalUser;
              _hostNameToWebSockets.Add("", new WebSocketListenerClient(PrivateConstants.TestAccountWebsocketAuth));
              _hostNameToWebSockets[""].Run(sendToIrcProcessor);

              bool isExit = false;
              while (!isExit) {
            Console.Write("> ");
            var command = Console.ReadLine();
            switch (command) {
              case "exit":
            isExit = true;
            break;
              default:
            if (!string.IsNullOrEmpty(command)) {
              if (command.StartsWith("/") && command.Length > 1) {
                client.SendRawMessage(command.Substring(1));
              } else {
                Console.WriteLine($"Unknown command '{command}'");
              }
            }
            break;
            }
              }
              client.Disconnect();
        }

 public ChannelSearchViewModel(IrcClient client)
 {
     this.client = client;
       this.allChannels = new List<BindableChannelInfo>();
       this.Channels = new BindableCollection<BindableChannelInfo>();
       this.client.ChannelListReceived += ircClient_ChannelListReceived;
       this.DisplayName = "Join Channel";
 }

 protected void InvalidSyncLibraryCommand(
     IrcClient client, 
     IList<IIrcMessageTarget> replyTarget, 
     string commandError)
 {
     client.LocalUser.SendMessage(replyTarget, string.Format("Invalid .sync-command: {0}", commandError));
     client.LocalUser.SendMessage(replyTarget, "Usage: .sync-library library-guid");
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="twitchUsername"></param>
        /// <param name="twitchOAuthToken">
        /// A chat login token which can be generated here: http://www.twitchapps.com/tmi/
        /// </param>
        public void Start(string twitchUsername, string twitchOAuthToken)
        {
            var client = new IrcClient();

            client.Connected += client_Connected;
            client.ChannelListReceived += client_ChannelListReceived;
            client.RawMessageReceived += client_RawMessageReceived;

            client.Connect("irc.twitch.tv", 6667, false, new IrcUserRegistrationInfo() {NickName = twitchUsername, Password = twitchOAuthToken, UserName = twitchUsername, RealName = twitchUsername});
        }

        public Client(Server server)
        {
            client = new IrcClient();
            this.server = server;

            channels = getChannels(server);

            SetEventHandlers();
            findClientConfs();
        }

        public ActionResult Irc()
        {
            var api = new AppHarborApi(new AuthInfo { AccessToken = ConfigurationManager.AppSettings["authToken"] });

            var latestBuild = api.GetBuilds(Constants.AppHarborAppName).First();
            var testResults = api.GetTests(Constants.AppHarborAppName, latestBuild.ID);
            List<AppHarbor.Model.Test> allTests = new List<AppHarbor.Model.Test>();

            foreach (var testresult in testResults)
            {
                FillTests(allTests, testresult);
            }

            AutoResetEvent are = new AutoResetEvent(false);
            IrcDotNet.IrcClient client = new IrcDotNet.IrcClient();

            try
            {
                client.Connect("irc.gamesurge.net", false, new IrcUserRegistrationInfo() { NickName = "crymono-build", RealName = "crymono", UserName = "crymono" });

                client.ClientInfoReceived += (s, e) => are.Set();

                are.WaitOne();

                client.Channels.Join(new string[] { "#crymono" });

                Thread.Sleep(200);
                string msg = latestBuild.Commit.Message.Replace("\n", "").Replace("\r", "");

                client.LocalUser.SendMessage("#crymono", "Build finished, latest commit: " + msg);
                Thread.Sleep(200);

                int numPassedTests = allTests.Count(t => t.Status == "Passed");
                float percentage = (float)numPassedTests / allTests.Count * 100;
                client.LocalUser.SendMessage("#crymono", String.Format("Test results: {0} of {1} passed ({2:0}%) - http://crymono.apphb.com/#!/{3} - AppHB: https://appharbor.com/applications/crymonobuild/builds/{3}/tests",
                    numPassedTests,
                    allTests.Count,
                    percentage,
                    latestBuild.ID
                    ));
                Thread.Sleep(200);

            }
            finally
            {
                if (client != null && client.IsConnected)
                {
                    client.Quit("to the hills!");
                    Thread.Sleep(200);
                    client.Disconnect();
                }
            }

            return Content("OK");
        }

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

 public IrcQueryViewModel(IrcUser user, IrcClient client, Settings settings)
 {
     this.Settings = settings;
       this.User = user;
       this.client = client;
       this.DisplayName = user.NickName;
       this.Messages = new BindableCollection<Message>();
       this.Closable = true;
       // TODO
       this.client.LocalUser.MessageReceived += this.messageReceived;
 }

        /// <summary>
        /// Initializes a new instance of the IrcChannelViewModel class
        /// </summary>
        public IrcStatusTabViewModel(IrcClient client)
        {
            this.Messages = new BindableCollection<Message>();
              this.Closable = false;
              this.DisplayName = "Status";
              this.Client = client;

              this.Client.LocalUser.MessageReceived += this.localUserMessageReceived;
              this.Client.MotdReceived += this.clientMessageOfTheDayReceived;
              this.Client.WhoIsReplyReceived += this.clientWhoIsReplyReceived;
        }

        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 IrcBot(IrcBotConfiguration configuration)
        {
            this.tasks = new List<IIrcTask>();
            this.users = new ConcurrentDictionary<string, IrcBotUser>();

            configuration.UserName = configuration.UserName ?? configuration.NickName;
            configuration.RealName = configuration.RealName?? configuration.NickName;

            this.Configuration = configuration;

            this.commandPrefix = string.Format("{0}", this.Configuration.NickName.ToLower());

            this.client = new IrcClient();
        }

 public void ConnectAndSetup()
 {
     _client = new IrcClient();
     _client.Connect("irc.homelien.no", 6667, false, new IrcUserRegistrationInfo
         {
             NickName = "testL",
             UserName = "testLK",
             RealName = "LarsBot"
         });
     _client.Connected += ClientOnConnected;
     _client.Disconnected += _client_Disconnected;
     _client.RawMessageReceived += _client_RawMessageReceived;
     _client.Error += ClientOnError;
     _client.ErrorMessageReceived += ClientOnErrorMessageReceived;
 }

 public SpeedRunsLiveIRC(LiveSplitState state, ITimerModel model, IEnumerable<string> channels)
 {
     ChannelsToJoin = channels.ToList();
     Client = new IrcClient();
     Client.ConnectFailed += Client_ConnectFailed;
     Client.Connected += Client_Connected;
     Client.Registered += Client_Registered;
     Client.RawMessageReceived += Client_RawMessageReceived;
     Client.ConnectFailed += Client_ConnectFailed;
     Client.Disconnected += Client_Disconnected;
     Model = model;
     state.OnSplit += Model_OnSplit;
     state.OnUndoSplit += Model_OnUndoSplit;
     state.OnReset += Model_OnReset;
     RaceState = RaceState.NotInRace;
 }

        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 INetwork Connect(INetwork network, IUser user)
        {
            IrcClient ircClient = new IrcClient();
            INetwork connection = this.RegisterNetwork(ircClient, network);

            this.OnNetworkAdded(connection);

            ircClient.Connect(network.Url.Host, network.Url.Port, false, new IrcUserRegistrationInfo()
            {
                NickName = user.Nickname,
                RealName = user.Realname,
                UserName = user.Nickname,
            });

            return network;
        }

        public TwitchChat(string accessToken, string channel)
        {
            Client = new IrcClient();
            UserFlags = new Dictionary<string, ChatBadges>();
            UserColors = new Dictionary<string, Color>();
            var twitch = Twitch.Instance;
            Client.Connected += Client_Connected;
            Client.Registered += Client_Registered;
            Channel = channel;

            Client.Connect("irc.twitch.tv", 6667,
                new IrcUserRegistrationInfo()
                {
                    NickName = twitch.ChannelName,
                    Password = $"oauth:{accessToken}"
                });
        }

        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);
        }