import { IPlayer } from "../PersonObjects/IPlayer";
import { calculateServerGrowth } from "../Server/formulas/grow";
import {
  calculateMoneyGainRate,
  calculateLevelUpgradeCost,
  calculateRamUpgradeCost,
  calculateCoreUpgradeCost,
  calculateNodeCost,
} from "../Hacknet/formulas/HacknetNodes";
import {
  calculateHashGainRate as HScalculateHashGainRate,
  calculateLevelUpgradeCost as HScalculateLevelUpgradeCost,
  calculateRamUpgradeCost as HScalculateRamUpgradeCost,
  calculateCoreUpgradeCost as HScalculateCoreUpgradeCost,
  calculateCacheUpgradeCost as HScalculateCacheUpgradeCost,
  calculateServerCost as HScalculateServerCost,
} from "../Hacknet/formulas/HacknetServers";
import { HacknetNodeConstants, HacknetServerConstants } from "../Hacknet/data/Constants";
import { calculateSkill, calculateExp } from "../PersonObjects/formulas/skill";
import {
  calculateHackingChance,
  calculateHackingExpGain,
  calculatePercentMoneyHacked,
  calculateHackingTime,
  calculateGrowTime,
  calculateWeakenTime,
} from "../Hacking";
import { Programs } from "../Programs/Programs";
import {
  Formulas as IFormulas,
  HacknetNodeConstants as DefHacknetNodeConstants,
  HacknetServerConstants as DefHacknetServerConstants,
} from "../ScriptEditor/NetscriptDefinitions";
import {
  calculateRespectGain,
  calculateWantedLevelGain,
  calculateMoneyGain,
  calculateWantedPenalty,
  calculateAscensionMult,
  calculateAscensionPointsGain,
} from "../Gang/formulas/formulas";
import { favorToRep as calculateFavorToRep, repToFavor as calculateRepToFavor } from "../Faction/formulas/favor";
import { repFromDonation } from "../Faction/formulas/donation";
import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
import { helpers } from "../Netscript/NetscriptHelpers";

