Java Plotter - By Facebamm

package daniel.textcodierer;

import android.content.Context;
import android.util.Log;

import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static daniel.textcodierer.R.string.HochPatter;
import static daniel.textcodierer.R.string.MalGeteiltPatter;
import static daniel.textcodierer.R.string.PlusMinusPatter;
import static java.lang.Float.parseFloat;
import static java.lang.Math.PI;

/**
 * Created by daniel on 16.07.2015.
 * Upadate by daniel on 22.07.2015.
 */
public class regex {
    String Aufgabe;
    String TAG = "REGEAUS";
    Context ctx;
    ArrayList<rechnungen> Rechnungen;

    public regex(Context ctx,String Aufgabe)

    {   this.ctx = ctx;
        Rechnungen = new ArrayList<>();
        this.Aufgabe = Aufgabe.toLowerCase().replaceAll(" ", "");
        Log.d(TAG,"Regex startup " + this.Aufgabe);
        Matcher m = Pattern.compile("((\\)|\\d+)\\()").matcher(Aufgabe);
        while(m.find())
        {
            String Ziffer = m.group(2);
            Log.d(TAG, String.valueOf("Ersetzt " + m.group(1) + "zu " + Ziffer + "*("));
            this.Aufgabe = this.Aufgabe.replace(m.group(1),String.valueOf(Ziffer + "*("));
        }
        Log.d(TAG,this.Aufgabe);
        Log.d(TAG,"MStart SinCosTan");
        new AllInOne();
        Log.d(TAG,this.Aufgabe);
    }
    public String get()
    {
        return Aufgabe;
    }


    private class AllInOne
    {
        ArrayList<Typo> o;
        public AllInOne()
        {
            delSin_Cos_Tan();
            new klammer();
            AllinOnePatter(Operat.Hoch);
            AllinOnePatter(Operat.MAl_GETEILT);
            AllinOnePatter(Operat.PLus_Minus);

        }
        public void AllinOnePatter(Operat Ops)
        {
            Log.d(TAG,String.valueOf("Start StartRegex()"));
            String aDate = Aufgabe;
            Pattern datePattern = Pattern.compile(Ops.Patter);
            Matcher matcher = datePattern.matcher(aDate);
            Rechnungen = new ArrayList<>();
            while (matcher.find()){
                double Zahl1, Zahl2;
                Zahl1 = StrgToDbl(matcher.group(2)); //3
                Zahl2 = StrgToDbl(matcher.group(4)); //5.5

                String TeilSatz,Zeichen;
                TeilSatz = matcher.group(1); //3*5.5
                Zeichen = matcher.group(3); //*

                int start =  matcher.start(1);
                int end  = matcher.end(1);

                rechnungen Item  = new rechnungen(Zahl1,Zahl2,Zeichen,TeilSatz,start,end);
                Rechnungen.add(Item);
            }
            auflosen(Ops);
        }

        private void auflosen(Operat Op)
        {
            for(rechnungen i: Rechnungen) {
                Log.d(TAG, String.valueOf("Start auflosen()"));
                Log.d(TAG, String.valueOf("Komplet " + i.Gesammt));
                Log.d(TAG, String.valueOf("Start at " + i.posi.x + " end at " + i.posi.xend));
                Log.d(TAG, String.valueOf("Number one " + i.Zahlen.get(0)));
                Log.d(TAG, String.valueOf("Number two " + i.Zahlen.get(1)));
                Log.d(TAG, String.valueOf("Operat " + i.Zeichen));
                String Ergebniss = String.valueOf(brechnung(i.Zeichen, i.Zahlen));
                Log.d(TAG, String.valueOf("Ergebnis " + Ergebniss));
                Aufgabe = Aufgabe.replace(i.Gesammt, Ergebniss);
                Log.d(TAG, Aufgabe);
                Log.d(TAG, String.valueOf("\n \n "));
                switch (Op)
                {
                    case Hoch: AllinOnePatter(Op);
                    case MAl_GETEILT: AllinOnePatter(Op);
                    case PLus_Minus: AllinOnePatter(Op);
                }
                return;
            }
        }

