Expression.java

package calculator.model;

import calculator.utils.ExceptionConstants;
import calculator.utils.Validator;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class Expression {
    private HashSet<Character> operators;
    private String expression;

    private static final List<Character> DEFAULT_SEPARATOR = Arrays.asList(':', ',');
    private static final String OR_DELIMITER = "|";
    private static final String CUSTOM_SEPARATOR_REGEX = "^//(.)\\\\n(.*)";

    private static final int CUSTOM_SEPARATOR_INDEX = 1;
    private static final int EXPRESSION_INDEX = 2;

    public static Expression parse(String line) {
        Expression expression = new Expression();

        line = line.trim();
        line = expression.extractOperators(line);
        expression.expression = line;

        return expression;
    }

    public HashSet<Character> getOperators() {
        return operators;
    }

    public String getExpression() {
        return expression;
    }

    public int calculate() {
        List<String> results = Arrays.stream(expression.split(getOperatorsRegex())).toList();
        results.forEach(Validator::validatePositiveInt);
        try {
            return results.stream()
                    .mapToInt(Integer::parseInt)
                    .reduce(0, Math::addExact);
        } catch (Exception exception) {
            throw new IllegalArgumentException(
                    ExceptionConstants.INVALID_EXPRESSION.getMessage() + expression, exception);
        }
    }

    private String extractOperators(String line) {
        this.operators = new HashSet<>();
        this.operators.addAll(DEFAULT_SEPARATOR);
        Matcher matcher = Pattern.compile(CUSTOM_SEPARATOR_REGEX).matcher(line);
        if (matcher.find()) {
            operators.add(matcher.group(CUSTOM_SEPARATOR_INDEX).charAt(0));
            return matcher.group(EXPRESSION_INDEX);
        }
        return line;
    }

    private String getOperatorsRegex() {
        return operators.stream()
                .map((ch) -> Pattern.quote(ch.toString())) // \같은 문자 처리
                .collect(Collectors.joining(OR_DELIMITER));
    }
}