export function NetscriptFormulas(player: IPlayer): InternalAPI<IFormulas> {
  const checkFormulasAccess = function (ctx: NetscriptContext): void {
    if (!player.hasProgram(Programs.Formulas.name)) {
      throw helpers.makeRuntimeErrorMsg(ctx, `Requires Formulas.exe to run.`);
    }
  };
  return {
    reputation: {
      calculateFavorToRep:
        (ctx: NetscriptContext) =>
        (_favor: unknown): number => {
          const favor = helpers.number(ctx, "favor", _favor);
          checkFormulasAccess(ctx);
          return calculateFavorToRep(favor);
        },
      calculateRepToFavor:
        (ctx: NetscriptContext) =>
        (_rep: unknown): number => {
          const rep = helpers.number(ctx, "rep", _rep);
          checkFormulasAccess(ctx);
          return calculateRepToFavor(rep);
        },
      repFromDonation:
        (ctx: NetscriptContext) =>
        (_amount: unknown, _player: unknown): number => {
          const amount = helpers.number(ctx, "amount", _amount);
          const player = helpers.player(ctx, _player);
          checkFormulasAccess(ctx);
          return repFromDonation(amount, player);
        },
    },
    skills: {
      calculateSkill:
        (ctx: NetscriptContext) =>
        (_exp: unknown, _mult: unknown = 1): number => {
          const exp = helpers.number(ctx, "exp", _exp);
          const mult = helpers.number(ctx, "mult", _mult);
          checkFormulasAccess(ctx);
          return calculateSkill(exp, mult);
        },
      calculateExp:
        (ctx: NetscriptContext) =>
        (_skill: unknown, _mult: unknown = 1): number => {
          const skill = helpers.number(ctx, "skill", _skill);
          const mult = helpers.number(ctx, "mult", _mult);
          checkFormulasAccess(ctx);
          return calculateExp(skill, mult);
        },
    },
    hacking: {
      hackChance:
        (ctx: NetscriptContext) =>
        (_server: unknown, _player: unknown): number => {
          const server = helpers.server(ctx, _server);
          const player = helpers.player(ctx, _player);
          checkFormulasAccess(ctx);
          return calculateHackingChance(server, player);
        },
      hackExp:
        (ctx: NetscriptContext) =>
        (_server: unknown, _player: unknown): number => {
          const server = helpers.server(ctx, _server);
          const player = helpers.player(ctx, _player);
          checkFormulasAccess(ctx);
          return calculateHackingExpGain(server, player);
        },
      hackPercent:
        (ctx: NetscriptContext) =>
        (_server: unknown, _player: unknown): number => {
          const server = helpers.server(ctx, _server);
          const player = helpers.player(ctx, _player);
          checkFormulasAccess(ctx);
          return calculatePercentMoneyHacked(server, player);
        },
      growPercent:
        (ctx: NetscriptContext) =>
        (_server: unknown, _threads: unknown, _player: unknown, _cores: unknown = 1): number => {
          const server = helpers.server(ctx, _server);
          const player = helpers.player(ctx, _player);
          const threads = helpers.number(ctx, "threads", _threads);
          const cores = helpers.number(ctx, "cores", _cores);
          checkFormulasAccess(ctx);
          return calculateServerGrowth(server, threads, player, cores);
        },
      hackTime:
        (ctx: NetscriptContext) =>
        (_server: unknown, _player: unknown): number => {
          const server = helpers.server(ctx, _server);
          const player = helpers.player(ctx, _player);
          checkFormulasAccess(ctx);
          return calculateHackingTime(server, player) * 1000;
        },
      growTime:
        (ctx: NetscriptContext) =>
        (_server: unknown, _player: unknown): number => {
          const server = helpers.server(ctx, _server);
          const player = helpers.player(ctx, _player);
          checkFormulasAccess(ctx);
          return calculateGrowTime(server, player) * 1000;
        },
      weakenTime:
        (ctx: NetscriptContext) =>
        (_server: unknown, _player: unknown): number => {
          const server = helpers.server(ctx, _server);
          const player = helpers.player(ctx, _player);
          checkFormulasAccess(ctx);
          return calculateWeakenTime(server, player) * 1000;
        },
    },
    hacknetNodes: {
      moneyGainRate:
        (ctx: NetscriptContext) =>
        (_level: unknown, _ram: unknown, _cores: unknown, _mult: unknown = 1): number => {
          const level = helpers.number(ctx, "level", _level);
          const ram = helpers.number(ctx, "ram", _ram);
          const cores = helpers.number(ctx, "cores", _cores);
          const mult = helpers.number(ctx, "mult", _mult);
          checkFormulasAccess(ctx);
          return calculateMoneyGainRate(level, ram, cores, mult);
        },
      levelUpgradeCost:
        (ctx: NetscriptContext) =>
        (_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
          const startingLevel = helpers.number(ctx, "startingLevel", _startingLevel);
          const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
          const costMult = helpers.number(ctx, "costMult", _costMult);
          checkFormulasAccess(ctx);
          return calculateLevelUpgradeCost(startingLevel, extraLevels, costMult);
        },
      ramUpgradeCost:
        (ctx: NetscriptContext) =>
        (_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
          const startingRam = helpers.number(ctx, "startingRam", _startingRam);
          const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
          const costMult = helpers.number(ctx, "costMult", _costMult);
          checkFormulasAccess(ctx);
          return calculateRamUpgradeCost(startingRam, extraLevels, costMult);
        },
      coreUpgradeCost:
        (ctx: NetscriptContext) =>
        (_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number => {
          const startingCore = helpers.number(ctx, "startingCore", _startingCore);
          const extraCores = helpers.number(ctx, "extraCores", _extraCores);
          const costMult = helpers.number(ctx, "costMult", _costMult);
          checkFormulasAccess(ctx);
          return calculateCoreUpgradeCost(startingCore, extraCores, costMult);
        },
      hacknetNodeCost:
        (ctx: NetscriptContext) =>
        (_n: unknown, _mult: unknown): number => {
          const n = helpers.number(ctx, "n", _n);
          const mult = helpers.number(ctx, "mult", _mult);
          checkFormulasAccess(ctx);
          return calculateNodeCost(n, mult);
        },
      constants: (ctx: NetscriptContext) => (): DefHacknetNodeConstants => {
        checkFormulasAccess(ctx);
        return Object.assign({}, HacknetNodeConstants);
      },
    },
    hacknetServers: {
      hashGainRate:
        (ctx: NetscriptContext) =>
        (_level: unknown, _ramUsed: unknown, _maxRam: unknown, _cores: unknown, _mult: unknown = 1): number => {
          const level = helpers.number(ctx, "level", _level);
          const ramUsed = helpers.number(ctx, "ramUsed", _ramUsed);
          const maxRam = helpers.number(ctx, "maxRam", _maxRam);
          const cores = helpers.number(ctx, "cores", _cores);
          const mult = helpers.number(ctx, "mult", _mult);
          checkFormulasAccess(ctx);
          return HScalculateHashGainRate(level, ramUsed, maxRam, cores, mult);
        },
      levelUpgradeCost:
        (ctx: NetscriptContext) =>
        (_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
          const startingLevel = helpers.number(ctx, "startingLevel", _startingLevel);
          const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
          const costMult = helpers.number(ctx, "costMult", _costMult);
          checkFormulasAccess(ctx);
          return HScalculateLevelUpgradeCost(startingLevel, extraLevels, costMult);
        },
      ramUpgradeCost:
        (ctx: NetscriptContext) =>
        (_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
          const startingRam = helpers.number(ctx, "startingRam", _startingRam);
          const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
          const costMult = helpers.number(ctx, "costMult", _costMult);
          checkFormulasAccess(ctx);
          return HScalculateRamUpgradeCost(startingRam, extraLevels, costMult);
        },
      coreUpgradeCost:
        (ctx: NetscriptContext) =>
        (_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number => {
          const startingCore = helpers.number(ctx, "startingCore", _startingCore);
          const extraCores = helpers.number(ctx, "extraCores", _extraCores);
          const costMult = helpers.number(ctx, "costMult", _costMult);
          checkFormulasAccess(ctx);
          return HScalculateCoreUpgradeCost(startingCore, extraCores, costMult);
        },
      cacheUpgradeCost:
        (ctx: NetscriptContext) =>
        (_startingCache: unknown, _extraCache: unknown = 1): number => {
          const startingCache = helpers.number(ctx, "startingCache", _startingCache);
          const extraCache = helpers.number(ctx, "extraCache", _extraCache);
          checkFormulasAccess(ctx);
          return HScalculateCacheUpgradeCost(startingCache, extraCache);
        },
      hashUpgradeCost:
        (ctx: NetscriptContext) =>
        (_upgName: unknown, _level: unknown): number => {
          const upgName = helpers.string(ctx, "upgName", _upgName);
          const level = helpers.number(ctx, "level", _level);
          checkFormulasAccess(ctx);
          const upg = player.hashManager.getUpgrade(upgName);
          if (!upg) {
            throw helpers.makeRuntimeErrorMsg(ctx, `Invalid Hash Upgrade: ${upgName}`);
          }
          return upg.getCost(level);
        },
      hacknetServerCost:
        (ctx: NetscriptContext) =>
        (_n: unknown, _mult: unknown = 1): number => {
          const n = helpers.number(ctx, "n", _n);
          const mult = helpers.number(ctx, "mult", _mult);
          checkFormulasAccess(ctx);
          return HScalculateServerCost(n, mult);
        },
      constants: (ctx: NetscriptContext) => (): DefHacknetServerConstants => {
        checkFormulasAccess(ctx);
        return Object.assign({}, HacknetServerConstants);
      },
    },
    gang: {
      wantedPenalty:
        (ctx: NetscriptContext) =>
        (_gang: unknown): number => {
          const gang = helpers.gang(ctx, _gang);
          checkFormulasAccess(ctx);
          return calculateWantedPenalty(gang);
        },
      respectGain:
        (ctx: NetscriptContext) =>
        (_gang: unknown, _member: unknown, _task: unknown): number => {
          const gang = helpers.gang(ctx, _gang);
          const member = helpers.gangMember(ctx, _member);
          const task = helpers.gangTask(ctx, _task);
          checkFormulasAccess(ctx);
          return calculateRespectGain(gang, member, task);
        },
      wantedLevelGain:
        (ctx: NetscriptContext) =>
        (_gang: unknown, _member: unknown, _task: unknown): number => {
          const gang = helpers.gang(ctx, _gang);
          const member = helpers.gangMember(ctx, _member);
          const task = helpers.gangTask(ctx, _task);
          checkFormulasAccess(ctx);
          return calculateWantedLevelGain(gang, member, task);
        },
      moneyGain:
        (ctx: NetscriptContext) =>
        (_gang: unknown, _member: unknown, _task: unknown): number => {
          const gang = helpers.gang(ctx, _gang);
          const member = helpers.gangMember(ctx, _member);
          const task = helpers.gangTask(ctx, _task);
          checkFormulasAccess(ctx);
          return calculateMoneyGain(gang, member, task);
        },
      ascensionPointsGain:
        (ctx: NetscriptContext) =>
        (_exp: unknown): number => {
          const exp = helpers.number(ctx, "exp", _exp);
          checkFormulasAccess(ctx);
          return calculateAscensionPointsGain(exp);
        },
      ascensionMultiplier:
        (ctx: NetscriptContext) =>
        (_points: unknown): number => {
          const points = helpers.number(ctx, "points", _points);
          checkFormulasAccess(ctx);
          return calculateAscensionMult(points);
        },
    },
  };
}