/***
bigint.inc - Big Integers Operation Library Functions

Version: 0.1
Date: 28-12-2014
Author: Statik

Provides some arithmetic and logical maths functions to operate 
with big integers.

**UNFINISHED**

***/

#if defined _BigInt_included
	#endinput
#endif

#define _BigInt_included

stock modpowBigInt(base[], exponent[], modulus[], nBase, output[], oSize) // http://en.wikipedia.org/wiki/Modular_exponentiation
{ // Modular exponentiation, Right-to-left binary method (binary exponentiation + memory efficient method)
	new eSize = getBigIntSize(exponent);
	new mSize = getBigIntSize(modulus);
	new auxSize = (mSize+1)*2; // output and base (pow base) are never bigger than modulus
	decl aux[auxSize];
	decl auxBase[auxSize]; // Is used as a replacemente of the power base, not the numeric base
	decl auxExponent[eSize+1];
	new parity[2];
	
	output[0] = 1;
	output[1] = -1;
	copyBigInt(base, auxBase, auxSize);
	copyBigInt(exponent, auxExponent, eSize+1);
	modBigInt(base, modulus, nBase, auxBase, auxSize);
	
	while (isBiggerThanBigNumber(auxExponent, {0,-1})) // exponent > 0
	{
		fulldivBigInt(auxExponent, {2,-1}, nBase, auxExponent, eSize+1, parity, sizeof(parity));
		if (parity[0] == 1) // (exponent % 2) == 1 / Is exponent odd?
		{
			multBigInt(output, auxBase, nBase, aux, auxSize);
			modBigInt(aux, modulus, nBase, output, oSize);
		}
		multBigInt(auxBase, auxBase, nBase, auxBase, auxSize);
		modBigInt(auxBase, modulus, nBase, auxBase, auxSize);
	}
}

stock powBigInt(number[], exponent[], base, output[], oSize) // Exponentiation by squaring recursive algorithm **UNFINISHED**
{ // http://en.wikipedia.org/wiki/Exponentiation_by_squaring
	new nSize = getBigIntSize(number);
	new eSize = getBigIntSize(exponent);
	if (!isBiggerThanBigNumber(exponent, {0,-1})) // Exponent is 0
	{
		output[0] = 1;
		output[1] = -1;
		return;
	}
	if (!isBiggerThanBigNumber(exponent, {1,-1})) // Exponent is 1
	{
		for (new i = 0; i <= nSize; i++)
		{
			output[i] = number[i];
		}
		return;
	}
	new bool:isExponentEven = (exponent[0] % 2) == 0;
	multBigInt(number, number, base, output, oSize); // number^2
	if (!isBiggerThanBigNumber(exponent, {2,-1})) return;
	
	if (isExponentEven)
	{
		//powBigInt(output, exponent/2, base, output, oSize);
	}
	else
	{
		
		//powBigInt(output, exponent-1/2, base, output, oSize);
	}
}

stock multBigInt(n1[], n2[], base, output[], oSize)
{
	new n1Size = getBigIntSize(n1);
	new n2Size = getBigIntSize(n2);
	if (n1Size < 40000 && n2Size < 40000)
	{
		standardMult(n1, n2, base, output, oSize);
	}
	else
	{
		karatsubaMult(n1, n2, base, output, oSize);
	}
}

stock divBigInt(n1[], n2[], base, output[], oSize)
{
	new n2Size = getBigIntSize(n2);
	decl remainder[n2Size+1]; // Remainder is never bigger than divisor/denominator
	fulldivBigInt(n1, n2, base, output, oSize, remainder, n2Size+1);
}

stock modBigInt(n1[], n2[], base, output[], oSize)
{
	new n1Size = getBigIntSize(n1);
	decl quotient[n1Size+1]; // Quotient is never bigger than dividend/numerator
	fulldivBigInt(n1, n2, base, quotient, n1Size+1, output, oSize);
}

