public class PasswordTestSelf {
    
    public static void main(String[] args) {
        System.out.println("Hinweise:\n"
                + "- Es wird nicht überprüft, ob die Membervariablen final sind!\n"
                + "- Es wird nicht überprüft, ob unerlaubte Methoden benutzt "
                + "werden (vgl. Anhang Aufgabenstellung).\n"
                + "- Sonderzeichen sind alle \"anderen\" Zeichen, d. h. alle "
                + "Zeichen außer A-Z, a-z und 0-9 (wird nicht überprüft!).\n");
        testExceptionsSyntax();
        System.out.println();
        passwordTest();
    }
    
    public static void testExceptionsSyntax() {
        System.out.println("Exception-Check (Syntax und toString aller Exception-Klassen):");
        
        System.out.print("- NotEnoughUpper... ");
        try {
            try {
                throw new NotEnoughUpper(15, 1);
            } catch (NotEnoughUpper ex) {
                if (!ex.toString().contains("15"))
                    System.out.println("fehlgeschlagen, denn die toString()-"
                            + "Methode muss auf die Anzahl der benötigen "
                            + "Großbuchstaben hinweisen.");
                else
                    System.out.println("erfolgreich.");

                System.out.print("  Prüfe Vererbungshierarchie... ");
                if (! (ex instanceof NotEnoughLetter))
                    System.out.println("FEHLER: Erbt nicht von NotEnoughLetter!");
                else if (! (ex instanceof NotEnoughExc))
                    System.out.println("FEHLER: Erbt nicht von NotEnoughExc!");
                else
                    System.out.println("erfolgreich.");
            }
        } catch (RuntimeException e) {
            System.out.println("fehlgeschlagen (" 
                    + e.getClass().getSimpleName() + ": " 
                    + e.toString() + ")!");
        }
        
        System.out.print("- NotEnoughLower... ");
        try {
            try {
                throw new NotEnoughLower(77, 1);
            } catch (NotEnoughLower ex) {
                if (!ex.toString().contains("77"))
                    System.out.println("fehlgeschlagen, denn die toString()-"
                            + "Methode muss auf die Anzahl der benötigen "
                            + "Kleinbuchstaben hinweisen.");
                else
                    System.out.println("erfolgreich.");

                System.out.print("  Prüfe Vererbungshierarchie... ");
                if (! (ex instanceof NotEnoughLetter))
                    System.out.println("FEHLER: Erbt nicht von NotEnoughLetter!");
                else if (! (ex instanceof NotEnoughExc))
                    System.out.println("FEHLER: Erbt nicht von NotEnoughExc!");
                else
                    System.out.println("erfolgreich.");
            }
        } catch (RuntimeException e) {
            System.out.println("fehlgeschlagen (" 
                    + e.getClass().getSimpleName() + ": " 
                    + e.toString() + ")!");
        }
        
        System.out.print("- NotEnoughNumber... ");
        try {
            try {
                throw new NotEnoughNumber(123, 1);
            } catch (NotEnoughNumber ex) {
                if (!ex.toString().contains("123"))
                    System.out.println("fehlgeschlagen, denn die toString()-"
                            + "Methode muss auf die Anzahl der benötigen "
                            + "Ziffern hinweisen.");
                else
                    System.out.println("erfolgreich.");

                System.out.print("  Prüfe Vererbungshierarchie... ");
                if (! (ex instanceof NotEnoughExc))
                    System.out.println("FEHLER: Erbt nicht von NotEnoughExc!");
                else
                    System.out.println("erfolgreich.");
            }
        } catch (RuntimeException e) {
            System.out.println("fehlgeschlagen (" 
                    + e.getClass().getSimpleName() + ": " 
                    + e.toString() + ")!");
        }
        
        System.out.print("- NotEnoughSpecial... ");
        try {
            try {
                throw new NotEnoughSpecial(12, 1);
            } catch (NotEnoughSpecial ex) {
                if (!ex.toString().contains("12"))
                    System.out.println("fehlgeschlagen, denn die toString()-"
                            + "Methode muss auf die Anzahl der benötigen "
                            + "Sonderzeichen hinweisen.");
                else
                    System.out.println("erfolgreich.");

                System.out.print("  Prüfe Vererbungshierarchie... ");
                if (! (ex instanceof NotEnoughExc))
                    System.out.println("FEHLER: Erbt nicht von NotEnoughExc!");
                else
                    System.out.println("erfolgreich.");
            }
        } catch (RuntimeException e) {
            System.out.println("fehlgeschlagen (" 
                    + e.getClass().getSimpleName() + ": " 
                    + e.toString() + ")!");
        }
        
        System.out.print("- NotLongEnoughExc... ");
        try {
            try {
                throw new NotLongEnoughExc(229, 1);
            } catch (NotLongEnoughExc ex) {
                if (!ex.toString().contains("229"))
                    System.out.println("fehlgeschlagen, denn die toString()-"
                            + "Methode muss auf die Anzahl der benötigen "
                            + "Zeichen hinweisen.");
                else
                    System.out.println("erfolgreich.");

                System.out.print("  Prüfe Vererbungshierarchie... ");
                if (! (ex instanceof Exception))
                    System.out.println("FEHLER: Erbt nicht von Exception!");
                else
                    System.out.println("erfolgreich.");
            }
        } catch (RuntimeException e) {
            System.out.println("fehlgeschlagen (" 
                    + e.getClass().getSimpleName() + ": " 
                    + e.toString() + ")!");
        }
        
        System.out.print("- NotEnoughLetter... ");
        try {
            try {
                throw new NotEnoughLetter(289, 1);
            } catch (NotEnoughLetter ex) {
                System.out.println("erfolgreich.");

                System.out.print("  Prüfe Vererbungshierarchie... ");
                if (! (ex instanceof Exception))
                    System.out.println("FEHLER: Erbt nicht von Exception!");
                else
                    System.out.println("erfolgreich.");
            }
        } catch (RuntimeException e) {
            System.out.println("fehlgeschlagen (" 
                    + e.getClass().getSimpleName() + ": " 
                    + e.toString() + ")!");
        }
        
        System.out.print("- IllegalCharExc... ");
        try {
            try {
                throw new IllegalCharExc('%');
            } catch (IllegalCharExc ex) {
                if (ex.toString().indexOf('%') < 0)
                    System.out.println("fehlgeschlagen, denn die toString()-"
                            + "Methode gibt keinen Hinweis auf das verbotene "
                            + "Zeichen (used).");
                else
                    System.out.println("erfolgreich.");

                System.out.print("  Prüfe Vererbungshierarchie... ");
                if (! (ex instanceof Exception))
                    System.out.println("FEHLER: Erbt nicht von Exception!");
                else
                    System.out.println("erfolgreich.");
            }
        } catch (Exception e) {
            System.out.println("fehlgeschlagen (" 
                    + e.getClass().getSimpleName() + ": " 
                    + e.toString() + ")!");
        }
    }
    
