/**
 * Encodes string into Base85.
 * @input {String} - The data to be encoded. This is passed to the function via the "this" keyword
 * @returns {String} The Base85 encoded data as string.
 */
String.prototype.toAscii85 = function(){
	/**
 	* Turns a single character (it ASCII code) to binary padded to 8 figures when necessary.
 	* @param {String} n - The single character whose ASCII code is to be converted to binary
 	* @returns {String} The binary of the ASCII code of n padded to 8 figures when necessary.
 	*/
	var encodeToBinary = function(n){
		let bin = n.charCodeAt(0);
		bin = bin.toString(2);
		bin = "0".repeat(8-bin.length) + bin;
		return bin;
	}
	let txt = [...this];
	let bin = "";
	for(let i = 0; i < txt.length; i++) bin += encodeToBinary(txt[i]);
	
	/* Pad the binary so it length is exactly divisible by 32 
	 * because we are going to divide it into chucks of 32's 
	 * We pad with "0"
	*/
	let padding = (32-(bin.length%32)); 
	if(padding%32 == 0) padding = 0; //If length is exactly divisible by 32 padding returns 32, so we reset it to 0
	for(let counter = 0; padding > 0 && counter < padding; counter++)
		bin += "0";
	
	//Divide whole binary to chunk of 32 characters
	let chunk = [];
	for(let i = 32; i <= bin.length; i += 32)
		chunk.push(bin.slice(i-32, i));
	
	/* Each chunk should be converted from binary to base 10
	 * The value should then be splitted into five integers
	 * chunk value (in base 10) = (int1*85^4) + (int2*85^3) + (int3*85^2) + (int4*85^1) + int5
	*/
	var ASCII = ""; 
	for(let i = 0; i < chunk.length; i++){
		let sub = parseInt(chunk[i], 2);
		let w1 = Math.floor(sub/Math.pow(85, 4));
		let w2 = Math.floor((sub-(w1*Math.pow(85, 4)))/Math.pow(85, 3));
		let w3 = Math.floor((sub-(w1*Math.pow(85, 4))-(w2*Math.pow(85, 3)))/Math.pow(85, 2));
		let w4 = Math.floor((sub-(w1*Math.pow(85, 4))-(w2*Math.pow(85, 3))-(w3*Math.pow(85, 2)))/Math.pow(85, 1));
		let w5 = sub-(w1*Math.pow(85, 4))-(w2*Math.pow(85, 3))-(w3*Math.pow(85, 2))-(w4*Math.pow(85, 1));
		
		//33 is added to each integer and convert to it corresponding ASCII character
		let sub1 = String.fromCharCode(w1+33);
		let sub2 = String.fromCharCode(w2+33);
		let sub3 = String.fromCharCode(w3+33);
		let sub4 = String.fromCharCode(w4+33);
		let sub5 = String.fromCharCode(w5+33);
		sub = sub1 + sub2 + sub3 + sub4 + sub5;
		
		//If chunk is just bunch of 0's just represent it with z
		if(sub == "!!!!!") sub = "z";
			
		ASCII += sub;
	}
	
	//Remove (padding/8) numbers of character from the final encoded characters
	for(let i = 0; (padding/8) != 0 && i < (padding/8); i++){
		if(ASCII == "z") ASCII = "!!!!!";
		ASCII = ASCII.substr(0, ASCII.length-1);
	}
	return "<~" + ASCII + "~>";
}

/**
 * Decodes Base85 encoded data into it original string.
 * @input {String} - The data to be decoded. This is passed to the function via the "this" keyword
 * @returns {String} The original decoded string from Base85.
 */
String.prototype.fromAscii85 = function(){
	//Remove white space and new lines
	let code = this.replace(/\s|\n/g,"");
	//remove beginning <~ and ending ~>
	code = code.replace(/^<~|~>$/g,"");
	//Replace all "z" with "!!!!!"
	code = code.replace(/z/g,"!!!!!");
	
	/* Pad the data so it length is exactly divisible by 5 
	 * because we are going to divide it into chucks of 5's 
	 * We pad with "u"
	*/
	let padding = 5 - (code.length%5); 
	if(padding%5 == 0) padding = 0; //If length is exactly divisible by 5 padding returns 5, so we reset it to 0
	code += "u".repeat(padding);
	
	//Divide padded data to chunk of 5 characters
	let chunk = [];
	for(let i = 5; i <= code.length; i += 5) chunk.push(code.slice(i-5, i));
	
	/*
	* Take each character in a chunk
	* Convert it to it ASCII code and subtract 33 from it
	* Raise it to the corresponding power of 85
	* And add the integers together
	* Convert it base 2 and pad it to 32 characters when necessary
	* Slice the 32 characters into 8 characters in 4 places
	* Convert each slice to base 10 and to the corresponding character of ASCII
	*/
	let txt = "";
	for(let i = 0; i < chunk.length; i++){
		let w1 = ((chunk[i][0]).charCodeAt(0)-33)*Math.pow(85,4);
		let w2 = ((chunk[i][1]).charCodeAt(0)-33)*Math.pow(85,3);
		let w3 = ((chunk[i][2]).charCodeAt(0)-33)*Math.pow(85,2);
		let w4 = ((chunk[i][3]).charCodeAt(0)-33)*Math.pow(85,1);
		let w5 = ((chunk[i][4]).charCodeAt(0)-33);
		let sub = w1+w2+w3+w4+w5;
		sub = sub.toString(2);
		sub = "0".repeat(32-sub.length)+sub;
		
		w1 = String.fromCharCode(parseInt(sub.slice(0, 8), 2));
		w2 = String.fromCharCode(parseInt(sub.slice(8, 16), 2));
		w3 = String.fromCharCode(parseInt(sub.slice(16, 24), 2));
		w4 = String.fromCharCode(parseInt(sub.slice(24, 32), 2));
		txt += w1+w2+w3+w4;
	}
	
	//Remove the number of padding added above from the strings
	for(let i = 0; i < padding; i++) txt = txt.substr(0, txt.length-1);
	
	return txt;
}

