import java.util.Arrays;

public class Parallelverordnung implements Runnable {
	
	private int[] numbers;

	public Parallelverordnung(int[] numbers) {
		this.numbers = numbers;
	}

	@Override
	public void run() {
		// Diese Methode wird für jeden Thread separat ausgeführt (-> Objektmethode):
		// Erstes Element bereits korrekt, alle anderen jetzt permutieren.
		// Vorschlag: Iteriere über alle (weiteren) Elemente und vertausche jedes
		// Element an den aktuellen Index -> Rekursion
		permutation(1); // starte mit dem am Index 1; dieser permutiert dann rekursiv alle danach
	}
	
	private void permutation(int currentIndex) {
		if (currentIndex == numbers.length-1) {  // Abbruchbedingung: Alle fertig permutiert
			System.out.println(Arrays.toString(numbers)); // Ausgabe
		} else {  // gibt noch was zu tun
			for (int j = currentIndex; j < numbers.length; j++) {
				swap(numbers, currentIndex,  j);
				permutation(currentIndex+1);  // jetzt alle Permutationen nach aktuellem Index durchspielen
				swap(numbers, currentIndex,  j);  // zurücksetzen (für nächsten Schleifendurchlauf)
			}
		}
	}
	
	private static void swap(int[] numbers, int i, int j) {
		int tmp = numbers[i];
		numbers[i] = numbers[j];
		numbers[j] = tmp;
	}

	public static void main(String[] args) {
		int[] numbers = readArray();
		
		// Erzeuge so viele Threads wie numbers lang ist, wobei jeder Thread
		// eine Kopie des Arrays übergeben bekommt, das Startelement aber 
		// jeweils unterschiedlich ist.
		Thread[] threads = new Thread[numbers.length];
		
		for (int i = 0; i < numbers.length; i++) {
			// TODO: Thread erzeugen (mit neuem Array; erstes Element jeweils
			//       richtig setzen. Erzeugten Thread direkt starten.
			int[] numbersCopy = new int[numbers.length];
			System.arraycopy(numbers, 0, numbersCopy, 0, numbers.length);
			swap(numbersCopy, 0, i);
			threads[i] = new Thread(new Parallelverordnung(numbersCopy));
			threads[i].start();
		}
		
		// Auf Beendingung aller Threads warten:
		for (Thread t : threads) {  // t ist erst threads[0], dann threads[1], ...
			boolean running = true;
			while (running) {
				try {
					t.join();
					running = false;  // alternativ: break (um while-Schleife bei Erfolg zu verlassen)
				} catch (InterruptedException e) {}
			}
		}
//		for (int i = 0; i < threads.length; i++) {
//			Thread t = threads[i];
//			// ab jetzt wie bei for-each
//		}
	}

	public static int[] readArray() {
		return new int[] { 1, 2, 3, 4 };
	}
}