// Adapted from updateMoneyGainRate function in the src/Hacknet/HacknetNode.ts file
const float_get_gain_rate = function (
  level,
  ram,
  cores
) {
  return level * Math.pow(1.035, ram - 1) * (cores + 5);
};
const float_get_gain_rate_increase = function (
  ns,
  integer_node,
  level,
  ram,
  cores
) {
  const object_node_stats = ns.hacknet.getNodeStats(integer_node);
  return float_get_gain_rate(
    object_node_stats.level + level,
    object_node_stats.ram + ram,
    object_node_stats.cores + cores
  ) -
  float_get_gain_rate(
    object_node_stats.level,
    object_node_stats.ram,
    object_node_stats.cores
  );
};

  for (; ns.hacknet.numNodes() <= 0;) {
    try {
      ns.hacknet.purchaseNode();
    } catch (error) {
      await ns.sleep(float_period_check);
    }

  for (
    ;
    ns.hacknet.numNodes() <= 0;
  ) {
    ns.hacknet.purchaseNode();

    const integer_nodes = ns.hacknet.numNodes();
    let
      integer_cost = ns.hacknet.getPurchaseNodeCost(),
      function_job = function () {
        ns.hacknet.purchaseNode();
      };

    const
      integer_nodes = ns.hacknet.numNodes(),
      array_upgrades = [
        {
          float_gain_rate_increase: float_get_gain_rate(
            1,
            1,
            1
          ),
          integer_cost: ns.hacknet.getPurchaseNodeCost(),
          upgrade: function () {
            return ns.hacknet.purchaseNode();
          }
        }
      ];
    // iterate through nodes

      const
        integer_cost_level = ns.hacknet.getLevelUpgradeCost(integer_index_nodes, 1),
        integer_cost_ram = ns.hacknet.getRamUpgradeCost(integer_index_nodes, 1),
        integer_cost_core = ns.hacknet.getCoreUpgradeCost(integer_index_nodes, 1);
      if (
        object_nodes_stats.level < integer_level &&
        integer_cost_level < integer_cost
      ) {
        integer_cost = integer_cost_level;
        function_job = function () {
          ns.hacknet.upgradeLevel(integer_index_nodes, 1);
        };

      if (object_nodes_stats.level < integer_level) {
        array_upgrades.push(
          {
            float_gain_rate_increase: float_get_gain_rate_increase(
              ns,
              integer_index_nodes,
              1,
              0,
              0
            ),
            integer_cost: ns.hacknet.getLevelUpgradeCost(integer_index_nodes, 1),
            upgrade: function () {
              return ns.hacknet.upgradeLevel(integer_index_nodes, 1);
            }
          }
        );
      }
      if (object_nodes_stats.ram < integer_ram) {
        array_upgrades.push(
          {
            float_gain_rate_increase: float_get_gain_rate_increase(
              ns,
              integer_index_nodes,
              0,
              1,
              0
            ),
            integer_cost: ns.hacknet.getRamUpgradeCost(integer_index_nodes, 1),
            upgrade: function () {
              return ns.hacknet.upgradeRam(integer_index_nodes, 1);
            }
          }
        );

      if (
        object_nodes_stats.ram < integer_ram &&
        integer_cost_ram < integer_cost
      ) {
        integer_cost = integer_cost_ram;
        function_job = function () {
          ns.hacknet.upgradeRam(integer_index_nodes, 1);
        };

      if (object_nodes_stats.cores < integer_cores) {
        array_upgrades.push(
          {
            float_gain_rate_increase: float_get_gain_rate_increase(
              ns,
              integer_index_nodes,
              0,
              0,
              1
            ),
            integer_cost: ns.hacknet.getCoreUpgradeCost(integer_index_nodes, 1),
            upgrade: function () {
              return ns.hacknet.upgradeCore(integer_index_nodes, 1);
            }
          }
        );

    }
    array_upgrades.sort(
      (a, b) =>
      b.float_gain_rate_increase - a.float_gain_rate_increase
    );
    const object_upgrade = array_upgrades[0];
    for (
      let integer_index_upgrades = 1;
      integer_index_upgrades < array_upgrades.length;
      ++integer_index_upgrades
    ) {

        object_nodes_stats.cores < integer_cores &&
        integer_cost_core < integer_cost

        object_upgrade.float_gain_rate_increase >=
        array_upgrades[integer_index_upgrades].float_gain_rate_increase

        integer_cost = integer_cost_core;
        function_job = function () {
          ns.hacknet.upgradeCore(integer_index_nodes, 1);
        };

        if (
          array_upgrades[integer_index_upgrades].integer_cost <
          object_upgrade.integer_cost
        ) {
          object_upgrade.integer_cost = array_upgrades[integer_index_upgrades].integer_cost;
          object_upgrade.upgrade = array_upgrades[integer_index_upgrades].upgrade;
        }
      } else {
        break;

    }
    try {
      function_job();
    } catch (error) {
      await ns.sleep(float_period_check);

    object_upgrade.upgrade();