package ru.compscicenter.java2019.calculator;

import javax.swing.*;

import static java.lang.Math.pow;

public class Calculator {

    public double count(String expression) {
        expression = expression.toUpperCase();
        StringBuilder noSpacesExpression = new StringBuilder();
        for (int i = 0; i < expression.length(); ++i) {
            if (expression.charAt(i) != ' ') {
                noSpacesExpression.append(expression.charAt(i));
            }
        }
        expression = noSpacesExpression.toString();
        return minusPlus(expression).answer;
    }

    private Result minusPlus(String expression) {
        Result current = mulDivDeg(expression);
        while (current.lost.length() > 0) {
            char sign = current.lost.charAt(0);
            if (!(sign == '+' || sign == '-')) {
                break;
            }
            String nextExpression = current.lost.substring(1);
            Result step = mulDivDeg(nextExpression);
            if (sign == '+') {
                current.answer += step.answer;
            } else {
                current.answer -= step.answer;
            }
            current.lost = step.lost;
        }
        return current;
    }

    private Result mulDivDeg(String expression) {
        Result current = brackets(expression);
        while (current.lost.length() > 0) {
            char sign = current.lost.charAt(0);
            if (!(sign == '*' || sign == '/' || sign == '^')) {
                break;
            }
            String nextExpression = current.lost.substring(1);
            Result step = brackets(nextExpression);
            if (sign == '*') {
                current.answer *= step.answer;
            } else if (sign == '/'){
                current.answer /= step.answer;
            } else {
                current.answer = pow(current.answer, step.answer);
            }
            current.lost = step.lost;
        }
        return current;
    }

    private Result brackets(String expression) {
        if (expression.charAt(0) == '(') {
            Result stepResult = minusPlus(expression.substring(1));
            if (stepResult.lost.length() != 0 && stepResult.lost.charAt(0) == ')') {
                stepResult.lost = stepResult.lost.substring(1);
            }
            return stepResult;
        }
        return functions(expression);
    }

    private Pair<Boolean, String> negativeExpression(String expression) {
        boolean isNegative = false;
        if (expression.charAt(0) == '-') {
            isNegative = true;
            expression = expression.substring(1);
        } else if (expression.charAt(0) == '+') {
            expression = expression.substring(1);
        }
        return new Pair<>(isNegative, expression);
    }

    private Result functions(String expression) {
        StringBuilder function = new StringBuilder();
        int i = 0;
        Pair<Boolean, String> negs = negativeExpression(expression);
        boolean isNegative = negs.first;
        expression = negs.second;
        while (i < expression.length() && Character.isLetter(expression.charAt(i))) {
            function.append(expression.charAt(i));
            ++i;
        }
        if (function.length() > 0) {
            if (i < expression.length() && expression.charAt(i) == '(') {
                Result result = brackets(expression.substring(i));
                result = makeFunction(function.toString(), result);
                if (isNegative) {
                    result.answer *= -1;
                }
                return result;
            }
        }
        if (isNegative) {
            return getNumber("-" + expression);
        } else {
            return getNumber(expression);
        }
    }

    private Result getNumber(String expression) {
        Pair<Boolean, String> negs = negativeExpression(expression);
        boolean isNegative = negs.first;
        expression = negs.second;
        int i = 0;
        boolean wasE = false;
        while (i < expression.length() && (Character.isDigit(expression.charAt(i)) ||
                expression.charAt(i) == 'E' || expression.charAt(i) == '.' ||
                (wasE && expression.charAt(i) == '+'))) {
            if (expression.charAt(i) == 'E') {
                wasE = true;
            }
            if (expression.charAt(i) == '+') {
                wasE = false;
            }
            ++i;
        }
        double doubleNumber = Double.valueOf(expression.substring(0, i));
        if (isNegative) {
            doubleNumber *= -1;
        }
        return new Result(doubleNumber, expression.substring(i));
    }

    private Result makeFunction(String function, Result result) {
        if (function.equals("SIN")) {
            return new Result(Math.sin(Math.toRadians(result.answer)), result.lost);
        } else if (function.equals("COS")) {
            return new Result(Math.cos(Math.toRadians(result.answer)), result.lost);
        } else {
            return new Result(Math.abs(result.answer), result.lost);
        }
    }

    private class Result {

        double answer;
        String lost;

        Result(double answer, String lost) {
            this.answer = answer;
            this.lost = lost;
        }
    }

    private class Pair<T, D> {
        T first;
        D second;

        Pair(T first, D second) {
            this.first = first;
            this.second = second;
        }
    }

}