package com.maxzhao;


import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Stack;
import java.util.function.BiFunction;
import java.util.function.Function;

/**
 * 计算四则运算表达式(含括号)，返回计算结果
 * 已有合法表达式校验
 *
 * @author
 * @time 2018.12.10
 */
public class CalculatorUtils2 {

    /**
     * 符号栈：运算符和括号
     */
    private static Stack<String> symbolStack = null;

    /**
     * 解析并计算四则运算表达式(含括号)，返回计算结果
     *
     * @param expression 算术表达式(含括号)
     */
    public static BigDecimal caculateBigDecimal(String expression) {
        expression = removeStrSpace(expression);
        if (expression.length() > 1 && !"=".equals(expression.charAt(expression.length() - 1) + "")) {
            expression += "=";
        }
        if (!isStandard(expression)) {
            System.err.println("错误：算术表达式有误！");
            return new BigDecimal("-1");
        }
        Stack<BigDecimal> numStack = new Stack<>();
        symbolStack = new Stack<>();
        StringBuffer temp = new StringBuffer();
        char thisChar;
        for (int i = 0; i < expression.length(); i++) {
            thisChar = expression.charAt(i);
            if (isNumber(thisChar) || thisChar == '.') {
                temp.append(thisChar);
                continue;
            }
            if (!temp.toString().isEmpty()) {
                numStack.push(new BigDecimal(temp.toString()));
                temp = new StringBuffer();
            }
            if (' ' == thisChar) {
                /*忽略空格和 ,*/
                continue;
            }
            /*校验运算符*/
            if ('f' == thisChar) {
                String floorStr = expression.substring(i, i + 5);
                if ("floor".equals(floorStr)) {
                    i += 4;
                    symbolStack.push(floorStr);
                    continue;
                }
            } else if ('m' == thisChar) {
                String floorStr = expression.substring(i, i + 3);
                if ("max".equals(floorStr)) {
                    i += 2;
                    symbolStack.push(floorStr);
                    continue;
                } else if ("min".equals(floorStr)) {
                    i += 2;
                    symbolStack.push(floorStr);
                    continue;
                }
            }
            int numCount = 1;
            BigDecimal a, b;
            BigDecimal[] numArr;
            while (!compareStackPeek(String.valueOf(thisChar))) {
                String top = symbolStack.peek();
                switch (top) {
                    case "+":
                        b = numStack.pop();
                        a = numStack.pop();
                        numStack.push(a.add(b));
                        symbolStack.pop();
                        break;
                    case "-":
                        b = numStack.pop();
                        a = numStack.pop();
                        numStack.push(a.subtract(b));
                        symbolStack.pop();
                        break;
                    case "*":
                        b = numStack.pop();
                        a = numStack.pop();
                        numStack.push(mul(a, b));
                        symbolStack.pop();
                        break;
                    case "/":
                        b = numStack.pop();
                        a = numStack.pop();
                        /*TODO 保留小数位数*/
                        numStack.push(b.signum() == 0 ? BigDecimal.ZERO : a.divide(b, 10, RoundingMode.CEILING));
                        symbolStack.pop();
                        break;
                }
                if (')' == thisChar) {
                    switch (top) {
                        case ",":
                            numCount++;
                            symbolStack.pop();
                            break;
                        case "floor":
                            numStack.push(CalculatorMathFunction.functionParamMap.get("floor").apply(numStack.pop()));
                            symbolStack.pop();
                            break;
                        case "max":
                            numArr = new BigDecimal[numCount];
                            for (int j = 0; j < numCount; j++) {
                                numArr[j] = numStack.pop();
                            }
                            numStack.push(CalculatorMathFunction.functionParamsMap.get("max").apply(numArr));
                            symbolStack.pop();
                            break;
                        case "min":
                            numArr = new BigDecimal[numCount];
                            for (int j = 0; j < numCount; j++) {
                                numArr[j] = numStack.pop();
                            }
                            numStack.push(CalculatorMathFunction.functionParamsMap.get("min").apply(numArr));
                            symbolStack.pop();
                            break;
                    }
                    if ("(".equals(top)) {
                        symbolStack.pop();
                        break;
                    }
                } else {
                    break;
                }
            }
            if (thisChar != '=') {
                if (")".equals(String.valueOf(thisChar))
                    /* && "(".equals(symbolStack.peek())*/) {
//                    symbolStack.pop();
                } else {
                    symbolStack.push(String.valueOf(thisChar));
                }
            }
        }
        return numStack.pop();
    }

    /**
     * 去除字符串中的所有空格
     *
     * @param str
     * @return
     */
    private static String removeStrSpace(String str) {
        return str != null ? str.contains("  ") ? removeStrSpace(str.replaceAll(" ", "")) : str.replaceAll(" ", "") : "";
    }

