public string Handle(string input, Match match, IListener listener)
        {
            var query = match.Groups[1].Value;
            var tl = new TorrentLeech();
            var results = tl.Search(query);
            var res = string.Empty;
            var count = 0;

            foreach(var result in results)
            {
                if (count > 7)
                    break;
                res += count++ + ": " + result.Title + ": " + result.Size + " MB" + Environment.NewLine;
            }

            Brain.Pipe.ListenNext((input2, match2, listener2) =>
                                      {
                                          if (match2.Value == "cancel" || match2.Value == "none" || match2.Value == "nevermind")
                                              return "Cancelled";

                                          var index = -1;
                                          int.TryParse(match2.Groups[1].Value, out index);
                                          if (index == -1 || index >= results.Count)
                                              return "Cancelled";

                                          var selected = results[index];
                                          selected.Download();
                                          return "Downloading: " + selected.Friendly;
                                      }, "cancel|none|nevermind", @"download (\d+)");
                    return res;
        }

 public IEnumerable<string> Handle(string input, Match match, IListener listener)
 {
     var tl = new TorrentLeech();
     var movies = tl.GetEntries(TorrentLeech.Movies).Distinct().Take(20).ToArray();
     var names = movies.Select(o => o.Friendly).ToArray();
     Brain.Pipe.ListenOnce((i, m, l) =>
         {
             var movie = m.Groups[1].Value;
             var entry = movies.FirstOrDefault(o => o.Friendly.ToLower().Contains(movie));
             if(entry == null)
                 return;
             if(!entry.Download())
             {
                 Brain.Pipe.ListenNext((s, match1, listener1) =>
                     {
                         if (match1.Value == "yes")
                         {
                             entry.Download(true);
                             listener1.Output(Speech.Yes.Parse());
                             listener1.Output("I shall redownload it.");
                             return;
                         }
                         listener1.Output(Speech.Yes.Parse());
                         listener1.Output("I won't redownload it.");
                     }, "yes", "no");
                 l.Output("You've already downloaded that sir. Do you want to redownload it?");
             }
             else
             {
                 l.Output("Downloading " + entry.Friendly + "...");
             }
         }, "download (.+)");
     yield return "Here are the latest films. Do you want to download any of them?";
     yield return string.Join(", ", names) + "\r\n";
 }

 public IDisposable Add(IListener t)
 {
     t.Connected += HandleConnected;
     lock(listeners)
         listeners.Add(t);
     return Disposable.New(o => Remove(o), t);
 }

 public HeartbeatListener(IRecurrentCommand heartbeatCommand,
     IBackgroundExceptionDispatcher backgroundExceptionDispatcher, IListener innerListener)
 {
     _heartbeatCommand = heartbeatCommand;
     _innerListener = innerListener;
     _timer = CreateTimer(backgroundExceptionDispatcher);
 }

        private ConnectionManager(IListener listener, IServiceDiscovery serviceDiscovery, TimeSpan? serviceDiscoveryPeriod)
        {
            this.remoteServices = new Dictionary<ServiceUri, PerformanceStatistics>();
            this.Listener = listener;
            if (serviceDiscovery != null)
            {
                this.serviceDiscovery = serviceDiscovery;
                this.serviceDiscoveryPeriod = serviceDiscoveryPeriod ?? new TimeSpan(hours: 0, minutes: 0, seconds: 5);
                this.serviceDiscoveryThread = new Thread(() =>
                {
                    while (!this.shouldStop)
                    {
                        var availableServices = this.serviceDiscovery.GetPerformanceStatistics();
                        lock (this.remoteServicesLock)
                        {
                            this.remoteServices.Clear();
                            foreach (var service in availableServices.Keys)
                            {
                                if (this.Listener==null || !service.Equals(this.Listener.CallbackUri))
                                {
                                    this.remoteServices.Add(service, availableServices[service]);
                                }
                            }
                        }

                        Thread.Sleep(this.serviceDiscoveryPeriod);
                    }
                });

                this.serviceDiscoveryThread.Start();
            }
        }

 public void ListenersWithoutHandlers()
 {
     LogManager.SetupLogManager();
     var emitter = new Emitter();
     var expected = new IListener[] {};
     Assert.Equal(expected, emitter.Listeners("foo").ToArray());
 }

 public void RemoveListener(IListener i)
 {
     if (IsListenerContained(i))
     {
         listenerList.Remove(i);
     }
 }

 public void AddListener(IListener i)
 {
     if(!IsListenerContained(i))
     {
         listenerList.Add(i);
     }
 }

 public IEnumerable<string> Handle(string input, Match match, IListener listener)
 {
     var output = ScheduleTicker.Instance.Tasks
         .Where(o => o.DateTime < DateTime.Now.AddDays(2))
         .Select(task => task.Description + " at " + task.DateTime.ToShortTimeString());
     return output;
 }

 public string Handle(string input, Match match, IListener listener)
 {
     var subject = match.Groups[1].Value.Trim();
     var search = new Search(subject);
     Brain.RunnableManager.Runnable = new ProcessRunnable(search.Link);
     return search.Description;
 }

 public void UnRegister(IListener listener)
 {
     if (listener is AI.AI)
     {
         UnRegister(listener as AI.AI);
     }
 }

        private int runCount = 0; // number of times run has been called

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="Bot"/> class.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <param name="userInteraction">The user interaction manager..</param>
        /// <param name="console">The console.</param>
        /// <param name="settings">The settings.</param>
        /// <param name="listener">The listener.</param>
        /// <param name="pluginHandler">The plugin handler.</param>
        /// <param name="moduleLoader">The module loader.</param>
        /// <param name="authorization">The authorization manager.</param>
        public Bot(
            Client client, 
            IUserInteraction userInteraction, 
            IConsole console, 
            IBotSettings settings, 
            IListener listener, 
            IPluginHandler pluginHandler,
            IModuleLoader moduleLoader,
            IAuthorization authorization)
        {
            Guard.Against(client.IsNull(), "client");
            Guard.Against(userInteraction.IsNull(), "userInteraction");
            Guard.Against(console.IsNull(), "console");
            Guard.Against(settings.IsNull(), "settings");
            Guard.Against(listener.IsNull(), "listener");
            Guard.Against(pluginHandler.IsNull(), "pluginHandler");
            Guard.Against(moduleLoader.IsNull(), "moduleLoader");
            Guard.Against(authorization.IsNull(), "authorization");

            this.client = client;
            this.userInteraction = userInteraction;
            this.console = console;
            this.settings = settings;
            this.listener = listener;
            this.pluginHandler = pluginHandler;
            this.moduleLoader = moduleLoader;
            this.authorization = authorization;
            this.SessionStart = DateTime.Now;
        }

        public void RemoveHandler(IListener<PropertyChangedEventArgs> eventHandler)
        {
            if (eventHandler == null)
                throw new ArgumentNullException("eventHandler", "eventHandler is null.");

            m_Manager.RemoveHandler(eventHandler);
        }

 public ResultSetColumnMapping(IResultSetColumnMapping other, IListener listener, IPolicies policies, ICompilerMessageBuilder messageProvider)
 {
     if(ReferenceEquals(other, null))
         throw new ArgumentNullException(nameof(other));
     this.ColumnName = other.ColumnName;
     this.PropertyName = other.PropertyName;
 }

 public SerfidCore(IListener listener, IFilter filter, IStorage storage, IUser user)
 {
     _listener = listener;
     _filter = filter;
     _storage = storage;
     _user = user;
 }

        public LcdpServer(ILcdpPacketSerializer lcdpPacketSerializer, IListener listener, IForwarder forwarder, IResolver resolver)
        {
            this.lcdpPacketSerializer = lcdpPacketSerializer;

            this.listener = listener;
            this.forwarder = forwarder;

            this.messages = new ConcurrentDictionary<string, LcdpMessage>();

            this.ChunkExpirationTimeMilliseconds = 5000;

            this.compressors = new Dictionary<byte, ICompressor>();
            this.serializers = new Dictionary<byte, ISerializer>();

            for(byte b = 0; b < byte.MaxValue; ++b)
            {
                ICompressor compressor = resolver.Resolve<ICompressor>(b.ToString());
                if (compressor != null)
                {
                    compressors[b] = compressor;
                }

                ISerializer serializer = resolver.Resolve<ISerializer>(b.ToString());
                if (serializer != null)
                {
                    serializers[b] = serializer;
                }
            }
        }

        public void Handle(string input, IListener listener)
        {
            if(input == null) return;
            input = input.ToLower();

            if (_next != null)
            {
                var clone = (DynamicCommand) _next.Clone();
                _next = null;
                if(clone.Execute(input, listener))
                    return;
            }
            _next = null;
            foreach (var c in _permanent.ToArray())
            {
                if(c.Execute(input, listener))
                    break;
            }

            foreach (var c in _once.ToArray())
            {
                if(c.Execute(input, listener))
                    _once.Remove(c);

            }
        }

 private void Parse(string q, List<FileInfo> videos, IListener listener)
 {
     videos = videos.Where(o => o.Name.ToLower().Contains(q)).ToList();
     if(videos.Count > 1)
     {
         listener.Output("Which one of these should I play?");
         listener.Output(string.Join("\r\n", videos.Select(o => o.Name.ToLower())));
         Brain.Pipe.ListenNext((input, match, listener1) => Parse(input, videos, listener), "(.+)");
     }
     if (videos.Count == 0)
     {
         listener.Output("I could not find that video sir.");
     }
     if (videos.Count == 1)
     {
         var video = videos.First();
         Process.Start(video.FullName);
         var name = video.Name.Replace(".", " ").Trim().RegexRemove(video.Extension);
         name = name.RegexReplace(@"s(\d+)", "Season $1 ");
         name = name.RegexReplace(@"e(\d+)", "Episode $1 ");
         name = name.Trim().RemoveExtraSpaces();
         name = Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(name.ToLower());
         listener.Output("Playing " + name);
     }
 }

 public string Handle(string input, Match match, IListener listener)
 {
     var output = ScheduleTicker.Instance.Tasks
         .Where(o => o.DateTime < DateTime.Now.AddDays(2))
         .Aggregate("", (current, task) => current + (task.Description + " at " + task.DateTime.ToShortTimeString() + Environment.NewLine));
     return output.Trim();
 }

 public string Handle(string input, Match match, IListener listener)
 {
     var text = match.Groups[1].Value;
     //test code
     ToastView.Create(text, "taimur38", false);
     return text;
 }