/** @param {NS} ns */
export async function main(ns) {
  ns.tprint("This is just a function library, it doesn't do anything.");
}

/** @param {NS} ns */
export function getCracks(ns) {
  let cracks = {};
  if (ns.fileExists("BruteSSH.exe", "home")) {
    cracks["BruteSSH.exe"] = ns.brutessh;
  };
  if (ns.fileExists("FTPCrack.exe", "home")) {
    cracks["FTPCrack.exe"] = ns.ftpcrack;
  };
  if (ns.fileExists("relaySMTP.exe", "home")) {
    cracks["relaySMTP.exe"] = ns.relaysmtp;
  };
  if (ns.fileExists("HTTPWorm.exe", "home")) {
    cracks["HTTPWorm.exe"] = ns.httpworm;
  };
  if (ns.fileExists("SQLInject.exe", "home")) {
    cracks["SQLInject.exe"] = ns.sqlinject;
  };
  return cracks;
}

/** @param {NS} ns */
export function scanServerList(ns) {
  const home = "home";
  let serverList = {};
  let unscanned = [];
  unscanned.push(home);
  while (unscanned.length > 0) {
    let currentServer = unscanned.pop();
    if (!serverList[currentServer]) {
      let maxRam = ns.getServerMaxRam(currentServer);
      let minPorts = ns.getServerNumPortsRequired(currentServer);
      let minSecLevel = ns.getServerMinSecurityLevel(currentServer);
      let minHackLevel = ns.getServerRequiredHackingLevel(currentServer);
      let rootAccess = ns.hasRootAccess(currentServer);
      let serverMoney = ns.getServerMaxMoney(currentServer);
      let serverFiles = ns.ls(currentServer);
      let skillFactor = (2.5 * minHackLevel * minSecLevel + 500) / (ns.getHackingLevel() + 50);
      let compareTimeFactor = serverMoney / skillFactor / 10e7;
      serverList[currentServer] =
      {
        serverName: currentServer,
        maxRam: maxRam,
        maxMoney: serverMoney,
        minSec: minSecLevel,
        minPorts: minPorts,
        minHackLvl: minHackLevel,
        rootAccess: rootAccess,
        factorMoneyPerTime: compareTimeFactor,
        openPorts: 0,
        serverFiles: serverFiles,
      };
      let neighbours = ns.scan(currentServer);
      for (let i = 0; i < neighbours.length; i++) {
        let neighbour = neighbours[i];
        if (serverList[neighbour]) {
          continue
        }
        unscanned.push(neighbour);
      }
    }
  }
  ns.write("serverList.txt", JSON.stringify(serverList), "w");
}

/** @param {NS} ns */
export function findBestTarget(ns, maxSec, maxPorts, currentHackLevel, manualTargetOverride) {
  if (!ns.fileExists("serverList.txt", "home")) scanServerList();
  let serverList = JSON.parse(ns.read("serverList.txt"));
  let bestEntry = null;
  let compareTime = 0;
  for (const [name, entry] of Object.entries(serverList)) {
    if (entry.minSec <= maxSec && entry.minPorts <= maxPorts && entry.minHackLvl < currentHackLevel) {
      if (entry.factorMoneyPerTime > compareTime) {
        compareTime = entry.factorMoneyPerTime;
        bestEntry = name;
      }
    }
  }
  if (manualTargetOverride.length > 0) {
    bestEntry = manualTargetOverride;
  }
  ns.write("bestTarget.txt", JSON.stringify(serverList[bestEntry]), "w");
}


/** @param {NS} ns */
export function crackingAndRooting(ns, cracks, funnyScript, copy) {
  if (!ns.fileExists("serverList.txt", "home")) scanServerList();
  let serverList = JSON.parse(ns.read("serverList.txt"));
  for (const [name, entry] of Object.entries(serverList)) {
    let cracked = false;
    let openPorts = serverList[name].openPorts || 0;
    if (entry.minPorts === 0 || (entry.minPorts > openPorts && entry.minPorts <= Object.keys(cracks).length)) {
      for (let k = 0; k < entry.minPorts; k++) {
        cracks[Object.keys(cracks)[k]](name);
        serverList[name].openPorts = k;
      }
      cracked = true;
    }
    if (!ns.hasRootAccess(name) && cracked === true) {
      ns.nuke(name);
      if (ns.hasRootAccess(name)) {
        serverList[name].rootAccess = true;
        if (serverList[name].maxRam > 0 && copy === true) {
          copyAndRunScript(ns, funnyScript, name);
        }
      }
    }
    ns.write("serverList.txt", JSON.stringify(serverList), "w");
  }
  ns.tprint("Cracking and rooting done");
}