    /**
     * 检查算术表达式的基本合法性
     *
     * @param expression 计算表达式
     * @return 符合返回true，否则false
     */
    private static boolean isStandard(String expression) {
        if (Optional.ofNullable(expression).orElse("").isEmpty()) {
            return false;
        }
        if (expression.indexOf("=") != expression.length() - 1) {
            return false;
        }
        int countLeftParenthesis = 0;
        char thisChar;
        for (int i = 0; i < expression.length(); i++) {
            thisChar = expression.charAt(i);
            /*校验是否为函数*/
            if ('f' == thisChar) {
                String floorStr = expression.substring(i, i + 5);
                if ("floor".equals(floorStr)) {
                    i += 5;
                    continue;
                }
            } else if ('m' == thisChar) {
                String floorStr = expression.substring(i, i + 3);
                if ("max".equals(floorStr)) {
                    i += 3;
                    continue;
                } else if ("min".equals(floorStr)) {
                    i += 3;
                    continue;
                }
            }
            if (!isNumber(thisChar) && !isOperator(thisChar)) {
                return false;
            }
            if ("(".equals(String.valueOf(thisChar))) {
                countLeftParenthesis++;
            }
            if (")".equals(String.valueOf(thisChar))) {
                if (countLeftParenthesis == 0) {
                    return false;
                }
                countLeftParenthesis--;
            }
        }
        return countLeftParenthesis == 0;
    }

    /**
     * 判断字符是否为数字
     *
     * @param num 字符
     * @return true 数字
     */
    private static boolean isNumber(char num) {
        return num >= '0' && num <= '9';
    }

    /**
     * 判断字符是否为运算符
     *
     * @param num 字符
     * @return true 操作符
     */
    private static boolean isOperator(char num) {
        return "()+-*/=".contains(String.valueOf(num));
    }

    /**
     * 比较优先级：当前运算符比栈顶元素运算符
     *
     * @param symbol
     * @return 优先级高则返回true，否则返回false
     */
    private static boolean compareStackPeek(String symbol) {
        if (symbolStack.empty()) {
            return true;
        }
        // 符号优先级说明（从高到低）:
        // 第1级: (
        // 第2级: * /
        // 第3级: + -
        // 第4级: )
        String top = symbolStack.peek();
//        if ("(".equals(top)) {
//            return true;
//        }
        // 比较优先级
        switch (symbol) {
            case "(":
                return true;
            case "*":
            case "/":
                return ("+".equals(top) || "-".equals(top));
            case "+":
            case "-":
            case ")":
            case "=":
                return false;
            default:
                break;
        }
        return true;
    }

    /*
     *精确加法
     */
    public static BigDecimal add(BigDecimal b1, BigDecimal b2) {
        return b1.add(b2);
    }

    /*
     *精确减法
     */
    public static BigDecimal sub(BigDecimal b1, BigDecimal b2) {
        return b1.subtract(b2);
    }

    /*
     *精确乘法
     */
    public static BigDecimal mul(BigDecimal b1, BigDecimal b2) {
        return b1.multiply(b2);
    }

    /*
     *精确乘法(扩大times倍)
     */
    public static BigDecimal mul(BigDecimal b, int times) {
        return b.multiply(new BigDecimal(Integer.valueOf(times).toString()));
    }

    /*
     *精确除法(默认精度)
     */
    public static BigDecimal div(BigDecimal b1, BigDecimal b2) {
        return div(b1, b2, 2);
    }

    /*
     *精确除法
     */
    public static BigDecimal div(BigDecimal b1, BigDecimal b2, int scale) {
        if (b2.equals(new BigDecimal(0))) {
            return new BigDecimal(0);
        }
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP);
    }


    /*
     *精确比较(与零比较)
     */
    public static int comparetoZero(BigDecimal b1) {
        BigDecimal b2 = new BigDecimal("0");

        return b1.compareTo(b2);//b1>b2返回1 b1=b2 返回0 1<b2返回-1.
    }

    public static void main(String[] args) {
        String expression = "((10+5) *3.7-4)/2.2";
        BigDecimal result = CalculatorUtils2.caculateBigDecimal(expression);
        System.out.println(expression + " = " + result);
    }
}

class CalculatorMathFunction {

    public static final Map<String, Function<BigDecimal, BigDecimal>> functionParamMap = new HashMap<>();
    public static final Map<String, Function<BigDecimal[], BigDecimal>> functionParamsMap = new HashMap<>();
    public static final Map<String, BiFunction<BigDecimal, BigDecimal, BigDecimal>> biFunctionMap = new HashMap<>();

    static {
        functionParamMap.put("floor", new FloorFunction());
        functionParamsMap.put("max", new MaxFunction());
        functionParamsMap.put("min", new MinFunction());
    }

    static class FloorFunction implements Function<BigDecimal, BigDecimal> {
        @Override
        public BigDecimal apply(BigDecimal bigDecimal) {
            return bigDecimal.setScale(0, RoundingMode.FLOOR);
        }
    }

    static class MaxFunction implements Function<BigDecimal[], BigDecimal> {
        @Override
        public BigDecimal apply(BigDecimal[] numArr) {
            if (numArr.length == 0) {
                return null;
            } else if (numArr.length == 1) {
                return numArr[0];
            }
            BigDecimal max = numArr[0];
            for (int i = 1; i < numArr.length; i++) {
                max = max.max(numArr[i]);
            }
            return max;
        }
    }

    static class MinFunction implements Function<BigDecimal[], BigDecimal> {
        @Override
        public BigDecimal apply(BigDecimal[] numArr) {
            if (numArr.length == 0) {
                return null;
            } else if (numArr.length == 1) {
                return numArr[0];
            }
            BigDecimal min = numArr[0];
            for (int i = 1; i < numArr.length; i++) {
                min = min.min(numArr[i]);
            }
            return min;
        }
    }
}