stock fulldivBigInt(n1[], n2[], base, quotient[], qSize, remainder[], rSize)
{
	new n1Size = getBigIntSize(n1);
	new n2Size = getBigIntSize(n2);
	
	if (qSize < (n1Size+1)) return;
	if (!isBiggerThanBigNumber(n2, {0,-1})) // n2 == 0
		return;
	
	if (n2Size > n1Size)
	{
		quotient[0] = 0;
		quotient[1] = -1;
		copyBigInt(n1, remainder, rSize);
		return;
	}
	decl tempRemainder[rSize+1];
	tempRemainder[0] = -1;
	quotient[n1Size] = -1;
	new i;
	for (i = n1Size-1; i >= 0; i--)
	{
		leftShiftBigInt(tempRemainder, 1);
		trimBigInt(tempRemainder);
		tempRemainder[0] = n1[i];
		quotient[i] = 0;
		while (!isBiggerThanBigNumber(n2, tempRemainder)) // (tempRemainder >= n2)
		{
			subBigInt(tempRemainder, n2, base, tempRemainder, rSize);
			quotient[i]++;
		}
	}
	copyBigInt(tempRemainder, remainder, rSize);
	trimBigInt(quotient);
}

stock karatsubaMult(n1[], n2[], base, output[], oSize) // Karatsuba recursive algorithm
{	// http://en.wikipedia.org/wiki/Karatsuba_algorithm#Pseudo_Code_Implementation
	if (oSize < 2) return;
	new n1Size = getBigIntSize(n1);
	new n2Size = getBigIntSize(n2);
	if (n1Size == 1 || n2Size == 1) // Base case 
	{
		standardMult(n1, n2, base, output, oSize);
		return;
	}
	new m = (n1Size > n2Size) ? n1Size : n2Size;
	new m2 = m/2;
	
	decl l1[oSize], h1[oSize];
	decl l2[oSize], h2[oSize];
	splitBigIntAt(n1, m2, l1, oSize, h1, oSize);
	splitBigIntAt(n2, m2, l2, oSize, h2, oSize);
	
	decl z0[oSize]; // <-
	karatsubaMult(l1, l2, base, z0, oSize);
	//standardMult(l1, l2, base, z0, oSize);
	
	decl z1[oSize]; // <-
	decl l1plush1[oSize];
	decl l2plush2[oSize];
	addBigInt(l1, h1, base, l1plush1, oSize);
	addBigInt(l2, h2, base, l2plush2, oSize);
	karatsubaMult(l1plush1, l2plush2, base, z1, oSize);
	//standardMult(l1plush1, l2plush2, base, z1, oSize);
	
	decl z2[oSize]; // <-
	karatsubaMult(h1, h2, base, z2, oSize);
	//standardMult(h1, h2, base, z2, oSize);
	
	decl z3[oSize]; // <-
	subBigInt(z1, z2, base, z3, oSize);
	subBigInt(z3, z0, base, z3, oSize);
	
	leftShiftBigInt(z2, 2*m2);
	leftShiftBigInt(z3, m2);
	
	addBigInt(z2, z3, base, output, oSize);
	addBigInt(output, z0, base, output, oSize);
	
	trimBigInt(output);
}

stock standardMult(n1[], n2[], base, output[], oSize)
{
	new n1Size = getBigIntSize(n1);
	new n2Size = getBigIntSize(n2);
	new bool:n1b = isBiggerThanBigNumber(n1, n2); // Is n1 bigger
	new sSize = (n1b) ? n2Size : n1Size; // Smallest size
	new bSize = (n1b) ? n1Size : n2Size; // Biggest size
	new carry = 0;
	decl value[sSize][oSize];
	new temp, i, u;
	for (i = 0; i < sSize; i++)
	{
		for (u = 0; u < bSize; u++)
		{
			temp = n1[(n1b)?u:i] * n2[(n1b)?i:u] + carry;
			if (temp >= base)
			{
				carry = temp / base;
				value[i][u] = temp % base;
			}
			else
			{
				carry = 0;
				value[i][u] = temp;
			}
		}
		if (carry != 0)
		{
			value[i][u] = carry;
			value[i][u+1] = -1;
			carry = 0;
		}
		else 
		{
			value[i][u] = -1;
		}
		leftShiftBigInt(value[i], i);
	}
	output[0] = -1; // Initializes output
	for (i = 0; i < sSize; i++)
	{
		addBigInt(output, value[i], base, output, oSize);
	}
	trimBigInt(output);
}

stock addBigInt(n1[], n2[], base, output[], oSize) // Standard algorithm
{
	new n1Size = getBigIntSize(n1);
	new n2Size = getBigIntSize(n2);
	new carry = 0;
	new temp;
	new i;
	for (i = 0; (i < n1Size || i < n2Size); i++)
	{
		if (i == oSize) return;
		if (i >= n1Size) temp = n2[i] + carry;
		else if (i >= n2Size) temp = n1[i] + carry;
		else temp = n1[i] + n2[i] + carry;
		
		if (temp >= base)
		{
			output[i] = temp - base;
			carry = 1;
		}
		else
		{
			output[i] = temp;
			carry = 0;
		}
	}
	if (carry == 1) // Adds the last carry
	{
		output[i] = carry;
		output[i+1] = -1;
	}
	else output[i] = -1;
	trimBigInt(output);
}

