package pr1.uebung08;

import static pr.MakeItSimple.*;

public class BigIntegerImplementation implements BigInteger {
	private int[] numbers;

	public BigIntegerImplementation() {

	}

	public BigIntegerImplementation(String zahl) {

		// Prüfung ob String nur aus numbers besteht
		for (int i = 0; i < zahl.length(); i++) {
			if (zahl.charAt(i) >= '0' && zahl.charAt(i) <= '9') {

			} else
				throw new PRException("Ungültiger String");

		}
		// zähle die führenden nullen und speichere die Anzahl in i
		int i = 0;

		while (zahl.charAt(i) == '0'/*&&i<zahl.length()-1*/)
			i++;
		int[] numbers = new int[zahl.length() - i];
		// Speichere die einzelnen Ziffern im String ins Integer Array
		for (int j = 0; j < numbers.length; j++) {
			numbers[j] = zahl.charAt(i) - '0';
			if (i < zahl.length() - 1)
				i++;

		}

		this.numbers = numbers;
	}

	public void setDigits(int[] numbers) {
		this.numbers = numbers;

	}

	@Override
	public BigInteger add(BigInteger number) {
		//TODO: Wenn param>numbers
		// Erstelle result für die Rückgabe
		BigInteger result;
		// Objekt das result zugewiesen wird
		BigIntegerImplementation tmpObj = new BigIntegerImplementation();

		// Speichere die numbers der Objekte in Arrays
		int[] params = number.getDigits();
		int[] numbers = this.numbers;

		int length1 = numbers.length - 1;
		int length2 = params.length - 1;

		int minLength;

		int[] array3 = new int[numbers.length];

		for (int i = 0; i < array3.length; i++) {

			array3[i] = numbers[i];
		}
		/*
		 * findet heraus welches der beiden Arrays kleiner ist damit bei der For
		 * schleife keine Exception ausgelöst wird
		 */
		if (length1 < length2)
			minLength = length1;
		else
			minLength = length2;

		/*
		 * arrays werden von höchsten Index zum kleinsten durchlaufen und addiert
		 */
		for (; minLength >= 0; minLength--) {

			array3[length1] = numbers[length1] + params[length2];
			length1--;
			length2--;

		}
		/*
		 * moreDigits wird angelegt falls die Summe über eine Stellenwertigkeit mehr
		 * verfügt (wenn beim ersten Index ein Übertrag stattfindet) ----- Falls im
		 * Index ein Übertrag stattfindet dann behalte den rest im Index und springe in
		 * einen Index tiefer und Inkrementiere
		 */
		boolean moreDigits = false;
		for (int i = array3.length - 1; i >= 0; i--) {
			if (array3[0] >= 10)
				moreDigits = true;
			if (array3[i] >= 10) {
				array3[i] = array3[i] % 10;
				if (i > 0)
					array3[--i] += 1;
				i++;

			}

		}
		/*
		 * größeres array wird angelegt da größere Zahl in den ersten Index =0 wird 1
		 * reingeschrieben, da zahl um eine Stellenwertigkeit wächst
		 */
		if (moreDigits) {
			int k = 1;
			int[] array4 = new int[(array3.length + 1)];
			array4[0] = 1;
			for (int i = 0; i < array3.length; i++) {
				array4[k] = array3[i];
				k++;

			}
			tmpObj.setDigits(array4);
		} else
			tmpObj.setDigits(array3);

		result = tmpObj;

		return result;
	}

	@Override
	public BigInteger times(BigInteger number) {
		// TODO:arr in obj speichern
		int[] param = number.getDigits();
		int[][] result;
		int[]endresult;
		int k = 0;
		int range;
		int range2;
		int nullen;
		int x = 0;

		if (!greaterThan(number)) {
			range = numbers.length;
			result = new int[range][param.length + numbers.length - 1];
			range = numbers.length;
			range2 = param.length;
		} else {
			range = param.length;
			result = new int[range][param.length + numbers.length - 1];
			range2 = numbers.length;
		}

		for (int i = 0; i < range; i++) {
			nullen = i;

			for (int j = 0; j < range2; j++) {
				// zähle die anzahl der nullen und rechne erst nach der letzen null
				if (nullen > 0) {
					nullen--;
				} else {
					// var k ist dazu da damit die rechnung immer erst nach der letzen null gemacht
					// wird indem k++ (wenn j++ dann overflow)
					k = j;
					// var x ist dazu da, das param den richtigen index bekommt da j auch
					// hochgezählt wird wenn nicht gerechnet wird
					// die anzahl der nullen i wird von j abgezogen
					x = j - i;

					// while schleife ist dazu da, dass jede zahl in param durchgegangen wird , da
					// die schleife sonst vorzeitig abbricht wegen nullzähler
					while (x < range2) {
						if (!greaterThan(number)) {
							result[i][k++] = numbers[i] * param[x];
						} else {
							result[i][k++] = numbers[x] * param[i];
						}
						x++;
					}
				}

			}

		}


		int v = result.length - 1;
		int overflow;
		for (int j = result[v].length - 1; j > 0; j--) {
			for (int i = result.length - 1; i > 0; i--) {
				result[0][j] += result[i][j];
				if (result[0][j] >= 10) {
					overflow = result[0][j] / 10;
					result[0][j] %= 10;
					result[0][--j] += overflow;
					j++;
				}

			}
		}

			if(result[0][0]>=10) {
			endresult= new int[param.length + numbers.length];
			endresult[0]=result[0][0]%10;
			endresult[1]=result[0][0]/10;
			int j=1;
			for(int i=2; i< endresult.length;i++) {
				endresult[i]= result[0][j];
				j++;
			}
		}else {
			endresult= new int[param.length + numbers.length - 1];
			for(int i=0; i<endresult.length;i++) {
				endresult[i]=result[0][i];
			}
		}



		for (int i = 0; i < endresult.length; i++) {
			print(endresult[i]);
		}

		return null;
	}

	@Override
	public int length() {
		int i;
		for (i = 0; i < numbers.length; i++)
			;
		return i;
	}

	@Override
	public int[] getDigits() {

		return numbers;
	}

	@Override
	public String toString() {
		String strNumbers = "";

		for (int i = 0; i < numbers.length; i++) {
			strNumbers += "" + numbers[i];

		}
		return strNumbers;
	}

	@Override
	public boolean equals(BigInteger number) {

		return false;
	}

	@Override
	public boolean greaterThan(BigInteger number) {
		int[] numbers = this.numbers;
		int[] param = number.getDigits();

		if (length() > number.length())
			return true;
		if (length() < number.length())
			return false;
		if (length() == number.length()) {
			for (int i = 0; i < numbers.length;) {
				if (numbers[i] > param[i])
					return true;
				else if (numbers[i] < param[i])
					return false;
				else
					i++;
			}
		}
		return false;
	}

}