        public void delSin_Cos_Tan()
        {
            o = new ArrayList<>();
            String aDate = Aufgabe;
            Pattern pattern = Pattern.compile(Operat.Sin_Cos_Tan.Patter);
            Matcher matcher = pattern.matcher(aDate);
            Log.d(TAG,Operat.Sin_Cos_Tan.Patter);
            Log.d(TAG,"Sin Startz");
            Log.d(TAG,"Sin " + Aufgabe);
            while (matcher.find());
            {

                String Gesammt = null;
                String TYP = null;
                String Inklammer = null;
                Log.e(TAG, matcher.group(1));
                Gesammt = matcher.group(1);
                TYP = matcher.group(2);
                Inklammer = matcher.group(3);
                o.add(new Typo(Gesammt, TYP, Inklammer));

                Log.d(TAG, String.valueOf("----------------------------"));
                Log.d(TAG, Gesammt);
                Log.d(TAG, Inklammer);
                Log.d(TAG, TYP);
                Log.d(TAG, String.valueOf("----------------------------"));
            }
            findenSin();
        }

        public void findenSin()
        {
            for(Typo e : this.o)
            {
                Aufgabe = Aufgabe.replace(e.all,e.getErgebniss());
                Log.d(TAG,"Starte Sin_Cos_Tan von Sin_Cos_Tan");
                delSin_Cos_Tan();
                return;
            }
        }

        private class Typo {
            String all, Typ, Inklammer;
            String EndInKlammer;

            public Typo(String all, String Typ, String Inklammer) {
                this.all = all;
                this.Typ = Typ;
                this.Inklammer = Inklammer;
                Log.d(TAG, "Starte regex von Sin_Cos_Tan mit " + all);
                this.EndInKlammer = new regex(ctx, Inklammer).get();
            }

            public String getErgebniss() {
                return String.valueOf(parseFloat(String.valueOf(this.berechnen())));
            }

            private double berechnen() {
                switch (Typ) {
                    case "sin":
                        return Math.sin(StrgToDbl(EndInKlammer));
                    case "sinh":
                        return Math.sinh(StrgToDbl(EndInKlammer));
                    case "asin":
                        return Math.asin(StrgToDbl(EndInKlammer));
                    case "cos":
                        return Math.cos(StrgToDbl(EndInKlammer));
                    case "acos":
                        return Math.acos(StrgToDbl(EndInKlammer));
                    case "cosh":
                        return Math.cosh(StrgToDbl(EndInKlammer));
                    case "tan":
                        return Math.tan(StrgToDbl(EndInKlammer));
                    case "atan":
                        return Math.atan(StrgToDbl(EndInKlammer));
                    case "tanh":
                        return Math.tanh(StrgToDbl(EndInKlammer));
                }
                return 0d;
            }

        }
    }

    private enum Operat
    {
        Hoch("((\\d+\\.\\d+|\\d+|pi)(\\^)(\\d+\\.\\d+|\\d+|pi))"),
        Sin_Cos_Tan("((sin|cos|tan|sinh|cosh|tanh|asin|acos|atan)\\((.+)\\))"),
        MAl_GETEILT("((\\d+\\.\\d+|\\d+|pi)(\\*|\\/)(\\d+\\.\\d+|\\d+|pi))"),
        PLus_Minus("((\\d+\\.\\d+|\\d+|pi)(\\+|\\-)(\\d+\\.\\d+|\\d+|pi))");
        private String Patter;
        private Operat(String Patter)
        {
            this.Patter = Patter;
        }
    }

    private class klammer
    {

        ArrayList<Tx> List;
        public klammer()
        {
            List = new ArrayList<>();
            finds();
        }

        //region wayToW

