package ru.compscicenter.java2019.calculator;

class Parser {
    public static void main(String[] args) {
        Parser pm = new Parser();
        //String f = "2^3*10E1";
        String f = "1+ 2";
        double ans = pm.Parse(f);
        System.out.format("%08f", ans);
    }

    public double Parse(String s) {
        s = DeleteSpases(s);
        Result result = PlusMinus(s);

        return result.acc;
    }

    private String DeleteSpases(String s) {
        String s2 = "";
        for(int i = 0; i < s.length(); i++) {
            if (s.charAt(i) != ' ') {
                s2 += s.charAt(i);
            }
        }

        return s2;
    }

    private Result PlusMinus(String s) {
        Result current = MulDiv(s);
        double acc = current.acc;

        while (current.rest.length() > 0) {
            if (!(current.rest.charAt(0) == '+' || current.rest.charAt(0) == '-'))
                break;

            char sign = current.rest.charAt(0);
            String next = current.rest.substring(1);

            acc = current.acc;

            current = MulDiv(next);
            if (sign == '+') {
                acc += current.acc;
            } else {
                acc -= current.acc;
            }
            current.acc = acc;
        }
        return new Result(current.acc, current.rest);
    }


    private Result MulDiv(String s) {
        Result current = Braket(s);

        double acc = current.acc;
        while (true) {
            if (current.rest.length() == 0) {
                return current;
            }

            char sign = current.rest.charAt(0);
            if ((sign != '*' && sign != '/'))
                return current;

            String next = current.rest.substring(1);
            Result right = Braket(next);

            if (sign == '*') {
                acc *= right.acc;
            } else {
                acc /= right.acc;
            }

            current = new Result(acc, right.rest);
        }
    }


    private Result Braket(String s) {

        char bra = s.charAt(0);
        if (bra == '(') {
            Result resInBrakets = PlusMinus(s.substring(1));

            if ((resInBrakets.rest.charAt(0) == ')') && (!resInBrakets.rest.isEmpty()) ) {
                resInBrakets.rest = resInBrakets.rest.substring(1);
            }
            return resInBrakets;
        }
        return Func(s);
    }


    private Result Func(String s) {
        String function = "";
        int i = 0;
        // searching for a function
        while ((i < s.length() && (Character.isLetter(s.charAt(i)) )) || ( Character.isDigit(s.charAt(i)) && i > 0 ) ) {
            if (s.charAt(i) == 'E') {
                break;
            }
            function += s.charAt(i);
            i++;
        }

        if (function.length() > 0) {
            if ( s.length() > i && s.charAt( i ) == '(') {
                Result r = Braket(s.substring(function.length()));
                if (function.equals("sin")) {
                    return new Result(Math.sin(Math.toRadians(r.acc)), r.rest);
                } else if (function.equals("cos")) {
                    return new Result(Math.cos(Math.toRadians(r.acc)), r.rest);
                } else if (function.equals("abs")) {
                    return new Result(Math.abs(Math.toRadians(r.acc)), r.rest);
                }
                //else if (function.equals("^")) {
                //    return new Result(Math.pow(NextNumber(s).acc, r.acc), r.rest);
                //}
            }
        }
        return NextNumber(s);
    }


    private Result NextNumber(String s) {

        double dPart = 0;
        boolean negative = false;

        if( s.charAt(0) == '-' ){
            negative = true;
            s = s.substring(1);
        }

        int i = 0;
        while (i < s.length() && (Character.isDigit(s.charAt(i)) || s.charAt(i) == '.')) {
            i++;
        }
        dPart = Double.parseDouble(s.substring(0, i));

        double dPow = 0;
        if (i < s.length() && s.charAt(i) == '^') {
            int j = i+1;
            while (j < s.length() && (Character.isDigit(s.charAt(j)) || s.charAt(j) == '.')) {
                j++;
            }
            if (j == i+1) {
                if (s.charAt(j) == '('){
                    Result Pow = Braket(s.substring(j));
                    dPart = Math.pow(dPart, Pow.acc);
                    if( negative ) dPart = -dPart;

                    int len = Pow.rest.length();
                    String restPart = s.substring(s.length()-len);
                    return new Result(dPart, restPart);
                }
            }
            dPow = Double.parseDouble(s.substring(i+1, j));
            dPart = Math.pow(dPart, dPow);

            if( negative ) dPart = -dPart;
            String restPart = s.substring(j);
            return new Result(dPart, restPart);
        }

        boolean neg_pow = false;
        if (i < s.length() && s.charAt(i) == 'E') {
            int j = i+1;
            if (j < s.length() && s.charAt(j) == '-') {
                neg_pow = true;
            }
            j++;
            while (j < s.length() && (Character.isDigit(s.charAt(j)) || s.charAt(j) == '.')) {
                j++;
            }
            if (neg_pow) {
                dPow = Double.parseDouble(s.substring(i+2, j));
                dPart = dPart * Math.pow(10, -dPow);
                if( negative ) dPart = -dPart;
                String restPart = s.substring(j);
                return new Result(dPart, restPart);
            }
            else {
                dPow = Double.parseDouble(s.substring(i+1, j));
                dPart = dPart * Math.pow(10, dPow);
                if( negative ) dPart = -dPart;
                String restPart = s.substring(j);
                return new Result(dPart, restPart);
            }
        }



        if( negative ) dPart = -dPart;

        String restPart = s.substring(i);
        Result res = new Result(dPart, restPart);
        return res;
    }
}