private DateTimeResolutionResult parseDecade()

in libraries/bot-dialogs/src/main/java/com/microsoft/recognizers/text/datetime/parsers/BaseDatePeriodParser.java [1730:1853]
100 lines of code
22 McCabe index (conditional complexity)

    private DateTimeResolutionResult parseDecade(String text, LocalDateTime referenceDate) {

        DateTimeResolutionResult ret = new DateTimeResolutionResult();
        int firstTwoNumOfYear = referenceDate.getYear() / 100;
        int decade = 0;
        int decadeLastYear = 10;
        int swift = 1;
        boolean inputCentury = false;

        String trimmedText = text.trim();
        ConditionalMatch match = RegexExtension.matchExact(this.config.getDecadeWithCenturyRegex(), text, true);
        String beginLuisStr;
        String endLuisStr;

        if (match.getSuccess()) {

            String decadeStr = match.getMatch().get().getGroup("decade").value.toLowerCase();
            if (!IntegerUtility.canParse(decadeStr)) {
                if (this.config.getWrittenDecades().containsKey(decadeStr)) {
                    decade = this.config.getWrittenDecades().get(decadeStr);
                } else if (this.config.getSpecialDecadeCases().containsKey(decadeStr)) {
                    firstTwoNumOfYear = this.config.getSpecialDecadeCases().get(decadeStr) / 100;
                    decade = this.config.getSpecialDecadeCases().get(decadeStr) % 100;
                    inputCentury = true;
                }
            } else {
                decade = Integer.parseInt(decadeStr);
            }

            String centuryStr = match.getMatch().get().getGroup("century").value.toLowerCase();
            if (!StringUtility.isNullOrEmpty(centuryStr)) {
                if (!IntegerUtility.canParse(centuryStr)) {
                    if (this.config.getNumbers().containsKey(centuryStr)) {
                        firstTwoNumOfYear = this.config.getNumbers().get(centuryStr);
                    } else {
                        // handle the case like "one/two thousand", "one/two hundred", etc.
                        List<ExtractResult> er = this.config.getIntegerExtractor().extract(centuryStr);

                        if (er.size() == 0) {
                            return ret;
                        }

                        firstTwoNumOfYear = Math.round(((Double)(this.config.getNumberParser().parse(er.get(0)).getValue() != null ?
                                this.config.getNumberParser().parse(er.get(0)).getValue() :
                                0)).floatValue());
                        if (firstTwoNumOfYear >= 100) {
                            firstTwoNumOfYear = firstTwoNumOfYear / 100;
                        }
                    }
                } else {
                    firstTwoNumOfYear = Integer.parseInt(centuryStr);
                }

                inputCentury = true;
            }
        } else {
            // handle cases like "the last 2 decades" "the next decade"
            match = RegexExtension.matchExact(this.config.getRelativeDecadeRegex(), trimmedText, true);
            if (match.getSuccess()) {
                inputCentury = true;

                swift = this.config.getSwiftDayOrMonth(trimmedText);

                String numStr = match.getMatch().get().getGroup("number").value.toLowerCase();
                List<ExtractResult> er = this.config.getIntegerExtractor().extract(numStr);
                if (er.size() == 1) {
                    int swiftNum = Math.round(((Double)(this.config.getNumberParser().parse(er.get(0)).getValue() != null ?
                            this.config.getNumberParser().parse(er.get(0)).getValue() :
                            0)).floatValue());
                    swift = swift * swiftNum;
                }

                int beginDecade = (referenceDate.getYear() % 100) / 10;
                if (swift < 0) {
                    beginDecade += swift;
                } else if (swift > 0) {
                    beginDecade += 1;
                }

                decade = beginDecade * 10;
            } else {
                return ret;
            }
        }

        int beginYear = firstTwoNumOfYear * 100 + decade;
        // swift = 0 corresponding to the/this decade
        int totalLastYear = decadeLastYear * Math.abs(swift == 0 ? 1 : swift);

        if (inputCentury) {
            beginLuisStr = DateTimeFormatUtil.luisDate(beginYear, 1, 1);
            endLuisStr = DateTimeFormatUtil.luisDate(beginYear + totalLastYear, 1, 1);
        } else {
            String beginYearStr = String.format("XX%s", decade);
            beginLuisStr = DateTimeFormatUtil.luisDate(-1, 1, 1);
            beginLuisStr = beginLuisStr.replace("XXXX", beginYearStr);

            String endYearStr = String.format("XX%s", (decade + totalLastYear));
            endLuisStr = DateTimeFormatUtil.luisDate(-1, 1, 1);
            endLuisStr = endLuisStr.replace("XXXX", endYearStr);
        }
        ret.setTimex(String.format("(%s,%s,P%sY)", beginLuisStr, endLuisStr, totalLastYear));

        int futureYear = beginYear;
        int pastYear = beginYear;
        LocalDateTime startDate = DateUtil.safeCreateFromMinValue(beginYear, 1, 1);
        if (!inputCentury && startDate.isBefore(referenceDate)) {
            futureYear += 100;
        }

        if (!inputCentury && startDate.compareTo(referenceDate) >= 0) {
            pastYear -= 100;
        }

        ret.setFutureValue(new Pair<>(DateUtil.safeCreateFromMinValue(futureYear, 1, 1),
                DateUtil.safeCreateFromMinValue(futureYear + totalLastYear, 1, 1)));

        ret.setPastValue(new Pair<>(DateUtil.safeCreateFromMinValue(pastYear, 1, 1),
                DateUtil.safeCreateFromMinValue(pastYear + totalLastYear, 1, 1)));

        ret.setSuccess(true);

        return ret;
    }