//
// Yet Another POD-Bot, based on PODBot by Markus Klinge ("CountFloyd").
// Copyright (c) Yet Another POD-Bot Contributors <yapb@entix.io>.
//
// This software is licensed under the MIT license.
// Additional exceptions apply. For full license details, see LICENSE.txt
//

#include <yapb.h>

ConVar yb_display_menu_text ("yb_display_menu_text", "1", "Enables or disables display menu text, when players asks for menu. Useful only for Android.");
ConVar yb_password ("yb_password", "", "The value (password) for the setinfo key, if user set's correct password, he's gains access to bot commands and menus.", false, 0.0f, 0.0f, Var::Password);
ConVar yb_password_key ("yb_password_key", "_ybpw", "The name of setinfo key used to store password to bot commands and menus", false);

int BotControl::cmdAddBot () {
   enum args { alias = 1, difficulty, personality, team, model, name, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // this is duplicate error as in main bot creation code, but not to be silent
   if (!graph.length () || graph.hasChanged ()) {
      ctrl.msg ("There is no graph found or graph is changed. Cannot create bot.");
      return BotCommandResult::Handled;
   }

   // if team is specified, modify args to set team
   if (m_args[alias].find ("_ct", 0) != String::InvalidIndex) {
      m_args.set (team, "2");
   }
   else if (m_args[alias].find ("_t", 0) != String::InvalidIndex) {
      m_args.set (team, "1");
   }

   // if highskilled bot is requsted set personality to rusher and maxout difficulty
   if (m_args[alias].find ("hs", 0) != String::InvalidIndex) {
      m_args.set (difficulty, "4");
      m_args.set (personality, "1");
   }
   bots.addbot (m_args[name], m_args[difficulty], m_args[personality], m_args[team], m_args[model], true);

   return BotCommandResult::Handled;
}

int BotControl::cmdKickBot () {
   enum args { alias = 1, team, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // if team is specified, kick from specified tram
   if (m_args[alias].find ("_ct", 0) != String::InvalidIndex || getInt (team) == 2 || getStr (team) == "ct") {
      bots.kickFromTeam (Team::CT);
   }
   else if (m_args[alias].find ("_t", 0) != String::InvalidIndex || getInt (team) == 1 || getStr (team) == "t") {
      bots.kickFromTeam (Team::Terrorist);
   }
   else {
      bots.kickRandom ();
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdKickBots () {
   enum args { alias = 1, instant, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // check if we're need to remove bots instantly
   auto kickInstant = getStr (instant) == "instant";

   // kick the bots
   bots.kickEveryone (kickInstant);

   return BotCommandResult::Handled;
}

int BotControl::cmdKillBots () {
   enum args { alias = 1, team, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // if team is specified, kick from specified tram
   if (m_args[alias].find ("_ct", 0) != String::InvalidIndex || getInt (team) == 2 || getStr (team) == "ct") {
      bots.killAllBots (Team::CT);
   }
   else if (m_args[alias].find ("_t", 0) != String::InvalidIndex || getInt (team) == 1 || getStr (team) == "t") {
      bots.killAllBots (Team::Terrorist);
   }
   else {
      bots.killAllBots ();
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdFill () {
   enum args { alias = 1, team, count, difficulty, personality, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   if (!hasArg (team)) {
      return BotCommandResult::BadFormat;
   }
   bots.serverFill (getInt (team), hasArg (personality) ? getInt (personality) : -1, hasArg (difficulty) ? getInt (difficulty) : -1, hasArg (count) ? getInt (count) : -1);

   return BotCommandResult::Handled;
}

int BotControl::cmdVote () {
   enum args { alias = 1, mapid, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   if (!hasArg (mapid)) {
      return BotCommandResult::BadFormat;
   }
   int mapID = getInt (mapid);

   // loop through all players
   for (const auto &bot : bots) {
      bot->m_voteMap = mapID;
   }
   msg ("All dead bots will vote for map #%d.", mapID);

   return BotCommandResult::Handled;
}

int BotControl::cmdWeaponMode () {
   enum args { alias = 1, type, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   if (!hasArg (type)) {
      return BotCommandResult::BadFormat;
   }
   Dictionary <String, int> modes;

   modes.push ("kinfe", 1);
   modes.push ("pistol", 2);
   modes.push ("shotgun", 3);
   modes.push ("smg", 4);
   modes.push ("rifle", 5);
   modes.push ("sniper", 6);
   modes.push ("standard", 7);

   auto mode = getStr (type);

   // check if selected mode exists
   if (!modes.exists (mode)) {
      return BotCommandResult::BadFormat;
   }
   bots.setWeaponMode (modes[mode]);

   return BotCommandResult::Handled;
}

int BotControl::cmdVersion () {
   auto hash = String (PRODUCT_GIT_HASH).substr (0, 8);
   auto author = String (PRODUCT_GIT_COMMIT_AUTHOR);

   // if no hash specified, set local one
   if (hash.startsWith ("unspe")) {
      hash = "local";
   }

   // if no commit author, set local one
   if (author.startsWith ("unspe")) {
      author = PRODUCT_EMAIL;
   }

   msg ("%s v%s (build %u)", PRODUCT_NAME, PRODUCT_VERSION, util.buildNumber ());
   msg ("  compiled: %s %s by %s", __DATE__, __TIME__, author.chars ());

   if (!hash.startsWith ("local")) {
      msg ("  commit: %scommit/%s", PRODUCT_COMMENTS, hash.chars ());
   }
   msg ("  url: %s", PRODUCT_URL);

   return BotCommandResult::Handled;
}

int BotControl::cmdNodeMenu () {
   enum args { alias = 1, max };

   // graph editor is available only with editor
   if (!graph.hasEditor ()) {
      msg ("Unable to open graph editor without setting the editor player.");
      return BotCommandResult::Handled;
   }
   showMenu (Menu::NodeMainPage1);

   return BotCommandResult::Handled;
}

int BotControl::cmdMenu () {
   enum args { alias = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // reset the current menu
   showMenu (Menu::None);

   if (getStr (cmd) == "cmd" && util.isAlive (m_ent)) {
      showMenu (Menu::Commands);
   }
   else {
      showMenu (Menu::Main);
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdList () {
   enum args { alias = 1, max };

   bots.listBots ();
   return BotCommandResult::Handled;
}

int BotControl::cmdCvars () {
   enum args { alias = 1, pattern, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   const auto &match = getStr (pattern);
   const bool isSave = match == "save";

   File cfg;

   // if save requested, dump cvars to yapb.cfg
   if (isSave) {
      cfg.open (strings.format ("%s/addons/yapb/conf/yapb.cfg", game.getModName ()), "wt");

      cfg.puts ("// Configuration file for %s\n\n", PRODUCT_SHORT_NAME);
   }

   for (const auto &cvar : game.getCvars ()) {
      if (cvar.info.empty ()) {
         continue;
      }

      if (!isSave && match != "empty" && !strstr (cvar.reg.name, match.chars ())) {
         continue;
      }

      // float value ?
      bool isFloat = !strings.isEmpty (cvar.self->str ()) && strstr (cvar.self->str (), ".");

      if (isSave) {
         cfg.puts ("//\n");
         cfg.puts ("// %s\n", String::join (cvar.info.split ("\n"), "\n//  ").chars ());
         cfg.puts ("// ---\n");

         if (cvar.bounded) {
            if (isFloat) {
               cfg.puts ("// Default: \"%.1f\", Min: \"%.1f\", Max: \"%.1f\"\n", cvar.initial, cvar.min, cvar.max);
            }
            else {
               cfg.puts ("// Default: \"%i\", Min: \"%i\", Max: \"%i\"\n", static_cast <int> (cvar.initial), static_cast <int> (cvar.min), static_cast <int> (cvar.max));
            }
         }
         else {
            cfg.puts ("// Default: \"%s\"\n", cvar.self->str ());
         }
         cfg.puts ("// \n");

         if (cvar.bounded) {
            if (isFloat) {
               cfg.puts ("%s \"%.1f\"\n", cvar.reg.name, cvar.self->float_ ());
            }
            else {
               cfg.puts ("%s \"%i\"\n", cvar.reg.name, cvar.self->int_ ());
            }
         }
         else {
            cfg.puts ("%s \"%s\"\n", cvar.reg.name, cvar.self->str ());
         }
         cfg.puts ("\n");
      }
      else {
         game.print ("cvar: %s", cvar.reg.name);
         game.print ("info: %s", cvar.info.chars ());

         game.print (" ");
      }
   }

   if (isSave) {
      msg ("Bots cvars has been written to file.");
      cfg.close ();
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNode () {
   enum args { root, alias, cmd, cmd2, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // graph editor supported only with editor
   if (game.isDedicated () && !graph.hasEditor () && getStr (cmd) != "acquire_editor") {
      msg ("Unable to use graph edit commands without setting graph editor player. Please use \"graph acquire_editor\" to acquire rights for graph editing.");
      return BotCommandResult::Handled;
   }

   // should be moved to class?
   static Dictionary <String, BotCmd> commands;
   static StringArray descriptions;

   // fill only once
   if (descriptions.empty ()) {

      // separate function
      auto pushGraphCmd = [&] (String cmd, String format, String help, Handler handler) -> void {
         BotCmd botCmd (cr::move (cmd), cr::move (format), cr::move (help), cr::move (handler));

         commands.push (cmd, cr::move (botCmd));
         descriptions.push (cmd);
      };

      // add graph commands
      pushGraphCmd ("on", "on [display|auto|noclip|models]", "Enables displaying of graph, nodes, noclip cheat", &BotControl::cmdNodeOn);
      pushGraphCmd ("off", "off [display|auto|noclip|models]", "Disables displaying of graph, auto adding nodes, noclip cheat", &BotControl::cmdNodeOff);
      pushGraphCmd ("menu", "menu [noarguments]", "Opens and displays bots graph edtior.", &BotControl::cmdNodeMenu);
      pushGraphCmd ("add", "add [noarguments]", "Opens and displays graph node add menu.", &BotControl::cmdNodeAdd);
      pushGraphCmd ("addbasic", "menu [noarguments]", "Adds basic nodes such as player spawn points, goals and ladders.", &BotControl::cmdNodeAddBasic);
      pushGraphCmd ("save", "save [noarguments]", "Save graph file to disk.", &BotControl::cmdNodeSave);
      pushGraphCmd ("load", "load [noarguments]", "Load graph file from disk.", &BotControl::cmdNodeLoad);
      pushGraphCmd ("erase", "erase [iamsure]", "Erases the graph file from disk.", &BotControl::cmdNodeErase);
      pushGraphCmd ("delete", "delete [nearest|index]", "Deletes single graph node from map.", &BotControl::cmdNodeDelete);
      pushGraphCmd ("check", "check [noarguments]", "Check if graph working correctly.", &BotControl::cmdNodeCheck);
      pushGraphCmd ("cache", "cache [nearest|index]", "Caching node for future use.", &BotControl::cmdNodeCache);
      pushGraphCmd ("clean", "clean [all|nearest|index]", "Clean useless path connections from all or single node.", &BotControl::cmdNodeClean);
      pushGraphCmd ("setradius", "setradius [radius] [nearest|index]", "Sets the radius for node.", &BotControl::cmdNodeSetRadius);
      pushGraphCmd ("flags", "flags [noarguments]", "Open and displays menu for modifying flags for nearest point.", &BotControl::cmdNodeSetFlags);
      pushGraphCmd ("teleport", "teleport [index]", "Teleports player to specified node index.", &BotControl::cmdNodeTeleport);
      pushGraphCmd ("upload", "upload [id]", "Uploads created graph to graph database.", &BotControl::cmdNodeUpload);

      // add path commands
      pushGraphCmd ("path_create", "path_create [noarguments]", "Opens and displays path creation menu.", &BotControl::cmdNodePathCreate);
      pushGraphCmd ("path_create_in", "path_create_in [noarguments]", "Opens and displays path creation menu.", &BotControl::cmdNodePathCreate);
      pushGraphCmd ("path_create_out", "path_create_out [noarguments]", "Opens and displays path creation menu.", &BotControl::cmdNodePathCreate);
      pushGraphCmd ("path_create_both", "path_create_both [noarguments]", "Opens and displays path creation menu.", &BotControl::cmdNodePathCreate);
      pushGraphCmd ("path_delete", "path_create_both [noarguments]", "Opens and displays path creation menu.", &BotControl::cmdNodePathDelete);
      pushGraphCmd ("path_set_autopath", "path_set_autoath [max_distance]", "Opens and displays path creation menu.", &BotControl::cmdNodePathSetAutoDistance);

      // camp points iterator
      pushGraphCmd ("iterate_camp", "iterate_camp [begin|end|next]", "Allows to go through all camp points on map.", &BotControl::cmdNodeIterateCamp);

      // remote graph editing stuff
      if (game.isDedicated ()) {
         pushGraphCmd ("acquire_editor", "acquire_editor [max_distance]", "Acquires rights to edit graph on dedicated server.", &BotControl::cmdNodeAcquireEditor);
         pushGraphCmd ("release_editor", "acquire_editor [max_distance]", "Releases graph editing rights.", &BotControl::cmdNodeAcquireEditor);
      }
   }
   if (commands.exists (getStr (cmd))) {
      auto item = commands[getStr (cmd)];

      // graph have only bad format return status
      int status = (this->*item.handler) ();

      if (status == BotCommandResult::BadFormat) {
         msg ("Incorrect usage of \"%s %s %s\" command. Correct usage is:\n\n\t%s\n\nPlease use correct format.", m_args[root].chars (), m_args[alias].chars (), item.name.chars (), item.format.chars ());
      }
   }
   else {
      if (getStr (cmd) == "help" && hasArg (cmd2) && commands.exists (getStr (cmd2))) {
         auto &item = commands[getStr (cmd2)];

         msg ("Command: \"%s %s %s\"\nFormat: %s\nHelp: %s", m_args[root].chars (), m_args[alias].chars (), item.name.chars (), item.format.chars (), item.help.chars ());
      }
      else {
         for (auto &desc : descriptions) {
            auto &item = commands[desc];
            msg ("   %s - %s", item.name.chars (), item.help.chars ());
         }
         msg ("Currently Graph Status %s", graph.hasEditFlag (GraphEdit::On) ? "Enabled" : "Disabled");
      }
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeOn () {
   enum args { alias = 1, cmd, option, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // enable various features of editor
   if (getStr (option) == "empty" || getStr (option) == "display" || getStr (option) == "models") {
      graph.setEditFlag (GraphEdit::On);
      enableDrawModels (true);

      msg ("Graph editor has been enabled.");
   }
   else if (getStr (option) == "noclip") {
      m_ent->v.movetype = MOVETYPE_NOCLIP;

      graph.setEditFlag (GraphEdit::On | GraphEdit::Noclip);
      enableDrawModels (true);

      msg ("Graph editor has been enabled with noclip mode.");
   }
   else if (getStr (option) == "auto") {
      graph.setEditFlag (GraphEdit::On | GraphEdit::Auto);
      enableDrawModels (true);

      msg ("Graph editor has been enabled with auto add node mode.");
   }

   if (graph.hasEditFlag (GraphEdit::On)) {
      extern ConVar mp_roundtime, mp_freezetime, mp_timelimit;

      mp_roundtime.set (9);
      mp_freezetime.set (0);
      mp_timelimit.set (0);
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeOff () {
   enum args { graph_cmd = 1, cmd, option, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // enable various features of editor
   if (getStr (option) == "empty" || getStr (option) == "display") {
      graph.clearEditFlag (GraphEdit::On | GraphEdit::Auto | GraphEdit::Noclip);
      enableDrawModels (false);

      msg ("Graph editor has been disabled.");
   }
   else if (getStr (option) == "models") {
      enableDrawModels (false);

      msg ("Graph editor has disabled spawn points highlighting.");
   }
   else if (getStr (option) == "noclip") {
      m_ent->v.movetype = MOVETYPE_WALK;
      graph.clearEditFlag (GraphEdit::Noclip);

      msg ("Graph editor has disabled noclip mode.");
   }
   else if (getStr (option) == "auto") {
      graph.clearEditFlag (GraphEdit::Auto);
      msg ("Graph editor has disabled auto add node mode.");
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeAdd () {
   enum args { graph_cmd = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   // show the menu
   showMenu (Menu::NodeType);
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeAddBasic () {
   enum args { graph_cmd = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   graph.addBasic ();
   msg ("Basic graph nodes was added.");

   return BotCommandResult::Handled;
}

int BotControl::cmdNodeSave () {
   enum args { graph_cmd = 1, cmd, option, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // if no check is set save anyway
   if (getStr (option) == "nocheck") {
      graph.saveGraphData ();

      msg ("All nodes has been saved and written to disk (IGNORING QUALITY CONTROL).");
   }
   else if (getStr (option) == "old") {
      graph.saveOldFormat ();

      msg ("All nodes has been saved and written to disk (POD-Bot Format (.pwf)).");
   }
   else {
      if (graph.checkNodes (false)) {
         graph.saveGraphData ();
         msg ("All nodes has been saved and written to disk.");
      }
      else {
         msg ("Could not save save nodes to disk. Graph check has failed.");
      }
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeLoad () {
   enum args { graph_cmd = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // just save graph on request
   if (graph.loadGraphData ()) {
      msg ("Graph successfully loaded.");
   }
   else {
      msg ("Could not load Graph. See console...");
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeErase () {
   enum args { graph_cmd = 1, cmd, iamsure, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // prevent accidents when graph are deleted unintentionally
   if (getStr (iamsure) == "iamsure") {
      graph.eraseFromDisk ();
   }
   else {
      msg ("Please, append \"iamsure\" as parameter to get graph erased from the disk.");
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeDelete () {
   enum args { graph_cmd = 1, cmd, nearest, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   // if "neareset" or nothing passed delete neareset, else delete by index
   if (getStr (nearest) == "empty" || getStr (nearest) == "nearest") {
      graph.erase (kInvalidNodeIndex);
   }
   else {
      int index = getInt (nearest);

      // check for existence
      if (graph.exists (index)) {
         graph.erase (index);
         msg ("Node %d has beed deleted.", index);
      }
      else {
         msg ("Could not delete node %d.", index);
      }
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeCheck () {
   enum args { graph_cmd = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // check if nodes are ok
   if (graph.checkNodes (true)) {
      msg ("Graph seems to be OK.");
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeCache () {
   enum args { graph_cmd = 1, cmd, nearest, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   // if "neareset" or nothing passed delete neareset, else delete by index
   if (getStr (nearest) == "empty" || getStr (nearest) == "nearest") {
      graph.cachePoint (kInvalidNodeIndex);

      msg ("Nearest node has been put into the memory.");
   }
   else {
      int index = getInt (nearest);

      // check for existence
      if (graph.exists (index)) {
         graph.cachePoint (index);
         msg ("Node %d has been put into the memory.", index);
      }
      else {
         msg ("Could not put node %d into the memory.", index);
      }
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeClean () {
   enum args { graph_cmd = 1, cmd, option, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   // if "all" passed clean up all the paths
   if (getStr (option) == "all") {
      int removed = 0;

      for (int i = 0; i < graph.length (); ++i) {
         removed += graph.clearConnections (i);
      }
      msg ("Done. Processed %d nodes. %d useless paths was cleared.", graph.length (), removed);
   }
   else if (getStr (option) == "empty" || getStr (option) == "nearest") {
      int removed = graph.clearConnections (graph.getEditorNeareset ());

      msg ("Done. Processed node %d. %d useless paths was cleared.", graph.getEditorNeareset (), removed);
   }
   else {
      int index = getInt (option);

      // check for existence
      if (graph.exists (index)) {
         int removed = graph.clearConnections (index);

         msg ("Done. Processed node %d. %d useless paths was cleared.", index, removed);
      }
      else {
         msg ("Could not process node %d clearance.", index);
      }
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeSetRadius () {
   enum args { graph_cmd = 1, cmd, radius, index, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // radius is a must
   if (!hasArg (radius)) {
      return BotCommandResult::BadFormat;
   }
   int radiusIndex = kInvalidNodeIndex;

   if (getStr (index) == "empty" || getStr (index) == "nearest") {
      radiusIndex = graph.getEditorNeareset ();
   }
   else {
      radiusIndex = getInt (index);
   }
   float value = getStr (radius).float_ ();

   graph.setRadius (radiusIndex, value);
   msg ("Node %d has been set to radius %.2f.", radiusIndex, value);

   return BotCommandResult::Handled;
}

int BotControl::cmdNodeSetFlags () {
   enum args { graph_cmd = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   //show the flag menu
   showMenu (Menu::NodeFlag);
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeTeleport () {
   enum args { graph_cmd = 1, cmd, teleport_index, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   if (!hasArg (teleport_index)) {
      return BotCommandResult::BadFormat;
   }
   int index = getInt (teleport_index);

   // check for existence
   if (graph.exists (index)) {
      engfuncs.pfnSetOrigin (graph.getEditor (), graph[index].origin);

      msg ("You have been teleported to node %d.", index);

      // turn graph on
      graph.setEditFlag (GraphEdit::On | GraphEdit::Noclip);
   }
   else {
      msg ("Could not teleport to node %d.", index);
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodePathCreate () {
   enum args { graph_cmd = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   // choose the direction for path creation
   if (m_args[cmd].find ("_both", 0) != String::InvalidIndex) {
      graph.pathCreate (PathConnection::Bidirectional);
   }
   else if (m_args[cmd].find ("_in", 0) != String::InvalidIndex) {
      graph.pathCreate (PathConnection::Incoming);
   }
   else if (m_args[cmd].find ("_out", 0) != String::InvalidIndex) {
      graph.pathCreate (PathConnection::Outgoing);
   }
   else {
      showMenu (Menu::NodePath);
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodePathDelete () {
   enum args { graph_cmd = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   // delete the patch
   graph.erasePath ();

   return BotCommandResult::Handled;
}

int BotControl::cmdNodePathSetAutoDistance () {
   enum args { graph_cmd = 1, cmd, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);
   showMenu (Menu::NodeAutoPath);

   return BotCommandResult::Handled;
}

int BotControl::cmdNodeAcquireEditor () {
   enum args { graph_cmd = 1, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   if (game.isNullEntity (m_ent)) {
      msg ("This command should not be executed from HLDS console.");
      return BotCommandResult::Handled;
   }

   if (graph.hasEditor ()) {
      msg ("Sorry, players \"%s\" already acquired rights to edit graph on this server.", graph.getEditor ()->v.netname.chars ());
      return BotCommandResult::Handled;
   }
   graph.setEditor (m_ent);
   msg ("You're acquired rights to edit graph on this server. You're now able to use graph commands.");

   return BotCommandResult::Handled;
}

int BotControl::cmdNodeReleaseEditor () {
   enum args { graph_cmd = 1, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   if (!graph.hasEditor ()) {
      msg ("No one is currently has rights to edit. Nothing to release.");
      return BotCommandResult::Handled;
   }
   graph.setEditor (nullptr);
   msg ("Graph editor rights freed. You're now not able to use graph commands.");

   return BotCommandResult::Handled;
}

int BotControl::cmdNodeUpload () {
   enum args { graph_cmd = 1, cmd };

   // do not allow to upload bad graph
   if (!graph.checkNodes (false)) {
      msg ("Sorry, unable to upload graph file that contains errors. Please type \"wp check\" to verify graph consistency.");
      return BotCommandResult::BadFormat;
   }

   msg ("\n");
   msg ("WARNING!");
   msg ("Graph uploaded to graph database in synchronous mode. That means if graph is big enough");
   msg ("you may notice the game freezes a bit during upload and issue request creation. Please, be patient.");
   msg ("\n");

   // six seconds is enough?
   http.setTimeout (6);

   // try to upload the file
   if (http.uploadFile ("http://upload.ubot.su/", strings.format ("%sgraph/%s.graph", graph.getDataDirectory (false), game.getMapName ()))) {
      msg ("Graph file was successfully validated and uploaded to the Ubot S3 storage (%s).", product.download);
      msg ("It will be available for download for all Ubot and YaPB users in a few minutes");
      msg ("\n");
      msg ("Thank you.");
      msg ("\n");
   }
   else {
      String status;
      auto code = http.getLastStatusCode ();

      if (code == HttpClientResult::Forbidden) {
         status = "AlreadyExists";
      }
      else if (code == HttpClientResult::NotFound) {
         status = "AccessDenied";
      }
      else {
         status.assignf ("%d", code);
      }
      msg ("Something went wrong with uploading. Come back later. (%s)", status);
      msg ("\n");

      if (code == HttpClientResult::Forbidden) {
         msg ("You should create issue-request manually for this graph");
         msg ("as it's already exists in database, can't overwrite. Sorry...");
      }
      else {
         msg ("There is an internal error, or something is totally wrong with");
         msg ("your files, and they are not passed sanity checks. Sorry...");
      }
      msg ("\n");
   }
   return BotCommandResult::Handled;
}

int BotControl::cmdNodeIterateCamp () {
   enum args { graph_cmd = 1, cmd, option, max };

   // adding more args to args array, if not enough passed
   fixMissingArgs (max);

   // turn graph on
   graph.setEditFlag (GraphEdit::On);

   // get the option descriping operation
   auto op = getStr (option);

   if (op != "begin" && op != "end" && op != "next") {
      return BotCommandResult::BadFormat;
   }

   if ((op == "next" || op == "end") && m_campIterator.empty ()) {
      msg ("Before calling for 'next' / 'end' camp point, you should hit 'begin'.");
      return BotCommandResult::Handled;
   }
   else if (op == "begin" && !m_campIterator.empty ()) {
      msg ("Before calling for 'begin' camp point, you should hit 'end'.");
      return BotCommandResult::Handled;
   }
   
   if (op == "end") {
      m_campIterator.clear ();
   }
   else if (op == "next") {
      if (!m_campIterator.empty ()) {
         Vector origin = graph[m_campIterator.first ()].origin;

         if (graph[m_campIterator.first ()].flags & NodeFlag::Crouch) {
            origin.z += 23.0f;
         }
         engfuncs.pfnSetOrigin (m_ent, origin);

         // go to next
         m_campIterator.shift ();

         if (m_campIterator.empty ()) {
            msg ("Finished iterating camp spots.");
         }
      }
   }
   else if (op == "begin") {
      for (int i = 0; i < graph.length (); ++i) {
         if (graph[i].flags & NodeFlag::Camp) {
            m_campIterator.push (i);
         }
      }
      msg ("Ready for iteration. Type 'next' to go to first camp node.");
   }
   return BotCommandResult::Handled;
}

int BotControl::menuMain (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
      m_isMenuFillCommand = false;
      showMenu (Menu::Control);
      break;

   case 2:
      showMenu (Menu::Features);
      break;

   case 3:
      m_isMenuFillCommand = true;
      showMenu (Menu::TeamSelect);
      break;

   case 4:
      bots.killAllBots ();
      break;

   case 10:
      showMenu (Menu::None);
      break;

   default:
      showMenu (Menu::Main);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuFeatures (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
      showMenu (Menu::WeaponMode);
      break;

   case 2:
      showMenu (graph.hasEditor () ? Menu::NodeMainPage1 : Menu::Features);
      break;

   case 3:
      showMenu (Menu::Personality);
      break;

   case 4:
      extern ConVar yb_debug;
      yb_debug.set (yb_debug.int_ () ^ 1);

      showMenu (Menu::Features);
      break;

   case 5:
      if (util.isAlive (m_ent)) {
         showMenu (Menu::Commands);
      }
      else {
         showMenu (Menu::None); // reset menu display
         msg ("You're dead, and have no access to this menu");
      }
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuControl (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
      bots.createRandom (true);
      showMenu (Menu::Control);
      break;

   case 2:
      showMenu (Menu::Difficulty);
      break;

   case 3:
      bots.kickRandom ();
      showMenu (Menu::Control);
      break;

   case 4:
      bots.kickEveryone ();
      break;

   case 5:
      kickBotByMenu (1);
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuWeaponMode (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 3:
   case 4:
   case 5:
   case 6:
   case 7:
      bots.setWeaponMode (item);
      showMenu (Menu::WeaponMode);
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuPersonality (int item) {
   if (m_isMenuFillCommand) {
      showMenu (Menu::None); // reset menu display

      switch (item) {
      case 1:
      case 2:
      case 3:
      case 4:
         bots.serverFill (m_menuServerFillTeam, item - 2, m_interMenuData[0]);
         showMenu (Menu::None);
         break;

      case 10:
         showMenu (Menu::None);
         break;
      }
      return BotCommandResult::Handled;
   }
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 3:
   case 4:
      m_interMenuData[3] = item - 2;
      showMenu (Menu::TeamSelect);
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuDifficulty (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
      m_interMenuData[0] = 0;
      break;

   case 2:
      m_interMenuData[0] = 1;
      break;

   case 3:
      m_interMenuData[0] = 2;
      break;

   case 4:
      m_interMenuData[0] = 3;
      break;

   case 5:
      m_interMenuData[0] = 4;
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   showMenu (Menu::Personality);

   return BotCommandResult::Handled;
}

int BotControl::menuTeamSelect (int item) {
   if (m_isMenuFillCommand) {
      showMenu (Menu::None); // reset menu display

      if (item < 3) {
         extern ConVar mp_limitteams, mp_autoteambalance;

         // turn off cvars if specified team
         mp_limitteams.set (0);
         mp_autoteambalance.set (0);
      }

      switch (item) {
      case 1:
      case 2:
      case 5:
         m_menuServerFillTeam = item;
         showMenu (Menu::Difficulty);
         break;

      case 10:
         showMenu (Menu::None);
         break;
      }
      return BotCommandResult::Handled;
   }
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 5:
      m_interMenuData[1] = item;

      if (item == 5) {
         m_interMenuData[2] = item;
         bots.addbot ("", m_interMenuData[0], m_interMenuData[3], m_interMenuData[1], m_interMenuData[2], true);
      }
      else {
         showMenu (item == 1 ? Menu::TerroristSelect : Menu::CTSelect);
      }
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuClassSelect (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 3:
   case 4:
   case 5:
      m_interMenuData[2] = item;
      bots.addbot ("", m_interMenuData[0], m_interMenuData[3], m_interMenuData[1], m_interMenuData[2], true);
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuCommands (int item) {
   showMenu (Menu::None); // reset menu display
   Bot *nearest = nullptr;

   switch (item) {
   case 1:
   case 2:
      if (util.findNearestPlayer (reinterpret_cast <void **> (&m_djump), m_ent, 600.0f, true, true, true, true, false) && !m_djump->m_hasC4 && !m_djump->hasHostage ()) {
         if (item == 1) {
            m_djump->startDoubleJump (m_ent);
         }
         else {
            if (m_djump) {
               m_djump->resetDoubleJump ();
               m_djump = nullptr;
            }
         }
      }
      showMenu (Menu::Commands);
      break;

   case 3:
   case 4:
      if (util.findNearestPlayer (reinterpret_cast <void **> (&nearest), m_ent, 600.0f, true, true, true, true, item == 4 ? false : true)) {
         nearest->dropWeaponForUser (m_ent, item == 4 ? false : true);
      }
      showMenu (Menu::Commands);
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuGraphPage1 (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
      if (graph.hasEditFlag (GraphEdit::On)) {
         graph.clearEditFlag (GraphEdit::On);
         enableDrawModels (false);

         msg ("Graph editor has been disabled.");
      }
      else {
         graph.setEditFlag (GraphEdit::On);
         enableDrawModels (true);

         msg ("Graph editor has been enabled.");
      }
      showMenu (Menu::NodeMainPage1);
      break;

   case 2:
      graph.setEditFlag (GraphEdit::On);
      graph.cachePoint (kInvalidNodeIndex);

      showMenu (Menu::NodeMainPage1);
      break;

   case 3:
      graph.setEditFlag (GraphEdit::On);
      showMenu (Menu::NodePath);
      break;

   case 4:
      graph.setEditFlag (GraphEdit::On);
      graph.erasePath ();
      
      showMenu (Menu::NodeMainPage1);
      break;

   case 5:
      graph.setEditFlag (GraphEdit::On);
      showMenu (Menu::NodeType);
      break;

   case 6:
      graph.setEditFlag (GraphEdit::On);
      graph.erase (kInvalidNodeIndex);

      showMenu (Menu::NodeMainPage1);
      break;

   case 7:
      graph.setEditFlag (GraphEdit::On);
      showMenu (Menu::NodeAutoPath);
      break;

   case 8:
      graph.setEditFlag (GraphEdit::On);
      showMenu (Menu::NodeRadius);
      break;

   case 9:
      showMenu (Menu::NodeMainPage2);
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuGraphPage2 (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1: {
      int terrPoints = 0;
      int ctPoints = 0;
      int goalPoints = 0;
      int rescuePoints = 0;
      int campPoints = 0;
      int sniperPoints = 0;
      int noHostagePoints = 0;

      for (int i = 0; i < graph.length (); ++i) {
         const Path &path = graph[i];

         if (path.flags & NodeFlag::TerroristOnly) {
            ++terrPoints;
         }

         if (path.flags & NodeFlag::CTOnly) {
            ++ctPoints;
         }

         if (path.flags & NodeFlag::Goal) {
            ++goalPoints;
         }

         if (path.flags & NodeFlag::Rescue) {
            ++rescuePoints;
         }

         if (path.flags & NodeFlag::Camp) {
            ++campPoints;
         }

         if (path.flags & NodeFlag::Sniper) {
            ++sniperPoints;
         }

         if (path.flags & NodeFlag::NoHostage) {
            ++noHostagePoints;
         }
      }
      msg ("Nodes: %d - T Points: %d\n"
         "CT Points: %d - Goal Points: %d\n"
         "Rescue Points: %d - Camp Points: %d\n"
         "Block Hostage Points: %d - Sniper Points: %d\n",
         graph.length (), terrPoints, ctPoints, goalPoints, rescuePoints, campPoints, noHostagePoints, sniperPoints);

      showMenu (Menu::NodeMainPage2);
   } break;

   case 2:
      graph.setEditFlag (GraphEdit::On);

      if (graph.hasEditFlag (GraphEdit::Auto)) {
         graph.clearEditFlag (GraphEdit::Auto);
      }
      else {
         graph.setEditFlag (GraphEdit::Auto);
      }
      msg ("Auto-Add-Nodes %s", graph.hasEditFlag (GraphEdit::Auto) ? "Enabled" : "Disabled");

      showMenu (Menu::NodeMainPage2);
      break;

   case 3:
      graph.setEditFlag (GraphEdit::On);
      showMenu (Menu::NodeFlag);
      break;

   case 4:
      if (graph.checkNodes (true)) {
         graph.saveGraphData ();
      }
      else {
         msg ("Graph not saved\nThere are errors. See console...");
      }
      showMenu (Menu::NodeMainPage2);
      break;

   case 5:
      graph.saveGraphData ();
      showMenu (Menu::NodeMainPage2);
      break;

   case 6:
      graph.loadGraphData ();
      showMenu (Menu::NodeMainPage2);
      break;

   case 7:
      if (graph.checkNodes (true)) {
         msg ("Nodes works fine");
      }
      else {
         msg ("There are errors, see console");
      }
      showMenu (Menu::NodeMainPage2);
      break;

   case 8:
      graph.setEditFlag (GraphEdit::On | GraphEdit::Noclip);
      showMenu (Menu::NodeMainPage2);
      break;

   case 9:
      showMenu (Menu::NodeMainPage1);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuGraphRadius (int item) {
   showMenu (Menu::None); // reset menu display
   graph.setEditFlag (GraphEdit::On); // turn graph on in case

   constexpr float radius[] = { 0.0f, 8.0f, 16.0f, 32.0f, 48.0f, 64.0f, 80.0f, 96.0f, 128.0f };

   if (item >= 1 && item <= 9) {
      graph.setRadius (kInvalidNodeIndex, radius[item - 1]);
      showMenu (Menu::NodeRadius);
   }
   return BotCommandResult::Handled;
}

int BotControl::menuGraphType (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 3:
   case 4:
   case 5:
   case 6:
   case 7:
      graph.add (item - 1);
      showMenu (Menu::NodeType);
      break;

   case 8:
      graph.add (100);
      showMenu (Menu::NodeType);
      break;

   case 9:
      graph.startLearnJump ();
      showMenu (Menu::NodeType);
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuGraphFlag (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
      graph.toggleFlags (NodeFlag::NoHostage);
      showMenu (Menu::NodeFlag);
      break;

   case 2:
      graph.toggleFlags (NodeFlag::TerroristOnly);
      showMenu (Menu::NodeFlag);
      break;

   case 3:
      graph.toggleFlags (NodeFlag::CTOnly);
      showMenu (Menu::NodeFlag);
      break;

   case 4:
      graph.toggleFlags (NodeFlag::Lift);
      showMenu (Menu::NodeFlag);
      break;

   case 5:
      graph.toggleFlags (NodeFlag::Sniper);
      showMenu (Menu::NodeFlag);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuAutoPathDistance (int item) {
   showMenu (Menu::None); // reset menu display

   constexpr float distances[] = { 0.0f, 100.0f, 130.0f, 160.0f, 190.0f, 220.0f, 250.0f };
   float result = 0.0f;

   if (item >= 1 && item <= 7) {
      result = distances[item - 1];
      graph.setAutoPathDistance (result);
   }

   if (cr::fzero (result)) {
      msg ("Autopathing is now disabled.");
   }
   else {
      msg ("Autopath distance is set to %.2f.", result);
   }
   showMenu (Menu::NodeAutoPath);

   return BotCommandResult::Handled;
}

int BotControl::menuKickPage1 (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 3:
   case 4:
   case 5:
   case 6:
   case 7:
   case 8:
      bots.kickBot (item - 1);
      kickBotByMenu (1);
      break;

   case 9:
      kickBotByMenu (2);
      break;

   case 10:
      showMenu (Menu::Control);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuKickPage2 (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 3:
   case 4:
   case 5:
   case 6:
   case 7:
   case 8:
      bots.kickBot (item + 8 - 1);
      kickBotByMenu (2);
      break;

   case 9:
      kickBotByMenu (3);
      break;

   case 10:
      kickBotByMenu (1);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuKickPage3 (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 3:
   case 4:
   case 5:
   case 6:
   case 7:
   case 8:
      bots.kickBot (item + 16 - 1);
      kickBotByMenu (3);
      break;

   case 9:
      kickBotByMenu (4);
      break;

   case 10:
      kickBotByMenu (2);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuKickPage4 (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
   case 2:
   case 3:
   case 4:
   case 5:
   case 6:
   case 7:
   case 8:
      bots.kickBot (item + 24 - 1);
      kickBotByMenu (4);
      break;

   case 10:
      kickBotByMenu (3);
      break;
   }
   return BotCommandResult::Handled;
}

int BotControl::menuGraphPath (int item) {
   showMenu (Menu::None); // reset menu display

   switch (item) {
   case 1:
      graph.pathCreate (PathConnection::Outgoing);
      showMenu (Menu::NodePath);
      break;

   case 2:
      graph.pathCreate (PathConnection::Incoming);
      showMenu (Menu::NodePath);
      break;

   case 3:
      graph.pathCreate (PathConnection::Bidirectional);
      showMenu (Menu::NodePath);
      break;

   case 10:
      showMenu (Menu::None);
      break;
   }
   return BotCommandResult::Handled;
}

bool BotControl::executeCommands () {
   if (m_args.empty ()) {
      return false;
   }

   // handle only "yb" and "yapb" commands
   if (m_args[0] != "yb" && m_args[0] != "yapb") {
      return false;
   }
   Client &client = util.getClient (game.indexOfPlayer (m_ent));

   // do not allow to execute stuff for non admins
   if (m_ent != game.getLocalEntity () && !(client.flags & ClientFlags::Admin)) {
      msg ("Access to %s commands is restricted.", PRODUCT_SHORT_NAME);
      return true;
   }

   auto aliasMatch = [] (String &test, const String &cmd, String &aliasName) -> bool {
      for (auto &alias : test.split ("/")) {
         if (alias == cmd) {
            aliasName = alias;
            return true;
         }
      }
      return false;
   };
   String cmd;

   // give some help
   if (m_args.length () > 0 && m_args[1] == "help") {
      for (auto &item : m_cmds) {
         if (aliasMatch (item.name, m_args[2], cmd)) {
            msg ("Command: \"%s %s\"\nFormat: %s\nHelp: %s", m_args[0].chars (), cmd.chars (), item.format.chars (), item.help.chars ());

            String aliases;

            for (auto &alias : item.name.split ("/")) {
               aliases.appendf ("%s, ", alias.chars ());
            }
            aliases.rtrim (", ");
            msg ("Aliases: %s", aliases.chars ());

            return true;
         }
      }

      if (m_args[2].empty ()) {
         return true;
      }
      else {
         msg ("No help found for \"%s\"", m_args[2].chars ());
      }
      return true;
   }
   cmd.clear ();

   // if no args passed just print all the commands
   if (m_args.length () == 1) {
      msg ("usage %s <command> [arguments]", m_args[0].chars ());
      msg ("valid commands are: ");

      for (auto &item : m_cmds) {
         msg ("   %s - %s", item.name.split ("/")[0].chars (), item.help.chars ());
      }
      return true;
   }

   // first search for a actual cmd
   for (auto &item : m_cmds) {
      auto root = m_args[0].chars ();

      if (aliasMatch (item.name, m_args[1], cmd)) {
         auto alias = cmd.chars ();

         switch ((this->*item.handler) ()) {
         case BotCommandResult::Handled:
         default:
            break;

         case BotCommandResult::ListenServer:
            msg ("Command \"%s %s\" is only available from the listenserver console.", root, alias);
            break;

         case BotCommandResult::BadFormat:
            msg ("Incorrect usage of \"%s %s\" command. Correct usage is:\n\n\t%s\n\nPlease type \"%s help %s\" to get more information.", root, alias, item.format.chars (), root, alias);
            break;
         }

         m_isFromConsole = false;
         return true;
      }
   }
   msg ("Unrecognized command: %s", m_args[1].chars ());
   return true;
}

bool BotControl::executeMenus () {
   if (!util.isPlayer (m_ent) || game.isBotCmd ()) {
      return false;
   }
   auto &issuer = util.getClient (game.indexOfPlayer (m_ent));

   // check if it's menu select, and some key pressed
   if (getStr (0) != "menuselect" || getStr (1).empty () || issuer.menu == Menu::None) {
      return false;
   }

   // let's get handle
   for (auto &menu : m_menus) {
      if (menu.ident == issuer.menu) {
         return (this->*menu.handler) (getStr (1).int_ ());
      }
   }
   return false;
}

void BotControl::showMenu (int id) {
   static bool s_menusParsed = false;

   // make menus looks like we need only once
   if (!s_menusParsed) {
      for (auto &parsed : m_menus) {
         const String &translated = conf.translate (parsed.text.chars ());

         // translate all the things
         parsed.text = translated;

          // make menu looks best
         if (!(game.is (GameFlags::Legacy))) {
            for (int j = 0; j < 10; ++j) {
               parsed.text.replace (strings.format ("%d.", j), strings.format ("\\r%d.\\w", j));
            }
         }
      }
      s_menusParsed = true;
   }

   if (!util.isPlayer (m_ent)) {
      return;
   }
   Client &client = util.getClient (game.indexOfPlayer (m_ent));

   if (id == Menu::None) {
      MessageWriter (MSG_ONE_UNRELIABLE, msgs.id (NetMsg::ShowMenu), nullptr, m_ent)
         .writeShort (0)
         .writeChar (0)
         .writeByte (0)
         .writeString ("");

      client.menu = id;
      return;
   }

   for (auto &display : m_menus) {
      if (display.ident == id) {
         auto text = (game.is (GameFlags::Xash3D | GameFlags::Mobility) && !yb_display_menu_text.bool_ ()) ? " " : display.text.chars ();
         MessageWriter msg;

         while (strlen (text) >= 64) {
            msg.start (MSG_ONE_UNRELIABLE, msgs.id (NetMsg::ShowMenu), nullptr, m_ent)
               .writeShort (display.slots)
               .writeChar (-1)
               .writeByte (1);

            for (int i = 0; i < 64; ++i) {
               msg.writeChar (text[i]);
            }
            msg.end ();
            text += 64;
         }

         MessageWriter (MSG_ONE_UNRELIABLE, msgs.id (NetMsg::ShowMenu), nullptr, m_ent)
            .writeShort (display.slots)
            .writeChar (-1)
            .writeByte (0)
            .writeString (text);

         client.menu = id;
         engfuncs.pfnClientCommand (m_ent, "speak \"player/geiger1\"\n"); // Stops others from hearing menu sounds..
      }
   }
}

void BotControl::kickBotByMenu (int page) {
   if (page > 4 || page < 1) {
      return;
   }

   String menus;
   menus.assignf ("\\yBots Remove Menu (%d/4):\\w\n\n", page);

   int menuKeys = (page == 4) ? cr::bit (9) : (cr::bit (8) | cr::bit (9));
   int menuKey = (page - 1) * 8;

   for (int i = menuKey; i < page * 8; ++i) {
      auto bot = bots[i];

      // check for fakeclient bit, since we're clear it upon kick, but actual bot struct destroyed after client disconnected
      if (bot != nullptr && (bot->pev->flags & FL_FAKECLIENT)) {
         menuKeys |= cr::bit (cr::abs (i - menuKey));
         menus.appendf ("%1.1d. %s%s\n", i - menuKey + 1, bot->pev->netname.chars (), bot->m_team == Team::CT ? " \\y(CT)\\w" : " \\r(T)\\w");
      }
      else {
         menus.appendf ("\\d %1.1d. Not a Bot\\w\n", i - menuKey + 1);
      }
   }
   menus.appendf ("\n%s 0. Back", (page == 4) ? "" : " 9. More...\n");

   // force to clear current menu
   showMenu (Menu::None);

   auto id = Menu::KickPage1 - 1 + page;

   for (auto &menu : m_menus) {
      if (menu.ident == id) {
         menu.slots = menuKeys & static_cast <uint32> (-1);
         menu.text = menus;

         break;
      }
   }
   showMenu (id);
}

void BotControl::assignAdminRights (edict_t *ent, char *infobuffer) {
   if (!game.isDedicated () || util.isFakeClient (ent)) {
      return;
   }
   const String &key = yb_password_key.str ();
   const String &password = yb_password.str ();

   if (!key.empty () && !password.empty ()) {
      auto &client = util.getClient (game.indexOfPlayer (ent));

      if (password == engfuncs.pfnInfoKeyValue (infobuffer, key.chars ())) {
         client.flags |= ClientFlags::Admin;
      }
      else {
         client.flags &= ~ClientFlags::Admin;
      }
   }
}

void BotControl::maintainAdminRights () {
   if (!game.isDedicated ()) {
      return;
   }

   for (int i = 0; i < game.maxClients (); ++i) {
      edict_t *player = game.playerOfIndex (i);

      // code below is executed only on dedicated server
      if (util.isPlayer (player) && !util.isFakeClient (player)) {
         Client &client = util.getClient (i);

         if (client.flags & ClientFlags::Admin) {
            if (strings.isEmpty (yb_password_key.str ()) && strings.isEmpty (yb_password.str ())) {
               client.flags &= ~ClientFlags::Admin;
            }
            else if (!!strcmp (yb_password.str (), engfuncs.pfnInfoKeyValue (engfuncs.pfnGetInfoKeyBuffer (client.ent), const_cast <char *> (yb_password_key.str ())))) {
               client.flags &= ~ClientFlags::Admin;
               game.print ("Player %s had lost remote access to %s.", player->v.netname.chars (), PRODUCT_SHORT_NAME);
            }
         }
         else if (!(client.flags & ClientFlags::Admin) && !strings.isEmpty (yb_password_key.str ()) && !strings.isEmpty (yb_password.str ())) {
            if (strcmp (yb_password.str (), engfuncs.pfnInfoKeyValue (engfuncs.pfnGetInfoKeyBuffer (client.ent), const_cast <char *> (yb_password_key.str ()))) == 0) {
               client.flags |= ClientFlags::Admin;
               game.print ("Player %s had gained full remote access to %s.", player->v.netname.chars (), PRODUCT_SHORT_NAME);
            }
         }
      }
   }
}

BotControl::BotControl () {
   m_ent = nullptr;
   m_djump = nullptr;

   m_isFromConsole = false;
   m_isMenuFillCommand = false;
   m_rapidOutput = false;
   m_menuServerFillTeam = 5;

   m_cmds.emplace ("add/addbot/add_ct/addbot_ct/add_t/addbot_t/addhs/addhs_t/addhs_ct", "add [difficulty[personality[team[model[name]]]]]", "Adding specific bot into the game.", &BotControl::cmdAddBot);
   m_cmds.emplace ("kick/kickone/kick_ct/kick_t/kickbot_ct/kickbot_t", "kick [team]", "Kicks off the random bot from the game.", &BotControl::cmdKickBot);
   m_cmds.emplace ("removebots/kickbots/kickall", "removebots [instant]", "Kicks all the bots from the game.", &BotControl::cmdKickBots);
   m_cmds.emplace ("kill/killbots/killall/kill_ct/kill_t", "kill [team]", "Kills the specified team / all the bots.", &BotControl::cmdKillBots);
   m_cmds.emplace ("fill/fillserver", "fill [team[count[difficulty[pesonality]]]]", "Fill the server (add bots) with specified parameters.", &BotControl::cmdFill);
   m_cmds.emplace ("vote/votemap", "vote [map_id]", "Forces all the bot to vote to specified map.", &BotControl::cmdVote);
   m_cmds.emplace ("weapons/weaponmode", "weapons [knife|pistol|shotgun|smg|rifle|sniper|standard]", "Sets the bots weapon mode to use", &BotControl::cmdWeaponMode);
   m_cmds.emplace ("menu/botmenu", "menu [cmd]", "Opens the main bot menu, or command menu if specified.", &BotControl::cmdMenu);
   m_cmds.emplace ("version/ver/about", "version [no arguments]", "Displays version information about bot build.", &BotControl::cmdVersion);
   m_cmds.emplace ("graphmenu/wpmenu/wptmenu", "graphmenu [noarguments]", "Opens and displays bots graph edtior.", &BotControl::cmdNodeMenu);
   m_cmds.emplace ("list/listbots", "list [noarguments]", "Lists the bots currently playing on server.", &BotControl::cmdList);
   m_cmds.emplace ("graph/g/wp/wpt/waypoint", "graph [help]", "Handles graph operations.", &BotControl::cmdNode);
   m_cmds.emplace ("cvars", "cvars [save|cvar]", "Display all the cvars with their descriptions.", &BotControl::cmdCvars);

   // declare the menus
   createMenus ();
}

void BotControl::handleEngineCommands () {
   collectArgs ();
   setIssuer (game.getLocalEntity ());

   setFromConsole (true);
   executeCommands ();
}

bool BotControl::handleClientCommands (edict_t *ent) {
   collectArgs ();
   setIssuer (ent);

   setFromConsole (true);
   return executeCommands ();
}

bool BotControl::handleMenuCommands (edict_t *ent) {
   collectArgs ();
   setIssuer (ent);

   setFromConsole (false);
   return ctrl.executeMenus ();
}

void BotControl::enableDrawModels (bool enable) {
   StringArray entities;

   entities.push ("info_player_start");
   entities.push ("info_player_deathmatch");
   entities.push ("info_vip_start");

   for (auto &entity : entities) {
      game.searchEntities ("classname", entity, [&enable] (edict_t *ent) {
         if (enable) {
            ent->v.effects &= ~EF_NODRAW;
         }
         else {
            ent->v.effects |= EF_NODRAW;
         }
         return EntitySearchResult::Continue;
      });
   }
}

void BotControl::createMenus () {
   auto keys = [] (int numKeys) -> int {
      int result = 0;

      for (int i = 0; i < numKeys; ++i) {
         result |= cr::bit (i);
      }
      result |= cr::bit (9);

      return result;
   };

   // bots main menu
   m_menus.emplace (
      Menu::Main, keys (4),
      "\\yMain Menu\\w\n\n"
      "1. Control Bots\n"
      "2. Features\n\n"
      "3. Fill Server\n"
      "4. End Round\n\n"
      "0. Exit",
      &BotControl::menuMain);


   // bots features menu
   m_menus.emplace (
      Menu::Features, keys (5),
      "\\yBots Features\\w\n\n"
      "1. Weapon Mode Menu\n"
      "2. Waypoint Menu\n"
      "3. Select Personality\n\n"
      "4. Toggle Debug Mode\n"
      "5. Command Menu\n\n"
      "0. Exit",
      &BotControl::menuFeatures);

   // bot control menu
   m_menus.emplace (
      Menu::Control, keys (5),
      "\\yBots Control Menu\\w\n\n"
      "1. Add a Bot, Quick\n"
      "2. Add a Bot, Specified\n\n"
      "3. Remove Random Bot\n"
      "4. Remove All Bots\n\n"
      "5. Remove Bot Menu\n\n"
      "0. Exit",
      &BotControl::menuControl);

   // weapon mode select menu
   m_menus.emplace (
      Menu::WeaponMode, keys (7),
      "\\yBots Weapon Mode\\w\n\n"
      "1. Knives only\n"
      "2. Pistols only\n"
      "3. Shotguns only\n"
      "4. Machine Guns only\n"
      "5. Rifles only\n"
      "6. Sniper Weapons only\n"
      "7. All Weapons\n\n"
      "0. Exit",
      &BotControl::menuWeaponMode);

   // personality select menu
   m_menus.emplace (
      Menu::Personality, keys (4),
      "\\yBots Personality\\w\n\n"
      "1. Random\n"
      "2. Normal\n"
      "3. Aggressive\n"
      "4. Careful\n\n"
      "0. Exit",
      &BotControl::menuPersonality);

   // difficulty select menu
   m_menus.emplace (
      Menu::Difficulty, keys (5),
      "\\yBots Difficulty Level\\w\n\n"
      "1. Newbie\n"
      "2. Average\n"
      "3. Normal\n"
      "4. Professional\n"
      "5. Godlike\n\n"
      "0. Exit",
      &BotControl::menuDifficulty);

   // team select menu
   m_menus.emplace (
      Menu::TeamSelect, keys (5),
      "\\ySelect a team\\w\n\n"
      "1. Terrorist Force\n"
      "2. Counter-Terrorist Force\n\n"
      "5. Auto-select\n\n"
      "0. Exit",
      &BotControl::menuTeamSelect);

   // terrorist model select menu
   m_menus.emplace (
      Menu::TerroristSelect, keys (5),
      "\\ySelect an appearance\\w\n\n"
      "1. Phoenix Connexion\n"
      "2. L337 Krew\n"
      "3. Arctic Avengers\n"
      "4. Guerilla Warfare\n\n"
      "5. Auto-select\n\n"
      "0. Exit",
      &BotControl::menuClassSelect);

   // counter-terrorist model select menu
   m_menus.emplace (
      Menu::CTSelect, keys (5),
      "\\ySelect an appearance\\w\n\n"
      "1. Seal Team 6 (DEVGRU)\n"
      "2. German GSG-9\n"
      "3. UK SAS\n"
      "4. French GIGN\n\n"
      "5. Auto-select\n\n"
      "0. Exit",
      &BotControl::menuClassSelect);

   // command menu
   m_menus.emplace (
      Menu::Commands, keys (4),
      "\\yBot Command Menu\\w\n\n"
      "1. Make Double Jump\n"
      "2. Finish Double Jump\n\n"
      "3. Drop the C4 Bomb\n"
      "4. Drop the Weapon\n\n"
      "0. Exit",
      &BotControl::menuCommands);

   // main waypoint menu
   m_menus.emplace (
      Menu::NodeMainPage1, keys (9),
      "\\yWaypoint Operations (Page 1)\\w\n\n"
      "1. Show/Hide waypoints\n"
      "2. Cache waypoint\n"
      "3. Create path\n"
      "4. Delete path\n"
      "5. Add waypoint\n"
      "6. Delete waypoint\n"
      "7. Set Autopath Distance\n"
      "8. Set Radius\n\n"
      "9. Next...\n\n"
      "0. Exit",
      &BotControl::menuGraphPage1);

   // main waypoint menu (page 2)
   m_menus.emplace (
      Menu::NodeMainPage2, keys (9),
      "\\yWaypoint Operations (Page 2)\\w\n\n"
      "1. Waypoint stats\n"
      "2. Autowaypoint on/off\n"
      "3. Set flags\n"
      "4. Save waypoints\n"
      "5. Save without checking\n"
      "6. Load waypoints\n"
      "7. Check waypoints\n"
      "8. Noclip cheat on/off\n\n"
      "9. Previous...\n\n"
      "0. Exit",
      &BotControl::menuGraphPage2);

   // select waypoint radius menu
   m_menus.emplace (
      Menu::NodeRadius, keys (9),
      "\\yWaypoint Radius\\w\n\n"
      "1. SetRadius 0\n"
      "2. SetRadius 8\n"
      "3. SetRadius 16\n"
      "4. SetRadius 32\n"
      "5. SetRadius 48\n"
      "6. SetRadius 64\n"
      "7. SetRadius 80\n"
      "8. SetRadius 96\n"
      "9. SetRadius 128\n\n"
      "0. Exit",
      &BotControl::menuGraphRadius);

   // waypoint add menu
   m_menus.emplace (
      Menu::NodeType, keys (9),
      "\\yWaypoint Type\\w\n\n"
      "1. Normal\n"
      "\\r2. Terrorist Important\n"
      "3. Counter-Terrorist Important\n"
      "\\w4. Block with hostage / Ladder\n"
      "\\y5. Rescue Zone\n"
      "\\w6. Camping\n"
      "7. Camp End\n"
      "\\r8. Map Goal\n"
      "\\w9. Jump\n\n"
      "0. Exit",
      &BotControl::menuGraphType);

   // set waypoint flag menu
   m_menus.emplace (
      Menu::NodeFlag, keys (5),
      "\\yToggle Waypoint Flags\\w\n\n"
      "1. Block with Hostage\n"
      "2. Terrorists Specific\n"
      "3. CTs Specific\n"
      "4. Use Elevator\n"
      "5. Sniper Point (\\yFor Camp Points Only!\\w)\n\n"
      "0. Exit",
      &BotControl::menuGraphFlag);

   // auto-path max distance
   m_menus.emplace (
      Menu::NodeAutoPath, keys (7),
      "\\yAutoPath Distance\\w\n\n"
      "1. Distance 0\n"
      "2. Distance 100\n"
      "3. Distance 130\n"
      "4. Distance 160\n"
      "5. Distance 190\n"
      "6. Distance 220\n"
      "7. Distance 250 (Default)\n\n"
      "0. Exit",
      &BotControl::menuAutoPathDistance);

   // path connections
   m_menus.emplace (
      Menu::NodePath, keys (3),
      "\\yCreate Path (Choose Direction)\\w\n\n"
      "1. Outgoing Path\n"
      "2. Incoming Path\n"
      "3. Bidirectional (Both Ways)\n\n"
      "0. Exit",
      &BotControl::menuGraphPath);

   // kick menus
   m_menus.emplace (Menu::KickPage1, 0x0, "", &BotControl::menuKickPage1);
   m_menus.emplace (Menu::KickPage2, 0x0, "", &BotControl::menuKickPage2);
   m_menus.emplace (Menu::KickPage3, 0x0, "", &BotControl::menuKickPage3);
   m_menus.emplace (Menu::KickPage4, 0x0, "", &BotControl::menuKickPage4);
}