    public static void passwordTest() {
        System.out.println("Passwort-Test (Klasse Password):");
        
        System.out.print("- Konstruktor... ");
        try {
            new Password(1, 2, 3, 4, 5, new char[]{});
            System.out.println("erfolgreich.");
        } catch (Exception e) {
            System.out.println("fehlgeschlagen (" 
                        + e.getClass().getSimpleName() + ": " 
                        + e.toString() + ")!");
        }
        
        
        int reqUpper = -1, reqLower = -1, reqSpecial = -1, reqNumbers = -1, reqLength = -1;
        int isUpper = -1, isLower = -1, isSpecial = -1, isNumbers = -1;
        char[] forbidden = {};
        String pass = "";
        java.util.Random gen = new java.util.Random();
        
        System.out.print("- NotLongEnoughExc... ");
        try {
            forbidden = new char[]{};
            for (int i = 0; i < 10000; i++) {
                reqUpper = gen.nextInt(3);
                reqLower = gen.nextInt(3);
                reqSpecial = gen.nextInt(3);
                reqNumbers = gen.nextInt(3);
                isUpper = reqUpper+gen.nextInt(2);
                isLower = reqLower+gen.nextInt(2);
                isSpecial = reqSpecial+gen.nextInt(2);
                isNumbers = reqNumbers+gen.nextInt(2);
                reqLength = isUpper+isLower+isSpecial+isNumbers+gen.nextInt(2)+1;

                Password pw = new Password(reqUpper, reqLower, reqSpecial,
                                           reqNumbers, reqLength, forbidden);

                try {
                    pass = genAllowedPass(isUpper, isLower, isSpecial, isNumbers);
                    pw.checkFormat(pass);
                } catch (NotLongEnoughExc e) {
                    continue;
                }
                System.out.println("fehlgeschlagen: Fälschlicherweise keine"
                    + " NotLongEnoughExc bei Passwort " + pass
                    + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                    + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                    + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                    + " {" + java.util.Arrays.toString(forbidden) + "})!");
            }
            System.out.println("erfolgreich.");
        } catch (Exception e) {
            System.out.println("fehlgeschlagen: " 
                    + e.getClass().getSimpleName() + " (" 
                    + e.toString() + ") bei Passwort " + pass
                    + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                    + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                    + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                    + " {" + java.util.Arrays.toString(forbidden) + "})!");
        }
        
        System.out.print("- NotEnoughExc... ");
        try {
            forbidden = new char[]{};
            for (int i = 0; i < 10000; i++) {
                reqUpper = gen.nextInt(3);
                reqLower = gen.nextInt(3);
                reqSpecial = gen.nextInt(3);
                reqNumbers = gen.nextInt(3);
                isUpper = java.lang.Math.max(reqUpper-gen.nextInt(3)+1, 0);  // -1, 0 oder +1
                isLower = java.lang.Math.max(reqLower-gen.nextInt(3)+1, 0);
                isSpecial = java.lang.Math.max(reqSpecial-gen.nextInt(3)+1, 0);
                isNumbers = java.lang.Math.max(reqNumbers-gen.nextInt(3)+1, 0);
                reqLength = isUpper+isLower+isSpecial+isNumbers;

                Password pw = new Password(reqUpper, reqLower, reqSpecial,
                                           reqNumbers, reqLength, forbidden);

                try {
                    pass = genAllowedPass(isUpper, isLower, isSpecial, isNumbers);
                    pw.checkFormat(pass);
                } catch (NotEnoughExc e) {
                    if (e instanceof NotEnoughLower) {
                        if (isLower >= reqLower) {
                            System.out.println("fehlgeschlagen: Fälschlicherweise"
                                + " NotEnoughLower bei Passwort '" + pass + "'"
                                + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                                + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                                + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                                + " {" + java.util.Arrays.toString(forbidden) + "})!");
                            break;
                        }
                    } 
                    else if (e instanceof NotEnoughUpper) { 
                        if (isUpper >= reqUpper) {
                            System.out.println("fehlgeschlagen: Fälschlicherweise"
                                + " NotEnoughUpper bei Passwort '" + pass + "'"
                                + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                                + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                                + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                                + " {" + java.util.Arrays.toString(forbidden) + "})!");
                            break;
                        }
                    }                   
                    else if (e instanceof NotEnoughSpecial) {
                        if (isSpecial >= reqSpecial) {
                            System.out.println("fehlgeschlagen: Fälschlicherweise"
                                + " NotEnoughSpecial bei Passwort '" + pass + "'"
                                + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                                + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                                + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                                + " {" + java.util.Arrays.toString(forbidden) + "})!");
                            break;
                        }
                    }             
                    else if (e instanceof NotEnoughNumber) { 
                        if (isNumbers >= reqNumbers) {
                            System.out.println("fehlgeschlagen: Fälschlicherweise"
                                + " NotEnoughNumber bei Passwort '" + pass + "'"
                                + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                                + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                                + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                                + " {" + java.util.Arrays.toString(forbidden) + "})!");
                            break;
                        }
                    } else {
                        System.out.println("fehlgeschlagen: " 
                            + e.getClass().getSimpleName() + " (" 
                            + e.toString() + ") sollte niemals auftreten;"
                            + " aufgetreten bei Passwort '" + pass + "'"
                            + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                            + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                            + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                            + " {" + java.util.Arrays.toString(forbidden) + "})!");
                    }
                }
            }
            System.out.println("erfolgreich.");
        } catch (Exception e) {
            System.out.println("fehlgeschlagen: " 
                    + e.getClass().getSimpleName() + " (" 
                    + e.toString() + ") bei Passwort '" + pass + "'"
                    + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                    + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                    + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                    + " {" + java.util.Arrays.toString(forbidden) + "})!");
        }
        
        System.out.print("- IllegalCharExc... ");
        try {
            for (int i = 0; i < 10000; i++) {
                int amountForbidden = gen.nextInt(10)+1;
                forbidden = new char[amountForbidden];
                for (int j = 0; j < amountForbidden; j++) {
                    char newVal = (char) (gen.nextInt(126)+1); // 1 - 126
                    if (java.nio.CharBuffer.wrap(forbidden).chars().
                          mapToObj(ch -> (char)ch).anyMatch(x -> x == newVal)) {
                        // -> already enthalten
                        j--;
                    } else {
                        forbidden[j] = newVal;
                    }
                }
                reqUpper = gen.nextInt(3);
                reqLower = gen.nextInt(3);
                reqSpecial = gen.nextInt(3);
                reqNumbers = gen.nextInt(3);
                isUpper = reqUpper+gen.nextInt(3);
                isLower = reqLower+gen.nextInt(3);
                isSpecial = reqSpecial+gen.nextInt(3);
                isNumbers = reqNumbers+gen.nextInt(3);
                reqLength = isUpper+isLower+isSpecial+isNumbers-gen.nextInt(2);
                
                Password pw = new Password(reqUpper, reqLower, reqSpecial,
                                           reqNumbers, reqLength, forbidden);

                try {
                    pass = genAllowedPass(isUpper, isLower, isSpecial, isNumbers);
                    pw.checkFormat(pass);
                } catch (IllegalCharExc e) {
                    boolean gerechtfertigt = false;
                    for (int j = 0; j < amountForbidden; j++)
                        if (pass.indexOf(forbidden[j]) >= 0)
                            gerechtfertigt = true;
                    if (!gerechtfertigt) {
                        System.out.println("fehlgeschlagen: IllegalCharExc bei"
                                + " Passwort '" + pass + "', obwohl gar kein"
                                + " verbotenes Zeichen enthalten ist"
                                + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                                + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                                + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                                + " {" + java.util.Arrays.toString(forbidden) + "})!");
                        System.out.println("Hinweis: Sonderzeichen sind alle Zeichen"
                                + " außer A-Z, a-z und 0-9. Zeichen siehe ASCII-Tabelle.");
                        break;
                    } else {
                        continue;
                    }
                }
                
                for (int j = 0; j < amountForbidden; j++) {
                    if (pass.indexOf(forbidden[j]) > 0) {
                        // Passwort enthält verbotenes zeichen
                        System.out.println("fehlgeschlagen: Passwort '" + pass 
                            + "' enthält verbotenes Zeichen '" + forbidden[j] 
                            + "', wurde aber keine IllegalCharExc geworfen."
                            + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                            + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                            + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                            + " {" + java.util.Arrays.toString(forbidden) + "})!");
                    }
                }
            }
            System.out.println("erfolgreich.");
        } catch (Exception e) {
            System.out.println("fehlgeschlagen: " 
                    + e.getClass().getSimpleName() + " (" 
                    + e.toString() + ") bei Passwort '" + pass + "'"
                    + " (benötigt: " + reqUpper + " Großbuchstaben, " + reqLower 
                    + " Kleinbuchstaben, " + reqNumbers + " Ziffern, " + reqSpecial
                    + " Sonderzeichen, Mindestlänge: " + reqLength + ", Verboten:"
                    + " {" + java.util.Arrays.toString(forbidden) + "})!");
        }
    }
        