        private void finds()
        {
            ArrayList<String> allo;
            boolean find = false;
            int start,end,acculut;
            start = -1;
            end = -1;
            acculut = -1;
            allo = new ArrayList<>();
            for(char i : Aufgabe.toCharArray())
            {
                String g = String.valueOf(i);
                switch (g) {
                    case "(":
                        allo = new ArrayList<>();
                        allo.add(g);
                        find = true;
                        end++;
                        start = end;
                        acculut++;
                        Log.d(TAG, String.valueOf("----------------------------"));
                        Log.d(TAG, "Gefunden (");
                        Log.d(TAG, String.valueOf("Start " + start));
                        Log.d(TAG, String.valueOf("Ende " + end));
                        Log.d(TAG, String.valueOf("Acculut " + acculut));
                        Log.d(TAG, String.valueOf("----------------------------"));

                        break;
                    case ")":
                        end++;
                        acculut--;
                        allo.add(g);
                        Log.d(TAG, String.valueOf("----------------------------"));
                        Log.d(TAG, "Gefunden )");
                        Log.d(TAG, String.valueOf("Ende " + end));
                        Log.d(TAG, String.valueOf("Acculut " + acculut));
                        Log.d(TAG, String.valueOf("----------------------------"));
                        if (acculut == -1) {
                            String a = "";
                            for (String h : allo) {
                                a = String.valueOf(a + h);
                            }
                            Pattern p = Pattern.compile("(\\((.+)\\))");
                            Matcher m = p.matcher(a);
                            while (m.find()) {
                                String gesammt = m.group(1);
                                String InKlammer = m.group(2);
                                Log.d(TAG, String.valueOf("----------------------------"));
                                Log.d(TAG, "Klammer gesammt" + gesammt);
                                Log.d(TAG, "Klammer inklammer" + InKlammer);
                                Log.d(TAG, String.valueOf("----------------------------"));
                                List.add(new Tx(gesammt, InKlammer));
                            }
                            this.find();
                        }
                        break;
                    default:
                        end++;
                        allo.add(g);
                        Log.d(TAG, String.valueOf("----------------------------"));
                        Log.d(TAG, "Gefunden " + g + "in default");
                        Log.d(TAG, String.valueOf("Ende " + end));
                        Log.d(TAG, String.valueOf("Acculut " + acculut));
                        Log.d(TAG, String.valueOf("----------------------------"));
                        break;

                }
            }
        }

        //endregion


        private void find()
        {
            for(Tx a : List)
            {
                Log.d(TAG,String.valueOf("----------------------------"));
                Log.d(TAG,"InKlammer_find " + a.All);
                Log.d(TAG,"InKlammer_find " + a.In);
                Log.d(TAG,"InKlammer_find " + a.Ergebniss);
                Log.d(TAG,String.valueOf("----------------------------"));
                Aufgabe=Aufgabe.replace(a.All,a.Ergebniss);
                new klammer();
                return;
            }
        }
        private class Tx
        {
            String All,In,Ergebniss;
            public Tx(String All,String InKlammer)
            {
                this.All = All;this.In = InKlammer;
                Log.d(TAG,"Starte regex von Klammer " + this.All);
                this.Ergebniss = new regex(ctx,InKlammer).get();
            }
        }
    }

    private Double brechnung(String Zeichen,ArrayList<Double> Zahlen)
    {
        switch (Zeichen)
        {
            case "+": return (Zahlen.get(0) + Zahlen.get(1));
            case "-": return (Zahlen.get(0) - Zahlen.get(1));
            case "/": return (Zahlen.get(0) / Zahlen.get(1));
            case "*": return (Zahlen.get(0) * Zahlen.get(1));
            case "^": return Math.pow(Zahlen.get(0), Zahlen.get(1));
        }
        return 0d;
    }

    private double StrgToDbl(String Input)
    {
        if(Input.equals("pi")){return PI;}
        double aDbl = Double.parseDouble(Input);
        return aDbl;
    }

    private class rechnungen
    {
        public String Gesammt;
        public ArrayList<Double> Zahlen;
        public String Zeichen;
        public position posi;

        public rechnungen(double ZahlOne,double ZahlTwo,String Zeichen, String Gesammt,int Start,int End)
        {
            Zahlen = new ArrayList<>();
            Zahlen.add(ZahlOne);
            Zahlen.add(ZahlTwo);
            this.Gesammt = Gesammt;
            this.Zeichen = Zeichen;
            posi = new position(Start,End);
        }

        public rechnungen(double ZahlOne,double ZahlTwo,String Zeichen, int Start)
        {
            Zahlen = new ArrayList<>();
            Zahlen.add(ZahlOne);
            Zahlen.add(ZahlTwo);

            this.Zeichen = Zeichen;
            posi = new position(Start);
        }

        private class position
        {
            public int x,xend;
            public position(int x, int xend)
            {
                this.x = x;
                this.xend = xend;
            }
            public position(int x)
            {
                this.x = x;
                this.xend = -1;
            }
        }
    }
}