RomanCalculator

package sk.upjs.ics.agilnaRuka.romanCalculator;

import java.util.ArrayList;
import java.util.List;

public class GeneralRomanNumber {

    public static final String DEFAULT_ROMAN_DIGITS = "OIVXLCDM";
    public static final int DIVIDING_BY_ZERO = -9999;
    public static final int UNKNOWN_OPERATION = -9999;
    public static final int INVALID_NUMBER = -9999;
    private String RomanDigits;
    private String RomanNumber;
    private GeneralRomanNumberConverter converter;

    public GeneralRomanNumber(String RomanDigits) {
        converter = new GeneralRomanNumberConverter();

        String RomanDigitsWithoutWhitespaces = removeSpaces(RomanDigits);

        if (RomanDigitsWithoutWhitespaces.length() < 2
                || converter.areRomanDigitsValid(RomanDigitsWithoutWhitespaces) == false) {
            this.RomanDigits = DEFAULT_ROMAN_DIGITS;
        } else {
            this.RomanDigits = RomanDigits;
        }
    }

    public String getRomanDigits() {
        return RomanDigits;
    }

    public String getRomanDigitsWithoutZero() {
        return RomanDigits.substring(1);
    }

    public String getZeroFromRomanDigits() {
        return String.valueOf(RomanDigits.charAt(0));
    }

    public String getPositiveRomanNumber() {
        if (RomanNumber.startsWith("-")) {
            return RomanNumber.substring(1);
        }
        return RomanNumber;
    }

    String removeSpaces(String string) {
        StringBuilder stringBuilder = new StringBuilder();
        char character;
        for (int index = 0; index < string.length(); index++) {
            character = string.charAt(index);
            if (character != ' ') {
                stringBuilder.append(character);
            }
        }
        return stringBuilder.toString();
    }

    boolean isRomanNumber(String RomanDigits, String RomanNumber) {
        for (int index = 0; index < RomanNumber.length(); index++) {
            if (converter.isSymbolInRomanDigits(RomanNumber.charAt(index), RomanDigits) == false) {
                return false;
            }
        }
        return true;
    }

    boolean containsOnlyValidDigits(String RomanNumber) {
        if (converter.isEachUppercaseEnglishLetter(RomanNumber) == false) {
            return false;
        }

        if (RomanNumber.length() > 1) {
            return isRomanNumber(getRomanDigitsWithoutZero(), RomanNumber);
        }
        return isRomanNumber(getRomanDigits(), RomanNumber);
    }

    int put(String RomanNumber) {
        String RomanNumberWithoutSpaces = removeSpaces(RomanNumber);

        if (isRomanNumber(getRomanDigits(), RomanNumberWithoutSpaces.substring(1)) == false
                && isRomanNumber(getRomanDigits(), RomanNumberWithoutSpaces) == false) {
            return -9999;
        }

        this.RomanNumber = RomanNumberWithoutSpaces;

        return value();
    }

    int value() {
        if (RomanNumber == null || RomanNumber.equals(getZeroFromRomanDigits())
                || getPositiveRomanNumber().equals(getZeroFromRomanDigits())) {
            return 0;
        }

        if (RomanNumber.startsWith("-")) {
            return -converter.RomanNumeralsConverter(getRomanDigitsWithoutZero(), getPositiveRomanNumber());
        }

        return converter.RomanNumeralsConverter(getRomanDigitsWithoutZero(), RomanNumber);
    }

    String romanValue() {
        return RomanNumber;
    }

    int normalCalculator(int number1, String operation, int number2) {
        if (number1 == GeneralRomanNumber.INVALID_NUMBER || number2 == GeneralRomanNumber.INVALID_NUMBER) {
            return GeneralRomanNumber.INVALID_NUMBER;
        }

        int result = 0;

        if (operation.equals("+")) {
            result = number1 + number2;
        } else if (operation.equals("-")) {
            result = number1 - number2;
        } else if (operation.equals("*")) {
            result = number1 * number2;
        } else if (operation.equals("/")) {
            if (number2 == 0) {
                return DIVIDING_BY_ZERO;
            }
            result = number1 / number2;
        } else {
            result = UNKNOWN_OPERATION;
        }
        return result;
    }

    List<String> parseExpression(String expression) {
        String expressionWithoutSpaces = removeSpaces(expression);
        List<String> parsedExpression = new ArrayList<>();

        for (int index = 1; index < expressionWithoutSpaces.length(); index++) {
            String character = String.valueOf(expressionWithoutSpaces.charAt(index));
            if (character.equals("+") || character.equals("-") || character.equals("*") || character.equals("/")) {
                parsedExpression.add(expressionWithoutSpaces.substring(0, index));
                parsedExpression.add(character);
                parsedExpression.add(expressionWithoutSpaces.substring(index + 1, expressionWithoutSpaces.length()));
                break;
            }
        }
        return parsedExpression;
    }

    void saveResult(int result) {
        if (result == 0) {
            RomanNumber = getZeroFromRomanDigits();
        } else if (result < 0) {
            RomanNumber = "-" + converter.integerToRoman(result * (-1), getRomanDigitsWithoutZero());
        } else {
            RomanNumber = converter.integerToRoman(result, getRomanDigitsWithoutZero());
        }
    }

    int calculator(String input) {
        List<String> parsedExpression = parseExpression(input);

        if (parsedExpression.isEmpty()) {
            return -9999;
        }

        int number1 = put(parsedExpression.get(0));
        String operation = parsedExpression.get(1);
        int number2 = put(parsedExpression.get(2));

        int result = normalCalculator(number1, operation, number2);
        saveResult(result);
        return result;
    }

}