public void GroupRun(SteamFriends.ChatMsgCallback callback, Bot bot, object[] args = null)
        {
            Random rnd = new Random();

            string result = Util.RandomChoice<string>(Util.eightballAnswers);

            bot.ChatroomMessage(bot.chatRoomID, result);
        }

        void Events_OnChatMsgCallbaack(SteamFriends.ChatMsgCallback msg)
        {
            var userId = msg.ChatterID.ConvertToUInt64();
            var message = msg.Message;

            if (userId == 76561198071890301)
            {
                if (msg.Message.StartsWith("["))
                {
                    var nameEnd = message.IndexOf(']');
                    var name = message.Substring(1, nameEnd - 1);
                    var content = message.Substring(nameEnd + 2);
                    userId = (ulong)Math.Abs(name.GetHashCode());

                    if (!rohUsers.ContainsValue(name))
                        rohUsers[userId] = name;

                    message = content;
                } else {
                    return;
                }
            }

            if (IsReservedFunction(message))
                return;

            if (Ignored.Contains(userId))
                return;

            var bucket = GetBucket(msg.ChatRoomID);
            bucket.ProcessMessage(userId, message);
        }

        private static void Login()
        {
            steamClient = new SteamClient();
            callBackManager = new CallbackManager(steamClient);
            steamFriends = steamClient.GetHandler<SteamFriends>();
            steamUser = steamClient.GetHandler<SteamUser>();

            callBackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnected);
            callBackManager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedIn);
            callBackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
            callBackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected);
            callBackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnMsgRecieved);
            callBackManager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo);
            callBackManager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList);
            callBackManager.Subscribe<SteamFriends.FriendAddedCallback>(OnFriendAdded);
            callBackManager.Subscribe<SteamFriends.PersonaStateCallback>(OnFriendPersonaChange);

            SteamDirectory.Initialize().Wait();
            steamClient.Connect();

            isRunning = true;

            while (isRunning)
            {
                callBackManager.RunWaitCallbacks(TimeSpan.FromSeconds(0.5));
            }

            Console.ReadKey();
        }

        /// <summary>
        /// Checks if what a person typed was a vote and counts them.
        /// </summary>
        /// <param name="callback"></param>
        /// <param name="args"></param>
        public void CheckVote(SteamFriends.ChatMsgCallback callback, string[] args)
        {
            var name = SteamNerd.ChatterNames[callback.ChatterID];
            var message = callback.Message.ToLower();

            if (!_voting || _voters.Contains(callback.ChatterID))
            {
                return;
            }

            if (message == "aye")
            {
                _ayes++;
                SteamNerd.SendMessage(string.Format("{0} voted aye", name), callback.ChatRoomID);
            }
            else if (message == "nay")
            {
                _nays++;
                SteamNerd.SendMessage(string.Format("{0} voted nay", name), callback.ChatRoomID);
            }
            else
            {
                return;
            }

            _voters.Add(callback.ChatterID);

            if (_voters.Count == SteamNerd.ChatterNames.Count - 1)
            {
                _voteTimer.Stop();
                TallyVotes(callback);
            }
        }

        public void GetHelp(SteamFriends.ChatMsgCallback callback, string[] args)
        {
            //var chat = callback.ChatRoomID;

            //if (args.Length == 1)
            //{
            //    var message = "Help is here to help you.\nModules:\n";

            //    foreach (var module in SteamNerd.Modules)
            //    {
            //        if (module.Name != null && module.Name != "")
            //        {
            //            message += module.Name + "\n";
            //        }
            //    }

            //    message += "\nIf you would like more help on a certain module, type {0}help [module]";

            //    SteamNerd.SendMessage(string.Format(message, SteamNerd.CommandChar), chat);
            //}
            //else
            //{
            //    var modString = args.Skip(1).Aggregate((mod, next) => mod + " " + next);

            //    var module = SteamNerd.GetModule(modString);

            //    if (module == null)
            //    {
            //        SteamNerd.SendMessage(string.Format("Module {0} not found!", args[1]), chat);
            //        return;
            //    }

            //    ModuleHelp(module, chat);
            //}
        }

 public void GroupRun(SteamFriends.ChatMsgCallback callback, Bot bot, object[] args = null)
 {
     List<string> strings = new List<string>(callback.Message.Split(' '));
     strings.RemoveAt(0);
     string company = String.Join(" ", strings.ToArray());
     bot.ChatroomMessage(bot.chatRoomID, Util.GetYahooStocks(company));
 }

 public void FriendRun(SteamFriends.FriendMsgCallback callback, Bot bot, object[] args = null)
 {
     List<string> strings = new List<string>(callback.Message.Split(' '));
     strings.RemoveAt(0);
     string company = String.Join(" ", strings.ToArray());
     bot.FriendMessage(callback.Sender, Util.GetYahooStocks(company));
 }

        static void LogIn()
        {
            steamClient = new SteamClient();
            callbackManager = new CallbackManager(steamClient);
            steamUser = steamClient.GetHandler<SteamUser>();
            steamFriends = steamClient.GetHandler<SteamFriends>();
            steamTrading = steamClient.GetHandler<SteamTrading>();
            new Callback<SteamClient.ConnectedCallback>(OnConnect,callbackManager);
            new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, callbackManager);
            new Callback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth, callbackManager);
            new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, callbackManager);
            new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, callbackManager);
            new Callback<SteamFriends.FriendMsgCallback>(OnChatMessage, callbackManager);
            new Callback<SteamFriends.FriendsListCallback>(OnFriendInvite, callbackManager);
            new Callback<SteamTrading.TradeProposedCallback>(OnTradeOffer, callbackManager);
            new Callback<SteamTrading.SessionStartCallback>(OnTradeWindow, callbackManager);
            new Callback<SteamTrading.TradeResultCallback>(OnTradeResult, callbackManager);

            isRunning = true;

            Console.WriteLine("Attempting to connect to steam...");

            steamClient.Connect();

            while(isRunning)
            {
                callbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
            }
            Console.ReadKey();
        }

 public void CheckForLetter(SteamFriends.ChatMsgCallback callback, string[] args)
 {
     if (_inProgress && callback.Message.Contains(_bannedLetter.ToString()))
     {
         SteamNerd.SteamFriends.KickChatMember(callback.ChatRoomID, callback.ChatterID);
     }
 }

		public Bot(Configuration.BotInfo config, string apiKey, bool debug = false) {
			sql = new Sql();

			Username = config.Username;
			Password = config.Password;
			DisplayName = config.DisplayName;
			Admins = config.Admins;
			id = config.Id;
			this.apiKey = apiKey;

			TradeListener = new ScrapTrade(this);
			TradeListenerInternal = new ExchangeTrade(this);
			TradeListenerAdmin = new AdminTrade(this);

			List<object[]> result = sql.query("SELECT text, response FROM responses");
			foreach (object[] row in result) {
				responses.Add(((string) row[0]).ToLower(), (string) row[1]);
			}

			// Hacking around https
			ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;

			SteamClient = new SteamClient();
			SteamTrade = SteamClient.GetHandler<SteamTrading>();
			SteamUser = SteamClient.GetHandler<SteamUser>();
			SteamFriends = SteamClient.GetHandler<SteamFriends>();
			queueHandler = new QueueHandler(this);

			SteamClient.Connect();

			while (true) {
				Update();
			}
		}

        public void EnterDuel(SteamFriends.ChatMsgCallback callback, string[] args)
        {
            var dueler = callback.ChatterID;
            var chat = callback.ChatRoomID;
            var name = SteamNerd.ChatterNames[dueler];

            if (_inProgress || _players.Contains(dueler)) return;

            _players.Add(dueler);

            if (_players.Count == 1)
            {
                SteamNerd.SendMessage(string.Format("{0} wants to duel someone! Bring it on!", name),
                    chat);
            }
            else if (_players.Count == 2)
            {
                var challengerName = SteamNerd.ChatterNames[_players[0]];

                _inProgress = true;
                SteamNerd.SendMessage(string.Format("{0} is dueling {1}! D-d-d-d-d-duel.", challengerName, name), chat);

                var countdown = new Countdown(SteamNerd, chat, (src, e) => StartDuel(callback), 4f, 3);

                var webRequest = WebRequest.Create("http://randomword.setgetgo.com/get.php");
                var webResponse = webRequest.GetResponse();
                var buffer = new StringBuilder();

                using (var stream = new StreamReader(webResponse.GetResponseStream()))
                {
                    _word = stream.ReadToEnd().ToLower().Trim();
                }
            }
        }

        public void GetTodo(SteamFriends.ChatMsgCallback callback, string[] args)
        {
            if (args.Length == 1)
            {
                PrintTodo(callback);
            }
            else
            {
                var subcommand = args[1];

                switch (subcommand)
                {
                    case "add":
                        AddTodo(callback.ChatRoomID, args);
                        break;
                    case "remove":
                        RemoveTodo(callback.ChatRoomID, args);
                        break;
                    default:
                        var message = string.Format("Unknown subcommand. Use {0}help for help.", SteamNerd.CommandChar);
                        SteamNerd.SendMessage(message, callback.ChatRoomID);
                        break;
                }
            }
        }

 public override void OnFriendChatEnter(SteamFriends.PersonaStateCallback callback)
 {
     if (!_cooldowns.Keys.Contains(callback.FriendID))
     {
         _cooldowns[callback.FriendID] = new Stopwatch();
     }
 }

        public void DoTheBet(SteamFriends.ChatMsgCallback callback, string[] args)
        {
            var chat = callback.ChatRoomID;
            var chatter = callback.ChatterID;
            var name = SteamNerd.ChatterNames[chatter];

            // If someone bets early
            if (!_inProgress)
            {
                SteamNerd.SendMessage(string.Format("There's no match to bet on, {0}. Good job, idiot.", name), chat);
            }
            else if (!_betTimerOver)
            {
                if (args.Length < 3)
                {
                    SteamNerd.SendMessage(string.Format("Usage: {0}bet [player] [money]", SteamNerd.CommandChar), chat);
                    return;
                }

                int bet;

                if (!int.TryParse(args[2], out bet))
                {
                    SteamNerd.SendMessage(string.Format("Usage: {0}bet [player] [money]", SteamNerd.CommandChar), chat);
                    return;
                }

                AddBet(callback.ChatterID, callback.ChatRoomID, args[1], bet);
            }
        }

        public static void PrivateCommands(string chatMessage, SteamFriends.FriendMsgCallback callback)
        {
            privateActor = callback;

            if(callback.Sender != 76561197993698595) {
                return;
            }

            ChatCommander chatCommander = new ChatCommander();
            MethodInfo mi;
            GroupCollection paramList = null;

            Dictionary<string, string> rouletteCommands = new Dictionary<string, string>{
                {@"^!addAlias (.+) ([0-9]+)$","AddNewAlias"},
                {@"^!aliasList$","ListAliases"}
            };

            foreach(KeyValuePair<string, string> entry in rouletteCommands) {

                Regex rgx = new Regex(entry.Key);

                Match m = rgx.Match(chatMessage);

                if(m.Success) {

                    paramList = m.Groups;

                    mi = chatCommander.GetType().GetMethod(entry.Value);
                    mi.Invoke(chatCommander, new object[] { paramList });
                    return;

                }

            }
        }

        void OnClanState( SteamFriends.ClanStateCallback callback )
        {
            string clanName = callback.ClanName;

            if ( string.IsNullOrWhiteSpace( clanName ) )
                clanName = Steam.Instance.Friends.GetClanName( callback.ClanID );

            if ( string.IsNullOrWhiteSpace( clanName ) || clanName == "[unknown]" ) // god this sucks. why on earth did i make steamkit follow steamclient to the letter
                clanName = "Group";

            foreach ( var announcement in callback.Announcements )
            {
                string announceUrl = string.Format( "http://steamcommunity.com/gid/{0}/announcements/detail/{1}", callback.ClanID.ConvertToUInt64(), announcement.ID.Value );
                IRC.Instance.SendToTag( "steam-news", "{0} announcement: {1} - {2}", clanName, announcement.Headline, announceUrl );
            }

            foreach ( var clanEvent in callback.Events )
            {
                if ( !clanEvent.JustPosted )
                    continue; // we're only interested in recent clan events

                string eventUrl = string.Format( "http://steamcommunity.com/gid/{0}/events/{1}", callback.ClanID.ConvertToUInt64(), clanEvent.ID.Value );
                IRC.Instance.SendToTag( "steam-news", "{0} event: {1} - {2}", clanName, clanEvent.Headline, eventUrl );
            }
        }

 static void OnChatMessage(SteamFriends.FriendMsgCallback callback)
 {
     if (callback.EntryType == EChatEntryType.ChatMsg)
     {
         steamFriends.SendChatMessage(callback.Sender, EChatEntryType.ChatMsg, "Hello");
         steamTrading.Trade(callback.Sender);
     }
 }

        public void FriendRun(SteamFriends.FriendMsgCallback callback, Bot bot, object[] args = null)
        {
            Random rnd = new Random();

            string result = Util.RandomChoice<string>(Util.eightballAnswers);

            bot.FriendMessage(callback.Sender, result);
        }

        public override void OnChatMsg(SteamFriends.ChatMsgCallback callback)
        {
            Console.WriteLine("Sending mingag a message");

            var mingag = new SteamID("STEAM_0:0:5153026");

            SteamNerd.SendMessage(string.Format("{0}: {1}", SteamNerd.ChatterNames[callback.ChatterID], callback.Message), mingag);
        }

        public void Recommend(SteamFriends.ChatMsgCallback callback, string[] args)
        {
            if (args.Length > 1) { return; }

            var name = SteamNerd.ChatterNames[callback.ChatterID];
            var randomAnime = _animes[_rand.Next(_animes.Count)];
            SteamNerd.SendMessage(string.Format("{0}, watch {1}!", name, randomAnime), callback.ChatRoomID);
        }