import java.util.Scanner;
import java.text.DecimalFormat;
import java.util.Locale;
import java.util.InputMismatchException;

public class TaschenrechnerExtendet3 {

        public static void main(String[] args)
        {
                DecimalFormat df = new DecimalFormat("###,###,###.###"); // Fuer die Uebersichlichkeit sont zu lange Nachkommastellen
                Locale.setDefault(Locale.GERMAN); // Deutsche Tastatur anstatt . jetzt , moeglich

                String wert = null;
                char vorzeichen = 0;
                boolean while_schleife = true;
                double berechneter_wert = 0.0;
                double wert_double = 0.0;
                Scanner scanner, scanner2;

                eingabeHilfe();

                while(while_schleife) // Schleifenbedinung ist true außer wenn wir ein e eingeben dann wird der Boolean auf false gesetzt
                {
                        try
                        {
                                System.out.println("Ihr Wert ist  " + df.format(berechneter_wert)+" | e=ende c=clear |");
                                scanner = new Scanner(System.in); // Konsolen eingabe

                                wert = scanner.nextLine();
                                vorzeichen = wert.charAt(0); // char vorzeichen den 0ten Wert zuweisen. z.b + - * /

                                scanner2 = new Scanner(wert.substring(1)); // substring nach der Stelle 1 der rest in Typ Scanner verweisen

                                switch (vorzeichen)
                                {
                                        case 'e': // | "" fuer String |  '' für char | int, double andere werte ist zahl nötig
                                                while_schleife=false; // Schleife Beendigt !
                                        case 'c':
                                                berechneter_wert = 0.0;
                                                break; // break sonst Fehlermeldung wegen Methode vom Scanner !
                                        case '!':
                                                pruefung_Werte = ganzZahl(berechneter_wert);
                                                berechneter_wert = fakultaet_berechnung((int)berechneter_wert);
                                                break;
                                        case '^':
                                                wert_double = scanner2.nextDouble();
                                                berechneter_wert = potenz(berechneter_wert ,wert_double);
                                                break;
                                        case '+':
                                                wert_double = scanner2.nextDouble();
                                                berechneter_wert = berechneter_wert + wert_double;
                                                break;
                                        case '-':
                                                wert_double = scanner2.nextDouble();
                                                berechneter_wert = berechneter_wert - wert_double;
                                                break;
                                        case '*':
                                                wert_double = scanner2.nextDouble();
                                                berechneter_wert = berechneter_wert * wert_double;
                                                break;
                                        case '/':
                                                wert_double = scanner2.nextDouble();
                                                if(wert_double != 0.0) // Wenn nextDouble keine 0 vom Substring dann geht if sonst else -> Fehlermeldung
                                                {
                                                    berechneter_wert = berechneter_wert / wert_double;
                                                }
                                                else
                                                {
                                                    throw new DivisionByZeroException();
                                                }
                                                break;
                                        default: // Wenn nichts eingeben wird, dann wird eine Fehlermeldung geworfen mit Verweis auf die Klasse Invalid...
                                                throw new InvalidOperatorException();
                                }
                        }
                        catch(DivisionByZeroException e)  // Auffangen (engl. catch) sonst Fehlermeldung nicht möglich
                        {
                                System.out.println("Fehler --- "+ e +": Division durch 0 \n");
                        }
                        catch(InvalidOperatorException e)
                        {
                                System.out.println("Fehler --- "+ e +": Unbekannter Operator \n");
                        }
                        catch(InputMismatchException e)
                        {
                                 System.out.println("Fehler --- "+ e +": Falsches Eingeabeformat \n");
                        }
                        catch(NotNaturalNumberException e)
                        {
                                System.out.println("Fehler --- "+ e + ": Kein ganzzahliger Wert \n");
                        }
                        catch(Exception e)
                        {
                                System.out.println("Fehler --- unbekannter Fehler \n");
                        }
                }
        }
        static void eingabeHilfe() // EingabeHilfe -> nur 1 mal deshalb oben If Abfrage
        {
               System.out.println("Hallo beim Taschenrechner, die Operatoren + , - , * , ! = Fakultaet , ^ = Potenz / sind erlaubt. Parameter e für Beendigung \n");
        }

        static int ganzZahl(double berechneter_wert) throws NotNaturalNumberException // Methode ganzZahl bekommt ein double und gibt ein Int zurück
        {
            double pruefung = berechneter_wert / (int)berechneter_wert;

            if(pruefung < (1.0 + Math.pow(10.0,-15.0))) // Pruefung der Bedingung -> Double / int = 1,0
            {
                return (int)pruefung;
            }
            else
            {
                throw new NotNaturalNumberException();
            }
        }

        static  int fakultaet_berechnung(int berechneter_wert)
        {
            int fakultaet = 1; // wie bei der Fakultaet -  muss 1 sein ! Sonst nicht Matherror bro how blow
            boolean forschleife = false; // Abschluss der If Abfrage mit Integer.Max_Value -> sonst zu oft eingezeigt wenn mehr als overflow ist

            for(int i =1; i <= berechneter_wert && forschleife == false; i++) // Fakultaet Bedingung i <= eingabe; Bei 5 nur 5 durchläufe
            {
                try
                {
                    if((Integer.MAX_VALUE/i)<fakultaet) //Int Max Value = 2.147.483.647
                    {
                        forschleife = true;
                        throw new ResultErrorException(); // Wirft Overflow Exception
                    }
                    fakultaet = fakultaet * i;
                }
                catch (ResultErrorException e)
                {
                        System.out.println("Fehler --- "+ e +": Integer-Overflow \n");
                        fakultaet = berechneter_wert; // Wichtig damit wir den vorherigen Wert haben, sonst ist das der Overflow wert oder 1
                }
            }
            return fakultaet;
        }

        static double potenz(double a, double b) throws InvalidExponentException, NotNaturalNumberException
        {
            double potenz_rechnung = 0.0; // Initialisierung der Variable Potenz_Rechnung
            double pruefung = 0.0;
            pruefung = ganzZahl(b);

                if(pruefung == 1.0 && b > 0.0)
                {
                    potenz_rechnung = a;
                    for (double i = 1.0; i < b; i++)  // Schleife wird so lange ausgeführt bis i(Zähler) den Exponenten erreicht hat.
                    {
                        potenz_rechnung = potenz_rechnung * a;
                    }
                }
                else
                {
                    throw new InvalidExponentException();
                }
            return potenz_rechnung;
        }
}
class DivisionByZeroException extends Exception // Etliche Klassen ... für die Exceptions
{
        private static final long serialVersionUID = 1L;
}

class ResultErrorException extends Exception
{
        private static final long serialVersionUID = 1L;
}

class InvalidOperatorException extends Exception
{
        private static final long serialVersionUID = 1L;
}

class InvalidExponentException extends Exception
{
        private static final long serialVersionUID = 1L;
}

class NotNaturalNumberException extends Exception
{
        private static final long serialVersionUID = 1L;
}