/** @param {NS} ns */
export function copyAndRunScript(ns, funnyScript, currentServer) {
  // change to run for one specific server with bestTarget from file
  //let minRam = ns.getScriptRam(funnyScript);
  let bestTarget = JSON.parse(ns.read("bestTarget.txt"));

  let name = currentServer;
  let serverList = JSON.parse(ns.read("serverList.txt"));
  ns.print(name);
  if (serverList[name].rootAccess === true && serverList[bestTarget.serverName].rootAccess === true) {
    if (name !== "home") {
      ns.print("killed threads on: " + name + ns.killall(name, true));
    } else {
      ns.print("killed threads on: " + name + ns.scriptKill(funnyScript[0], name));
    };
    //move script and run
    if (serverList[name].maxRam > 0) {
      ns.scp(funnyScript, name, "home");
      let maxProcesses = 1;
      if (serverList[name].maxRam >= 8) {
        maxProcesses = Math.max(Math.floor((serverList[name].maxRam) / 8), 1);
      } else {
        maxProcesses = 1
      };

      for (let n = 1; n <= maxProcesses; n++) {
        ns.exec(funnyScript[0], name, 1, bestTarget.serverName);
      }

      /*let maxThreads = 0;
      if (name === "home") {
        maxThreads = Math.floor((serverList[name].maxRam - ns.getServerUsedRam(name) - 32) / minRam);
        ns.print(name + " " + maxThreads);
      } else {
        ns.print(name);
        maxThreads = Math.floor(serverList[name].maxRam / minRam);
        ns.print(name + " " + maxThreads);
      };
      while (maxThreads > 0) {
        let threadsToAssign = maxThreads < 500 ? maxThreads : 500;
        if (ns.exec(funnyScript, name, threadsToAssign, bestTarget.serverName, serverList[bestTarget.serverName].minSec, serverList[bestTarget.serverName].maxMoney, JSON.stringify(serverList[bestTarget.serverName])) !== 0) {
          ns.print("Executing script on: " + name + " with: " + threadsToAssign + " threads out of " + maxThreads + " total threads");
          maxThreads = maxThreads - threadsToAssign;
        } else {
          ns.tprint("Error running script on: " + name);
          maxThreads = -1;
        };
      }*/
    }
  }
}

/** @param {NS} ns */
export async function purchaseAndUpgradeServers(ns) {
  ns.disableLog("sleep");
  ns.disableLog("getServerMoneyAvailable");
  ns.disableLog("getServerMaxRam");
  let maxPurchasedServers = ns.getPurchasedServerLimit();
  let purchasedServers = [];
  let count = listPurchasedServers(ns).length;
  let currentMoney = 0;
  let serverList = {};
  while (count < maxPurchasedServers) {
    purchasedServers = listPurchasedServers(ns);
    currentMoney = ns.getServerMoneyAvailable("home");
    let targetRamInitial = 16;
    if (ns.getPurchasedServerCost(targetRamInitial) < currentMoney) {
      let hostname = ns.purchaseServer("pserv-" + purchasedServers.length, 16);

      count = listPurchasedServers(ns).length;
      serverList = JSON.parse(ns.read("serverList.txt"));
      serverList[hostname] = {
        serverName: hostname,
        maxRam: 16,
        maxMoney: 0,
        minSec: 0,
        minPorts: 5,
        minHackLvl: 1,
        rootAccess: true,
        factorMoneyPerTime: 99999999,
        openPorts: 0,
      };
      ns.write("serverList.txt", JSON.stringify(serverList), "w");
      continue
    } else {
      await ns.sleep(5000);
    }
  }

  let i = 5;
  while (i < 21) {
    let targetRam = 2 ** i;
    purchasedServers = listPurchasedServers(ns);
    for (let currentServer of purchasedServers) {
      currentMoney = ns.getServerMoneyAvailable("home");

      if (ns.getServerMaxRam(currentServer) < targetRam && ns.getPurchasedServerUpgradeCost(currentServer, targetRam) < currentMoney) {
        if (ns.upgradePurchasedServer(currentServer, targetRam)) {
          ns.print(currentServer + " upgraded to " + targetRam + " GB RAM");
          serverList = JSON.parse(ns.read("serverList.txt"));
          serverList[currentServer].maxRam = targetRam;
          ns.write("serverList.txt", JSON.stringify(serverList), "w");
        }
      } else {
        await ns.sleep(5000);
        continue
      };
    }
    ++i;
  }
  ns.tprint("Extiting purchaseServers script!")
}

/** @param {NS} ns */
function listPurchasedServers(ns) {
  return ns.getPurchasedServers();
}

/** @param {NS} ns */
export async function runControllerOnPserv(ns) {
  let purchasedServers = listPurchasedServers(ns);
  let nPID = 0;
  nPID = ns.exec("S2controller.js", "home");
  ns.tprint("Started S2controller.js on " + "home" + " with PID " + nPID)
  for (let currentServer of purchasedServers) {
    ns.scp(["S2tGrow.js", "S2tWeaken.js", "S2tHack.js", "S2controller.js", "S2utils.js"], currentServer, "home");
    nPID = ns.exec("S2controller.js", currentServer);
    if (nPID > 0) {
      ns.tprint("Started S2controller.js on " + currentServer + " with PID " + nPID)
    }
  }
}

/** @param {NS} ns */
export async function backdoor(ns) {
  let serverList = JSON.parse(ns.read("serverList.txt"));
  let lasthackingLevel = 0;
  let currentHackingLevel = 0;
  while (true) {
    currentHackingLevel = ns.getHackingLevel();
    if (currentHackingLevel > lasthackingLevel) {
      lasthackingLevel = currentHackingLevel;
      for (const [name, entry] of Object.entries(serverList)) {
        if (entry.minHackLvl <= lasthackingLevel && entry.hasBackdoor !== true) {
          ns.singularity.connect(name);
          await ns.singularity.installBackdoor();
          ns.singularity.connect("home");
          serverList[name].hasBackdoor = true;
          ns.tprint("Backdoor on: " + name);
        }
      }
      ns.write("serverList.txt", JSON.stringify(serverList), "w");
    } else {
      await ns.sleep(30000)
    };

  }
}