stock subBigInt(n1[], n2[], base, output[], oSize) // Standard algorithm
{
	new n1Size = getBigIntSize(n1);
	new n2Size = getBigIntSize(n2);
	new carry = 0;
	new temp;
	new i;
	for (i = 0; (i < n1Size || i < n2Size); i++)
	{
		if (i == oSize) return;
		if (i >= n1Size) temp = n2[i] - carry;
		else if (i >= n2Size) temp = n1[i] - carry;
		else temp = n1[i] - n2[i] - carry;
		
		if (temp < 0)
		{
			output[i] =  temp + base;
			carry = 1;
		}
		else
		{
			output[i] = temp;
			carry = 0;
		}
	}
	output[i] = -1;
	trimBigInt(output);
}

stock bool:splitBigIntAt(number[], index, lowOut[], loSize, highOut[], hoSize)
{
	new nSize = getBigIntSize(number);
	if (index == 0) return false;
	if (index >= nSize) return false;
	if (index >= loSize) return false;
	if (nSize-index >= hoSize) return false;
	
	new i;
	for (i = 0; i < index; i++)
	{
		lowOut[i] = number[i];
	}
	lowOut[i] = -1;
	trimBigInt(lowOut);
	
	for (i = index; i < nSize; i++)
	{
		highOut[i-index] = number[i];
	}
	highOut[i-index] = -1;
	trimBigInt(highOut);
	
	return true;
}

stock bool:isEqualToBigNumber(n1[], n2[])
{
	new n1Size = getBigIntSize(n1);
	new n2Size = getBigIntSize(n2);
	if (n1Size != n2Size) return false;
	
	for (new i = 0; i < n1Size; i++)
	{
		if (n1[i] != n2[i]) return false;
	}
	return true;
}

stock bool:isBiggerThanBigNumber(n1[], n2[])
{
	new n1Size = getBigIntSize(n1);
	new n2Size = getBigIntSize(n2);
	if (n1Size > n2Size) return true;
	if (n1Size < n2Size) return false;
	
	for (new i = (n1Size-1); i >= 0; i--)
	{
		if (n1[i] == n2[i]) continue;
		else if (n1[i] > n2[i]) return true;
		else return false;
	}
	return false; // In case both numbers are the same
}

stock leftShiftBigInt(number[], digits) // Logical shift
{
	if (digits == 0) return;
	new nSize = getBigIntSize(number);
	decl temp[nSize+1];
	for (new i = 0; i <= nSize; i++) // Creates a backup
	{
		temp[i] = number[i];
	}
	for (new a = 0; a < digits; a++) // Fills with zeros
	{
		number[a] = 0;
	}
	for (new i = 0; i <= nSize; i++) // Puts the backup back in
	{
		number[i+digits] = temp[i];
	}
	trimBigInt(number);
}

stock trimBigInt(number[]) // Removes left padded zeros
{
	new nSize = getBigIntSize(number);
	for (new zeros = 0; number[nSize-zeros-1] == 0; zeros++)
	{ 
		if (nSize-zeros-1 != 0) number[nSize-zeros-1] = -1;
	}
}

stock copyBigInt(number[], output[], oSize)
{
	new nSize = getBigIntSize(number);
	if (oSize <= nSize) return;
	for (new i = 0; i <= nSize; i++)
	{
		output[i] = number[i];
	}
}

stock getBigIntSize(number[])
{
	new i;
	for (i = 0; number[i] != -1; i++){}
	return i;
}

stock toBase256BigInt(number[], output[], oLength)
{
	new nSize = getBigIntSize(number);
	new finalLength = nSize/2 + (nSize%2);
	if (oLength < finalLength) return 0;
	new i;
	new high, low;
	
	for (i = 0; i < finalLength; i++)
	{
		if ((i == finalLength-1) && nSize%2 == 1)
			high = 0;
		else
			high = number[i*2+1];
		low = number[i*2];
		output[finalLength-i-1] = (high << 4) + low;
	}
	return finalLength;
}

