override fun applyToNextLine()

in src/commonMain/kotlin/org/intellij/markdown/parser/constraints/CommonMarkdownConstraints.kt [49:161]
99 lines of code
23 McCabe index (conditional complexity)

    override fun applyToNextLine(pos: LookaheadText.Position?): CommonMarkdownConstraints {
        if (pos == null) {
            return base
        }
        assert(pos.offsetInCurrentLine == -1) { "given $pos" }

        val line = pos.currentLine
        val prevN = indents.size
        var indexPrev = 0

        val getBlockQuoteIndent = { startOffset: Int ->
            var offset = startOffset
            var blockQuoteIndent = 0

            // '\t' can be omitted here since it'll add at least 4 indent
            while (blockQuoteIndent < 3 && offset < line.length && line[offset] == ' ') {
                blockQuoteIndent++
                offset++
            }

            if (offset < line.length && line[offset] == BQ_CHAR) {
                blockQuoteIndent + 1
            } else {
                null
            }
        }

        val fillMaybeBlockquoteAndListIndents = fun(constraints: CommonMarkdownConstraints): CommonMarkdownConstraints {
            if (indexPrev >= prevN) {
                return constraints
            }

            var offset = constraints.getCharsEaten(line)
            var totalSpaces = 0
            var spacesSeen = 0
            val hasKMoreSpaces = { k: Int ->
                val oldSpacesSeen = spacesSeen
                val oldOffset = offset
                afterSpaces@
                while (spacesSeen < k && offset < line.length) {
                    val deltaSpaces = when (line[offset]) {
                        ' ' -> 1
                        '\t' -> 4 - totalSpaces % 4
                        else -> break@afterSpaces
                    }
                    spacesSeen += deltaSpaces
                    totalSpaces += deltaSpaces
                    offset++
                }
                if (offset == line.length) {
                    spacesSeen = Int.MAX_VALUE
                }

                if (k <= spacesSeen) {
                    spacesSeen -= k
                    true
                } else {
                    offset = oldOffset
                    spacesSeen = oldSpacesSeen
                    false
                }
            }

            val bqIndent: Int?
            if (types[indexPrev] == BQ_CHAR) {
                bqIndent = getBlockQuoteIndent(offset)
                        ?: return constraints
                offset += bqIndent
                indexPrev++
            } else {
                bqIndent = null
            }

            val oldIndexPrev = indexPrev
            while (indexPrev < prevN && types[indexPrev] != BQ_CHAR) {
                val deltaIndent = indents[indexPrev] -
                        if (indexPrev == 0)
                            0
                        else
                            indents[indexPrev - 1]

                if (!hasKMoreSpaces(deltaIndent)) {
                    break
                }

                indexPrev++
            }

            var result = constraints
            if (bqIndent != null) {
                val bonusForTheBlockquote = if (hasKMoreSpaces(1)) 1 else 0
                result = create(result, bqIndent + bonusForTheBlockquote, BQ_CHAR, true, offset)
            }
            for (index in oldIndexPrev until indexPrev) {
                val deltaIndent = indents[index] -
                        if (index == 0)
                            0
                        else
                            indents[index - 1]
                result = create(result, deltaIndent, types[index], false, offset)
            }
            return result
        }

        var result = base
        while (true) {
            val nextConstraints = fillMaybeBlockquoteAndListIndents(result)
            if (nextConstraints == result) {
                return result
            }
            result = nextConstraints
        }
    }