import multiply from "./multiply";

import divide from "./divide";

import compare, { isEqual } from "./compare";

import { parseStringNumber, isInteger, isZero } from "./utils";

/**

* Raises a number to an integer power (simple repeated multiplication)

* @param base Base number as string

* @param exponent Integer exponent as string

* @returns Result as string

*/

function powerInteger(base: string, exponent: string): string {

if (isZero(exponent)) {

return "1";

}

if (isZero(base)) {

return "0";

}

if (isEqual(exponent, "1")) {

return base;

}

const expParsed = parseStringNumber(exponent);

let isNegativeExp = expParsed.sign === -1;

let absExp = expParsed.integerPart;

// Simple repeated multiplication for now (can optimize later)

let result = "1";

let counter = "0";

while (compare(counter, absExp) < 0) {

result = multiply(result, base);

counter = add(counter, "1");

}

// If exponent was negative, return 1/result

if (isNegativeExp) {

return divide("1", result, 20);

}

return result;

}

/**

* Divides a number by 2 (integer division)

* @param num Number as string

* @returns Result as string

*/

function divideByTwo(num: string): string {

if (isZero(num)) return "0";

if (isEqual(num, "1")) return "0";

// Use existing divide function

return divide(num, "2", 0);

}

/**

* Raises a number to a power

* @param base Base number as string

* @param exponent Exponent as string

* @returns Result as string

*/

export function pow(base: string, exponent: string): string {

if (!isInteger(exponent)) {

throw new Error("Non-integer exponents are not supported yet");

}

if (isZero(base) && compare(exponent, "0") < 0) {

throw new Error("Cannot raise zero to a negative power");

}

return powerInteger(base, exponent);

}

/**

* Calculates the nth root of a number using Newton's method

* @param radicand The number to find the root of

* @param n The root degree (must be positive integer)

* @param precision Number of decimal places (default 20)

* @returns Result as string

*/

export function nthRoot(radicand: string, n: string, precision: number = 20): string {

if (!isInteger(n)) {

throw new Error("Root degree must be an integer");

}

if (compare(n, "0") <= 0) {

throw new Error("Root degree must be positive");

}

if (isZero(radicand)) {

return "0";

}

if (isEqual(n, "1")) {

return radicand;

}

const radicandParsed = parseStringNumber(radicand);

if (isEqual(n, "2")) {

// For even root of negative number, handle before calling sqrt

if (radicandParsed.sign === -1) {

throw new Error("Cannot take even root of negative number");

}

// Use existing sqrt function with precision parameter

const sqrt = require("./sqrt").default;

return sqrt(radicand, precision);

}

// For negative radicand and even root, throw error

if (radicandParsed.sign === -1) {

const nParsed = parseStringNumber(n);

const nLastDigit = nParsed.integerPart[nParsed.integerPart.length - 1];

const nLastDigitValue = nLastDigit.charCodeAt(0) - "0".charCodeAt(0);

if (nLastDigitValue % 2 === 0) {

throw new Error("Cannot take even root of negative number");

}

}

const absRadicand = radicandParsed.sign === -1 ? radicandParsed.integerPart + (radicandParsed.fractionalPart ? "." + radicandParsed.fractionalPart : "") : radicand;

// Newton's method: x_{n+1} = (1/n) * ((n-1)*x_n + radicand/x_n^(n-1))

let x = absRadicand; // Initial guess

// Better initial guess

if (compare(absRadicand, "1") > 0) {

x = divide(absRadicand, n, precision + 5);

} else {

x = absRadicand;

}

const tolerance = "0." + "0".repeat(precision) + "1";

const maxIterations = 100;

for (let i = 0; i < maxIterations; i++) {

// x_n^(n-1)

const xPowerNMinus1 = powerInteger(x, subtract(n, "1"));

// radicand / x_n^(n-1)

const quotient = divide(absRadicand, xPowerNMinus1, precision + 5);

// (n-1) * x_n

const nMinus1TimesX = multiply(subtract(n, "1"), x);

// (n-1) * x_n + radicand / x_n^(n-1)

const sum = add(nMinus1TimesX, quotient);

// x_{n+1} = sum / n

const newX = divide(sum, n, precision + 5);

// Check convergence

const diff = abs(subtract(newX, x));

if (compare(diff, tolerance) < 0) {

x = newX;

break;

}

x = newX;

}

// Round to specified precision

const result = divide(x, "1", precision);

// Apply original sign for odd roots

if (radicandParsed.sign === -1) {

return "-" + result;

}

return result;

}

// Import helper functions directly

import add from "./add";

import subtract from "./subtract";

import abs from "./abs";