Brackets.kt

package com.jetbrains.rider.ideaInterop.fileTypes.csharp

import com.intellij.lang.Language
import com.intellij.lang.LanguageAnnotators
import com.intellij.lang.annotation.AnnotationHolder
import com.intellij.lang.annotation.Annotator
import com.intellij.openapi.editor.markup.TextAttributes
import com.intellij.psi.PsiElement
import com.intellij.psi.impl.source.tree.LeafPsiElement
import com.intellij.ui.JBColor
import com.jetbrains.rider.ideaInterop.fileTypes.csharp.RainbowColors.angleBracketsColor
import com.jetbrains.rider.ideaInterop.fileTypes.csharp.RainbowColors.roundBracketsColor
import com.jetbrains.rider.ideaInterop.fileTypes.csharp.RainbowColors.squareBracketsColor
import com.jetbrains.rider.ideaInterop.fileTypes.csharp.RainbowColors.squigglyBracketsColor
import com.jetbrains.rider.ideaInterop.fileTypes.csharp.RainbowUtils.annotateUtil
import java.awt.Color
import java.awt.Font

class RainbowBrackets : Annotator {

    override fun annotate(element: PsiElement, holder: AnnotationHolder) {
        if (element is LeafPsiElement) {
            annotateUtil(element, holder)
        }
    }
}

object RainbowUtils {

    private val roundBrackets = arrayOf("(", ")")
    private val squigglyBrackets = arrayOf("{", "}")
    private val squareBrackets = arrayOf("[", "]")
    private val angleBrackets = arrayOf("<", ">", "</", "/>")

    fun dynamicallySelectColor(level: Int, colors: Array<Color>) =
        colors[level % colors.size]

    private fun containsBrackets(text: String, brackets: Array<String>) =
        brackets.any { text.contains(it) }

    private fun getAttributesColor(level: Int, bracket: String) =
        when (bracket) {
            in roundBrackets -> dynamicallySelectColor(level, roundBracketsColor)
            in squigglyBrackets -> dynamicallySelectColor(level, squigglyBracketsColor)
            in squareBrackets -> dynamicallySelectColor(level, squareBracketsColor)
            in angleBrackets -> dynamicallySelectColor(level, angleBracketsColor)
            else -> dynamicallySelectColor(level, roundBracketsColor)
        }

    private fun getBracketAttributes(level: Int, bracket: String) =
        TextAttributes(getAttributesColor(level, bracket), null, null, null, Font.PLAIN)

    private fun getBracketLevel(element: LeafPsiElement) =
        when {
            element.text in roundBrackets -> getBracketLevel(element, roundBrackets)
            element.text in squigglyBrackets -> getBracketLevel(element, squigglyBrackets)
            element.text in squareBrackets -> getBracketLevel(element, squareBrackets)
            element.text in angleBrackets -> getBracketLevel(element, angleBrackets)
            else -> 0
        }

    private fun getBracketLevel(psiElement: PsiElement, brackets: Array<String>): Int {
        var level = 0
        var eachParent: PsiElement? = psiElement
        while (eachParent != null) {
            if (containsBrackets(eachParent.text, brackets)) {
                level++
            }
            eachParent = eachParent.parent
        }
        return level
    }
    private val specLangList = arrayOf("JAVA", "kotlin", "Scala", "JavaScript", "PHP")
    fun registerAnnotatorForAllLanguages() {
        Language.getRegisteredLanguages()
            .filter { lang -> !specLangList.contains(lang.id) }
            .forEach { lang -> LanguageAnnotators.INSTANCE.addExplicitExtension(lang, RainbowBrackets()) }
    }
    fun annotateUtil(element: LeafPsiElement, holder: AnnotationHolder) {
        val level = getBracketLevel(element)
        if (level > 0) {
            val attrs = getBracketAttributes(level, element.text)
            holder.createInfoAnnotation(element.psi, null).enforcedTextAttributes = attrs
        }
    }
}

object RainbowColors {

    val roundBracketsColor: Array<Color> = arrayOf(
        JBColor(0xE66A01, 0xE6B422),
        JBColor(0x109321, 0x00A960),
        JBColor(0xFF3E5D, 0xFC7482),
        JBColor(0x9C27B0, 0x9C27B0),
        JBColor(0x006BE7, 0x2196F3)
    )

    val squareBracketsColor: Array<Color> = arrayOf(
        JBColor(0x0B9087, 0x33CCFF),
        JBColor(0x6444E6, 0x8080FF),
        JBColor(0x00599B, 0x0073A8)
    )

    val squigglyBracketsColor: Array<Color> = arrayOf(
        JBColor(0x0057D2, 0x1976D2),
        JBColor(0x509629, 0xCDDC39),
        JBColor(0xA526AA, 0x965096),
        JBColor(0xFF6D27, 0xFF9863)
    )

    val angleBracketsColor = roundBracketsColor
}