//  name of current host (usually "home")

// name of current host (usually "home")

};
// tries to continually buy ram as long as you have sufficient cash
const void_buy_home_ram = function(ns) {
  // void_debug(array_get_servers, Array.from(arguments));
  // let float_cash_current = getServerMoneyAvailable("home");
  // try {
  //   while (float_cash_current >= getUpgradeHomeRamCost()) {
  //     ns.upgradeHomeRam();
  //     float_cash_current = getServerMoneyAvailable("home");
  //   }
  // }
  // catch (error) { 
  // }

  let integer_server_ram_biggest_afforded = Math.pow(2, Math.trunc(Math.log2(ns.getServerMoneyAvailable(object_constants.string_host) / object_constants.BaseCostFor1GBOfRamServer) / Math.log2(2)));

  let integer_server_ram_biggest_afforded = Math.pow(2, Math.trunc(Math.log2(ns.getServerMoneyAvailable("home") / object_constants.BaseCostFor1GBOfRamServer) / Math.log2(2)));

// buys the best server with cash available, unless there are 25 servers already, in which case deletes the worst server, unless all 25 have ram == PurchasedServerMaxRam

// continually buys the best server with cash available, unless there are 25 servers already, in which case deletes the worst server, unless all 25 have ram == PurchasedServerMaxRam

  const object_constants = object_get_constants(ns);
  const array_servers_bought = ns.getPurchasedServers();
  // if array_servers_bought.length <= 2 and your cash is >= the cheapest server
  const integer_server_ram_biggest_afforded = integer_get_server_ram_biggest_afforded(ns);
  // you currently have no bought servers yet, get a server with ram at least equal to "home"
  if (
    // ram is at least equal to the minimum ram possible for purchased servers
    (integer_server_ram_biggest_afforded >= object_constants.integer_server_ram_min) &&
    // ram is at least equal to the ram of "home", probably a bad idea to hardcode this since the string_name of "home" might change in the future. tags: warning, potential, problem
    (integer_server_ram_biggest_afforded >= integer_get_server_ram_total(ns, object_constants.string_host)) &&
    // you have no bought servers yet
    (array_servers_bought.length === 0)
  ) {
    ns.purchaseServer(string_name, integer_server_ram_biggest_afforded);
  }
  
// you have one or more servers already
  if ((array_servers_bought.length > 0)) {
    // get smallest bought server
    const string_server_bought_smallest = string_get_server_bought_smallest(ns);
    // get biggest bought server
    const string_server_bought_biggest = string_get_server_bought_biggest(ns);
    // get the ram of the biggest bought server
    const integer_server_bought_biggest_ram_total = integer_get_server_ram_total(ns, string_server_bought_biggest);

    // you currently own less than the maximum amount of purchased servers allowed
    if (array_servers_bought.length < object_constants.PurchasedServerLimit) {

  const boolean_conditions_server_purchase_1 = function(ns) {
    const integer_server_ram_biggest_afforded = integer_get_server_ram_biggest_afforded(ns);
    const object_constants = object_get_constants(ns);
    if (// ram is at least equal to the minimum ram possible for purchased servers
      (integer_server_ram_biggest_afforded >= object_constants.integer_server_ram_min) &&
      // ram is at least equal to the ram of "home", probably a bad idea to hardcode this since the string_name of "home" might change in the future. tags: warning, potential, problem
      (integer_server_ram_biggest_afforded >= integer_get_server_ram_total(ns, object_constants.string_host)) &&
      // you have no bought servers yet
      (ns.getPurchasedServers().length === 0)
    ) {
      return true;
    }
    else {
      return false;
    }
  };
  
  const boolean_conditions_server_purchase_2 = function(ns) {
    const integer_servers_bought_amount = ns.getPurchasedServers().length;
    const integer_servers_bought_limit = object_get_constants(ns).PurchasedServerLimit;
    const float_ram_server_bought_biggest = integer_get_server_ram_total(ns, string_get_server_bought_biggest(ns));
    if (// you have one or more servers already
      (integer_servers_bought_amount > 0) &&
      // you currently own less than the maximum amount of purchased servers allowed
      (integer_servers_bought_amount < integer_servers_bought_limit) &&

      if (
        (integer_server_bought_biggest_ram_total != object_constants.PurchasedServerLimit) &&
        (integer_server_ram_biggest_afforded > integer_server_bought_biggest_ram_total)
      ) {
        ns.purchaseServer(string_name, integer_server_ram_biggest_afforded);
      }

      (float_ram_server_bought_biggest != integer_servers_bought_limit) &&
      (integer_get_server_ram_biggest_afforded(ns) > float_ram_server_bought_biggest)
    ) {
      return true;
    }
    else {
      return false;
    }
  };
  
  const boolean_conditions_server_purchase_3 = function(ns) {
    const integer_servers_bought_amount = ns.getPurchasedServers().length;
    const object_constants = object_get_constants(ns);
    const float_ram_server_bought_maximum = object_constants.PurchasedServerMaxRam;
    if (// you have one or more servers already
      (integer_servers_bought_amount > 0) &&
      // you currently own less than the maximum amount of purchased servers allowed
      (integer_servers_bought_amount < object_constants.PurchasedServerLimit) &&

      if (
        (integer_server_bought_biggest_ram_total == object_constants.PurchasedServerMaxRam) &&
        (integer_server_ram_biggest_afforded == object_constants.PurchasedServerMaxRam)
      ) {
        ns.purchaseServer(string_name, integer_server_ram_biggest_afforded);
      }

      (integer_get_server_ram_total(ns, string_get_server_bought_biggest(ns)) == float_ram_server_bought_maximum) &&
      (integer_get_server_ram_biggest_afforded(ns) == float_ram_server_bought_maximum)
    ) {
      return true;

    if (
      // you currently own the maximum amount of purchased servers allowed
      (array_servers_bought.length == object_constants.PurchasedServerLimit) &&

    else {
      return false;
    }
  };
  
  const boolean_conditions_server_delete_purchase = function(ns) {
    const object_constants = object_get_constants(ns);
    if (// you currently own the maximum amount of purchased servers allowed
      (ns.getPurchasedServers().length == object_constants.PurchasedServerLimit) &&

      !(boolean_servers_bought_all_max(ns, object_constants.PurchasedServerMaxRam))
    ) {
      const integer_price_server_bought_biggest = object_constants.BaseCostFor1GBOfRamServer * integer_server_bought_biggest_ram_total;

      !(boolean_servers_bought_all_max(ns, object_constants.PurchasedServerMaxRam)) &&

      if (ns.getServerMoneyAvailable(object_constants.string_host) >= 3 * integer_price_server_bought_biggest) {
        ns.deleteServer(string_server_bought_smallest);
        ns.purchaseServer(string_name, integer_server_ram_biggest_afforded);
      }

      (ns.getServerMoneyAvailable("home") >= 3 * object_constants.BaseCostFor1GBOfRamServer * integer_get_server_ram_total(ns, string_get_server_bought_smallest(ns)))
    ) {
      return true;
    }
    else {
      return false;

  };
  while (boolean_conditions_server_delete_purchase(ns)) {
    ns.deleteServer(string_get_server_bought_smallest(ns));
    ns.purchaseServer(string_name, integer_get_server_ram_biggest_afforded(ns));
  }
  
  while (
    boolean_conditions_server_purchase_3(ns) ||
    boolean_conditions_server_purchase_2(ns) ||
    boolean_conditions_server_purchase_1(ns)
  ) {
    ns.purchaseServer(string_name, integer_get_server_ram_biggest_afforded(ns));

};
const string_get_server_rooted_hackable_with_score_biggest = function(ns) {
  void_debug(string_get_server_rooted_with_score_biggest, Array.from(arguments));
  const array_servers_rooted_sorted_by_score = array_get_servers_rooted_sorted_by_score(ns);
  for (let integer_indices_0 = array_servers_rooted_sorted_by_score.length - 1; integer_indices_0 >= 0; --integer_indices_0) {
    const string_server_target = array_servers_rooted_sorted_by_score[integer_indices_0];
    if (ns.getHackingLevel() >= ns.getServerRequiredHackingLevel(string_server_target)) {
      return string_server_target;
    }
  }

  const string_server_target = string_get_server_rooted_with_score_biggest(ns);

  const string_server_target = string_get_server_rooted_hackable_with_score_biggest(ns);

  void_buy_home_ram(ns);

//      ns.tprint(`current value before: ${integer_time_current}`);
//      ns.tprint(`finishes value before: ${integer_time_finishes}`);

      // ns.tprint(`current value before: ${integer_time_current}`);
      // ns.tprint(`finishes value before: ${integer_time_finishes}`);

//      ns.tprint(`finishes value after: ${integer_time_finishes}`);

      // ns.tprint(`finishes value after: ${integer_time_finishes}`);

//  arbitrarily check every float_period_check_seconds to see if the current time is greater than the time that the runner is supposed to finish.

    // arbitrarily check every float_period_check_seconds to see if the current time is greater than the time that the runner is supposed to finish.

# Description

# Bitburner Scripts
## Description