package blatt06;

public class Toolbox {

    public static void main(String[] args) {
        toolboxTest();
    }
    
    private static void toolboxTest() {
        /**
         * Wichtige Hinweise:
         * Bitte versuche nicht, das nachfolgende Programm zu verstehen!
         * Es soll dir lediglich beim Testen helfen und dich nicht weiterbilden!
         * Da es sich hierbei um ein Testprogramm handelt, wurden Duplikate
         * bewusst nicht vermieden! Orientiere dich also für künftige Aufgaben
         * nicht an dieser Methode! Für Tests nutzt man in der Regel
         * JUnit-Tests, wobei hier der Einfachheit wegen alles in einer Methode
         * geschrieben wurde, die in der main-Methode aufgerufen werden soll
         * (um es euch nicht unnötig kompliziert zu machen).
         */
                
        System.out.print("Welche Methode soll getestet werden (bitte hier "
                + "eingeben und Enter drücken):\n"
                + "0 = evenSum()\n"
                + "1 = multiplication()\n"
                + "2 = reverse()\n"
                + "3 = numberOfOddIntegers()\n"
                + "4 = filterOdd\n"
                + "5 = Alle in dieser Reihenfolge.\n"
                + "Deine Wahl: ");
        
        java.util.Scanner s = new java.util.Scanner(System.in);
        int input = s.nextInt();
        
        System.out.println("\nTest:");
        
        boolean all = input == 5;
        if (all) input = 0;
        boolean works;
        java.util.Random R = new java.util.Random();
        
        switch (input) {
            case 0:        
                // evenSum:
                works = true;
                int[][] testCases = { {0, 0}, {1, 0}, {2, 2}, {3, 2}, {4, 6}, {5, 6},
                                      {6, 12}, {7, 12}, {10, 30}, {14, 56}, {17, 72},
                                      {29, 210}, {4289, 4598880}, {10000, 25005000}};
                for (int i = 0; i < testCases.length; i++) {
                    for (int vz = 1; vz >= -1; vz -= 2) {
                        int result = evenSum(vz*testCases[i][0]);
                        if (result != vz*testCases[i][1]) {
                            System.out.println("Fehler: evenSum(" + vz*testCases[i][0] + ")"
                                + " hat zu " + result + " evaluiert,"
                                + " während " + vz*testCases[i][1] + " richtig wäre.");
                            works = false;
                            break;
                        }
                    }
                    if (!works) break;
                }
                if (works) System.out.println("Erfolgreich: evenSum()");
                if (!all) break;
            case 1:
                // multiplication:
                works = true;
                for (int i = 0; i < 10000; i++) {
                    int a = R.nextInt(20)-10;
                    int b = R.nextInt(20)-10;
                    if (multiplication(a, b) != (a*b)) {
                        System.out.println("Fehler: multiplication(" + a + ", " + b + ")"
                            + " hat zu " + multiplication(a, b) + " ausgewertet,"
                            + " während " + (a*b) + " richtig wäre.");
                        works = false;
                        break;
                    }
                }
                if (works) System.out.println("Erfolgreich: multiplication()");
                if (!all) break;
            case 2:
                // reverse:
                works = true;
                for (int i = 0; i < 1000; i++) {
                    int[] array = new int[R.nextInt(10)];
                    for (int j = 0 ; j < array.length; j++)
                        array[j] = R.nextInt(20);
                    // Kopie erstellen, um Originalarray ggf. auszugeben:
                    int[] dupl = java.util.Arrays.copyOf(array, array.length);
                    int[] reversed = new int[array.length]; // das korrekte Ergebnis
                    for (int j = 0; j < array.length; j++)
                        reversed[j] = array[array.length-j-1];
                    reverse(array); // Fktaufruf
                    if (!java.util.Arrays.equals(array, reversed)) {
                        System.out.println("Fehler: reverse(" + java.util.Arrays.toString(dupl)
                            + ") hat das Array zu " + java.util.Arrays.toString(array) 
                            + " verändert, während " + java.util.Arrays.toString(reversed)
                            + " richtig wäre.");
                        works = false;
                        break;
                    }
                }
                if (works) System.out.println("Erfolgreich: reverse()");
                if (!all) break;
            case 3:
                // numberOfOddIntegers:
                works = true;
                for (int i = 0; i < 1000; i++) {
                    int[] array = new int[R.nextInt(20)];
                    int countOdd = 0;
                    for (int j = 0 ; j < array.length; j++) {
                        array[j] = R.nextInt(100);
                        if (array[j] % 2 != 0) countOdd++;
                    }
                    int countedOdd = numberOfOddIntegers(array);
                    if (countOdd != countedOdd) {
                        System.out.println("Fehler: numberOfOddIntegers("
                            + java.util.Arrays.toString(array) + ") hat " + countedOdd
                            + " ungerade Zahlen gezählt, während " + countOdd 
                            + " richtig wäre.");
                        works = false;
                        break;
                    }
                }
                if (works) System.out.println("Erfolgreich: numberOfOddIntegers()");
                if (!all) break;
            case 4:
                // filterOdd:
                works = true;
                for (int i = 0; i < 1000; i++) {
                    int[] array = new int[R.nextInt(20)];
                    int countOdd = 0;
                    for (int j = 0 ; j < array.length; j++) {
                        array[j] = R.nextInt(100);
                        if (array[j] % 2 != 0) countOdd++;
                    }
                    // Kopie erstellen, falls fehlerhafterweise Original verändert:
                    int[] arrayDupl = java.util.Arrays.copyOf(array, array.length);
                    int[] arrayOddSol = new int[countOdd];
                    int c = 0;
                    for (int j = 0 ; j < array.length; j++) {
                        if (array[j] % 2 != 0)
                            arrayOddSol[c++] = array[j];
                    }
                    int[] arrayOddResult = filterOdd(array);
                    if (!java.util.Arrays.equals(arrayDupl, array)) {
                        System.out.println("Fehler: filterOdd führt eine Änderung am "
                                + "übergebenen Array durch, was laut Aufgabenstellung "
                                + "verboten ist!");
                        works = false;
                        break;
                    } else if (!java.util.Arrays.equals(arrayOddResult, arrayOddSol)) {
                        System.out.println("Fehler: filterOdd(" + java.util.Arrays.toString(array)
                            + ") hat " + java.util.Arrays.toString(arrayOddResult)
                            + " zurückgegeben, während " + java.util.Arrays.toString(arrayOddSol)
                            + " richtig wäre.");
                        works = false;
                        break;
                    }
                }
                if (works) System.out.println("Erfolgreich: filterOdd()");
                break;
            default:
                System.out.println("Die Eingabe " + input + " ist ungültig.");
        }
        System.out.println();
    }
    
    
    public static int evenSum(int n) {
        if (n <= -2) { 
            if (!isEven(n))
                n += 1;
            return n + evenSum(n+2);
        } else if (n >= 2) {
            if (!isEven(n))
                n -= 1;
            return n + evenSum(n-2);
        } else // bei -1, 0, 1
            return 0;
    }
    private static boolean isEven(int n) {
        if (n == 1 || n == -1)
            return false;
        else if (n == 0)
            return true;
        else if (n > 0)
            return isEven(n-2);
        else
            return isEven(n+2);
    }
    