    private static String genAllowedPass(int isUpper, int isLower,
                                         int isSpecial, int isNumbers) {
        java.util.Random gen = new java.util.Random();
        java.util.List<Integer> use;
        String ret = "";
        int reqLength = isUpper+isLower+isSpecial+isNumbers;
        while (ret.length() < reqLength) {
            use = new java.util.ArrayList<>();
            if (isUpper > 0)
                use.add(0);
            if (isLower > 0)
                use.add(1);
            if (isNumbers > 0)
                use.add(2);
            if (isSpecial > 0) {
                use.add(3);
            }
            
            int rand = gen.nextInt(use.size());
            switch (use.get(rand)) {
                case 0:
                    ret += (char) ('A' + gen.nextInt(26));
                    isUpper--; break;
                case 1:
                    ret += (char) ('a' + gen.nextInt(26));
                    isLower--; break;
                case 2:
                    ret += (char) ('0' + gen.nextInt(10));
                    isNumbers--; break;
                case 3:
                    java.util.List<Character> special = 
                            new java.util.ArrayList<>();
                    for (char c = '!'; c <= '/'; c++)
                        special.add(c);
                    for (char c = ':'; c <= '@'; c++)
                        special.add(c);
                    for (char c = '['; c <= '`'; c++)
                        special.add(c);
                    for (char c = '{'; c <= '~'; c++)
                        special.add(c);
                    ret += (char) special.get(gen.nextInt(special.size()));
                    isSpecial--; break;
                default:
                    System.out.println("Darf nicht eintreten. Testklasse falsch.");
            }
        }
        
        return ret;
    }
}