stock bool:hexString2BigInt(const String:hexString[], output[], oSize)
{

	new i;
	new temp[oSize];
	for(i = 0; hexString[i] != 0; i++)
	{
		if (i >= oSize) return false;
		temp[i] = hexChar2Int(hexString[i]);
		
		if (temp[i] == -1) return false;
	}
	// Inverts number string
	for (new u = 0; u < i; u++)
	{
		output[u] = temp[i-u-1];
	}
	output[i] = -1; // Terminates the number string
	trimBigInt(output);
	return true;
}

stock bool:bigInt2HexString(input[], String:hexString[], hsSize)
{
	new nSize = getBigIntSize(input);
	new i;
	for (i = 0; i < (hsSize-1); i++)
	{
		if (i == nSize) break;
		if ((hexString[i] = int2HexChar(input[nSize-i-1])) == -1) return false;
	}
	hexString[i] = 0;
	return true;
	
}

stock hexChar2Int(input)
{
	if(input >= '0' && input <= '9')
		return input - '0';
	if(input >= 'A' && input <= 'F')
		return input - 'A' + 10;
	if(input >= 'a' && input <= 'f')
		return input - 'a' + 10;
	return -1;
}

stock int2HexChar(input)
{
	if (input >= 0 && input <= 9)
		return input + '0';
	if (input >= 10 && input <= 16)
		return input + 'A' - 10;
	return -1;	
}