    public static int multiplication(int x, int y) {
        if (y == 0 || x == 0)
            return 0;
        
        // Die folgende Fallunterscheidung kann man sich sparen, beschleunigt
        // die Berechnung jedoch (Bsp.: 1*5 = 5+0 statt 1+1+1+1+1+0)
        if (y < x) {
            if (y > 0)
                return x + multiplication(x, y-1);
            else
                return -x + multiplication(x, y+1);
        } else {
            if (x > 0)
                return y + multiplication(x-1, y);
            else
                return -y + multiplication(x+1, y);
        }
    }

    public static void reverse(int[] m) {
        reverse(m, 0);
    }
    private static void reverse(int[] m, int pos) {
        // n bezeichnet die aktuell zu vertauschende Position, wobei am Index
        // 0 begonnen wird und bis zur Mitte rekursiv vertauscht wird
        if (pos >= m.length/2) // Mitte erreicht
            return;
        
        int tmp = m[pos];
        m[pos] = m[m.length-pos-1];
        m[m.length-pos-1] = tmp;
        reverse(m, pos+1);
    }

    public static int numberOfOddIntegers(int[] m) {
        return numberOfOddIntegers(m, 0);
    }
    private static int numberOfOddIntegers(int[] m, int fromPos) {
        if (fromPos >= m.length) // ungültiger Parameter bzw. Rekursionsanker
            return 0;
        
        int isOdd = 0;
        if (!isEven(m[fromPos]))
            isOdd = 1;
        return isOdd + numberOfOddIntegers(m, fromPos+1);
    }

    public static int[] filterOdd(int[] m) {
        return filterOdd(m, 0);
    }
    private static int[] filterOdd(int[] m, int pos) {
        if (pos >= m.length) // -> Rekursionsanker
            return new int[]{};
        
        if (isEven(m[pos])) {
            return filterOdd(m, pos+1);
        } else {
            int[] almost = filterOdd(m, pos+1);
            int[] ret = new int[almost.length+1];
            arrayClone(almost, ret, 0, 1);
            ret[0] = m[pos];
            return ret;
        }
    }
    private static void arrayClone(int[] from, int[] to, int fromStart, int toStart) {
        if (fromStart >= from.length || toStart >= to.length)
            return;
        to[toStart] = from[fromStart];
        arrayClone(from, to, fromStart+1, toStart+1);
    }
}