/**
 * Encodes string to Base64.
 * *****NOTICE the inbuilt btoa() can do this, this is just to understand what's going on under the hood******
 * @input {String} - The string to be encoded. This is passed to the function via the "this" keyword
 * @returns {String} The Base64 encoded data as string
 */
String.prototype.toBase64 = function(){
	var __codeString = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	
	/**
 	* Turns a single character (it ASCII code) to binary padded to 8 figures when necessary.
 	* @param {String} n - The single character whose ASCII code is to be converted to binary
 	* @returns {String} The binary of the ASCII code of n padded to 8 figures when necessary.
 	*/
	var encodeToBinary = function(n){
		let bin = n.charCodeAt(0);
		bin = bin.toString(2);
		bin = "0".repeat(8-bin.length) + bin;
		return bin;
	}

	let txt = [...this];
	let bin = "";
	for(let i = 0; i < txt.length; i++) bin += encodeToBinary(txt[i]);
	
	/* Pad the data so it length is exactly divisible by 24 
	 * because we are going to divide it into chucks of 24's 
	 * We pad with "0"
	*/
	let padding = (24-(bin.length%24)); 
	if(padding%24 == 0) padding = 0; //If length is exactly divisible by 24 padding returns 24, so we reset it to 0
	for(let counter = 0; padding > 0 && counter < padding; counter++)
		bin += "0";
	
	//Divide padded data to chunk of 24 characters
	let chunk = [];
	for(let i = 24; i <= bin.length; i += 24) chunk.push(bin.slice(i-24, i));
	
	/*
	* Slice the 24 characters in each chunk into 6 characters in 4 places
	* If a 6 character chunk is "000000" encode it as "="
	* Else convert the chunk to base10 and map it to our __codeString variable
	* i.e. if the chunk in base10 is 0, it is encoded as "A" (__codeString[0])
	*/
	let BASE64 = ""; 
	for(let i = 0; i < chunk.length; i++){
		let w1 = (chunk[i].slice(0, 6) == "000000")?"=":__codeString[parseInt(chunk[i].slice(0, 6), 2)];
		let w2 = (chunk[i].slice(6, 12) == "000000")?"=":__codeString[parseInt(chunk[i].slice(6, 12), 2)];
		let w3 = (chunk[i].slice(12, 18) == "000000")?"=":__codeString[parseInt(chunk[i].slice(12, 18), 2)];
		let w4 = (chunk[i].slice(18, 24) == "000000")?"=":__codeString[parseInt(chunk[i].slice(18, 24), 2)];
		let sub = w1+w2+w3+w4;
		BASE64 += sub;
	}
	return BASE64;
}

/**
 * Decodes Base64 encoded data to it original string.
 * *****NOTICE the inbuilt atob() can do this, this is just to understand what's going on under the hood******
 * @input {String} - The string to be decoded. This is passed to the function via the "this" keyword
 * @returns {String} The original decoded string form Base64
 */
String.prototype.fromBase64 = function(){
	var __codeString = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	let txt = [...this];
	
	/*Find the index of character inthe encoded data in our __codeString
	* Convert it to binary and padd it to 6 chcracters when necessary
	*/
	let decode = "";
	for(let i = 0; i < txt.length; i++){
		let tx = ((__codeString.indexOf(txt[i])>0)?__codeString.indexOf(txt[i]):0).toString(2);
		tx = "0".repeat(6-tx.length) + tx;
		decode += tx;
	}
	
	//Break the whole binary into chunks of 8 characters
	let chunk = [];
	for(let i = 8; i <= decode.length; i += 8) chunk.push(decode.slice(i-8, i));
	
	//Take each chunk of 8 characters and convert it to base10 and to the corresponding character of ASCII
	let realText = ""; 
	for(let i = 0; i < chunk.length; i++){
		if(parseInt(chunk[i],2) == 0) continue;
		realText += String.fromCharCode(parseInt(chunk[i],2));
	}
	return realText;
}