/*
test()
{
	// LOTS OF TESTS
	PrintDebug(caller, "Modulus size: %i", getBigIntSize(modulus));
	
	/// Addition test
	new n1[] = {0xC,9,4,9,0xF,0,-1};
	new n2[] = {0,0x3,5,7,-1};
	decl String:s1[7];
	decl String:s2[7];
	bigInt2HexString(n1, s1, sizeof(s1));
	bigInt2HexString(n2, s2, sizeof(s2));
	PrintDebug(caller, "HEX 1 : %s", s1);
	PrintDebug(caller, "HEX 2 : %s", s2);
	new a[20];
	addBigInt(n1, n2, 16, a, sizeof(a));
	new String:sa[20];
	bigInt2HexString(a, sa, sizeof(sa));
	PrintDebug(caller, "HEX 1 + HEX 2 = %s", sa);
	
	/// Split test
	new n3[] = {4,6,8,2,5,7,3,4,7,2,-1};
	new n4[15];
	new n5[15];
	splitBigIntAt(n3, 5, n4, sizeof(n4), n5, sizeof(n5));
	new String:s3[30];
	new String:s4[15];
	new String:s5[15];
	bigInt2HexString(n3, s3, sizeof(s3));
	bigInt2HexString(n4, s4, sizeof(s4));
	bigInt2HexString(n5, s5, sizeof(s5));
	PrintDebug(caller, "%s splitted at index %i", s3, 5);
	PrintDebug(caller, "Low: %s", s4);
	PrintDebug(caller, "High: %s", s5);
	
	/// Subtraction test
	new n6[] = {3,1,3,5,5,9,6,9,-1};
	new n7[] = {1,3,5,6,9,6,9,2,-1};
	decl String:s6[10];
	decl String:s7[10];
	bigInt2HexString(n6, s6, sizeof(s6));
	bigInt2HexString(n7, s7, sizeof(s7));
	new n8[10];
	new String:s8[10];
	subBigInt(n6, n7, 16, n8, sizeof(n8));
	bigInt2HexString(n8, s8, sizeof(s8));
	PrintDebug(caller, "Subtracting %s to %s...", s7, s6);
	PrintDebug(caller, "Result: %s", s8);
	
	/// Shift test
	new n9[] = {3,7,9,1,5,7,8,1,-1};
	decl String:s9[15];
	bigInt2HexString(n9, s9, sizeof(s9));
	PrintDebug(caller, "Shifting %s 3 numbers to left", s9);
	leftShiftBigInt(n9, 3);
	bigInt2HexString(n9, s9, sizeof(s9));
	PrintDebug(caller, "Result: %s", s9);
	
	/// Standard multiplication test
	new n10[] = {3,1,3,5,5,9,6,9,-1};
	new n11[] = {1,3,5,6,9,6,9,2,-1};
	decl String:s10[10];
	decl String:s11[10];
	bigInt2HexString(n10, s10, sizeof(s10));
	bigInt2HexString(n11, s11, sizeof(s11));
	new n12[30];
	new String:s12[30];
	standardMult(n10, n11, 16, n12, sizeof(n12));
	bigInt2HexString(n12, s12, sizeof(s12));
	PrintDebug(caller, "Multiplying (standard) %s to %s...", s10, s11);
	PrintDebug(caller, "Result: %s", s12);
	
	/// Karatsuba multiplication test
	new n13[] = {3,1,3,5,5,9,6,9,-1};
	new n14[] = {1,3,5,6,9,6,9,2,-1};
	decl String:s13[10];
	decl String:s14[10];
	bigInt2HexString(n13, s13, sizeof(s13));
	bigInt2HexString(n14, s14, sizeof(s14));
	new n15[30];
	new String:s15[30];
	karatsubaMult(n13, n14, 16, n15, sizeof(n15));
	bigInt2HexString(n15, s15, sizeof(s15));
	PrintDebug(caller, "Multiplying (karatsuba) %s to %s...", s13, s14);
	PrintDebug(caller, "Result: %s", s15);
	
	/// Exponentiation test
	new n16[] = {3,4,5,6,2,5,-1};
	new n17[] = {0,1,-1};
	decl String:s16[20];
	decl String:s17[20];
	bigInt2HexString(n16, s16, sizeof(s16));
	bigInt2HexString(n17, s17, sizeof(s17));
	new n18[30];
	new String:s18[30];
	powBigInt(n16, n17, 16, n18, sizeof(n18));
	bigInt2HexString(n18, s18, sizeof(s18));
	PrintDebug(caller, "Exponentiating %s to %s...", s16, s17);
	PrintDebug(caller, "Result: %s", s18);
	
	/// Division test
	new n19[] = {9,0xC,7,2,-1};
	new n20[] = {6,2,6,-1};
	decl String:s19[20];
	decl String:s20[20];
	bigInt2HexString(n19, s19, sizeof(s19));
	bigInt2HexString(n20, s20, sizeof(s20));
	new n21[30];
	new String:s21[30];
	new n22[30];
	new String:s22[30];
	fulldivBigInt(n19, n20, 16, n21, sizeof(n21), n22, sizeof(n22));
	bigInt2HexString(n21, s21, sizeof(s21));
	bigInt2HexString(n22, s22, sizeof(s22));
	PrintDebug(caller, "Dividing %s to %s...", s19, s20);
	PrintDebug(caller, "Quotient: %s - Remainder: %s", s21, s22);
	
	/// PKCS#1 v1.5 Padding Scheme test
	//decl String:aux[1024] = "BE629EA2D835880BF2572379CC751C5FA44F4A09B6F8CE5CB52C53EEDD0314E77AC827219E78DB1473BBA7BBE8BABC85C02CBC308B75375AE7C4B3AA31A491BB08D1946328F2B1BCE3E07E96D1CFF5E95A553C083A424CD5F6B7F2B55F89B958F0AE3B80A94CF5FEB3BD9417ABD09E1A42456E99128169CCEC176FDF7D2893A5";
	new k = strlen(hexModulus);
	new String:paddedMessage[k+1];
	pkcs1v15Pad(message, k, paddedMessage, k+1);
	PrintDebug(caller, "Padding message: %s with %i length modulus ", message, k);
	PrintDebug(caller, "Result: %i - %s", strlen(paddedMessage), paddedMessage);
	
	/// Modular exponentiation test

	decl n23[1024];
	decl n24[20];
	decl n25[1024];
	hexString2BigInt(paddedMessage, n23, 1024);
	hexString2BigInt(hexExponent, n24, 20);
	hexString2BigInt(hexModulus, n25, 1024);

	//new n23[] = {3,2,-1};
	//new n24[] = {5,-1};
	//new n25[] = {6,2,6,-1};
	new String:s23[1024];
	new String:s24[40];
	new String:s25[1024];
	new n26[1024];
	new String:s26[1024];
	modpowBigInt(n23, n24, n25, 16, n26, sizeof(n26));
	bigInt2HexString(n23, s23, sizeof(s23));
	bigInt2HexString(n24, s24, sizeof(s24));
	bigInt2HexString(n25, s25, sizeof(s25));
	bigInt2HexString(n26, s26, sizeof(s26));
	PrintDebug(caller, "Modular Power Test");
	PrintDebug(caller, "base = %s", s23);
	PrintDebug(caller, "exponent = %s", s24);
	PrintDebug(caller, "modulus = %s", s25);
	PrintDebug(caller, "Result size: %i, result = \n%s", getBigIntSize(n26), s26);
}
*/