docs.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.github.javaparser:javaparser-core:3.26.2'
    }
}

import com.github.javaparser.JavaParser
import com.github.javaparser.ParserConfiguration
import com.github.javaparser.ast.body.EnumDeclaration
import com.github.javaparser.ast.body.FieldDeclaration
import com.github.javaparser.ast.type.ClassOrInterfaceType

tasks.register('generateConfigDocs') {
    group = 'documentation'
    description = 'Generates CONFIG.md from Settings.java and SettingTypes.java'

    def settingsFile = file("src/main/java/configured/Settings.java")
    def typesFile = file("src/main/java/configured/SettingTypes.java")
    def outputFile = file("CONFIG.md")

    inputs.files settingsFile, typesFile
    outputs.file outputFile

    doLast {
        def parserConfig = new ParserConfiguration()
                .setLanguageLevel(ParserConfiguration.LanguageLevel.JAVA_17)
        def parser = new JavaParser(parserConfig)

        def cleanComment = { commentOptional ->
            if (!commentOptional.isPresent()) return ""
            return commentOptional.get().asString()
                    .lines()
                    .collect { line -> line.trim().replaceAll(/^(?:\/{3}|\/\*\*|\*\/|\*)\s?/, '').trim() }
                    .findAll { !it.isEmpty() }
                    .join("\n")
        }

        def enumRegistry = [:] // Map<String, List<[name: String, doc: String]>>
        if (typesFile.exists()) {
            def parseResult = parser.parse(typesFile)
            if (!parseResult.isSuccessful()) {
                throw new GradleException("Failed to parse SettingTypes.java: " + parseResult.problems)
            }
            parseResult.result.get().findAll(EnumDeclaration.class).each { enumDecl ->
                def entries = []
                enumDecl.entries.each { entry ->
                    entries << [name: entry.nameAsString, doc: cleanComment(entry.comment)]
                }
                enumRegistry[enumDecl.nameAsString] = entries
            }
        }

        def getSimpleName = { String typeName ->
            return typeName.contains(".") ? typeName.substring(typeName.lastIndexOf('.') + 1) : typeName
        }

        def settingsParseResult = parser.parse(settingsFile)
        if (!settingsParseResult.isSuccessful()) {
            throw new GradleException("Failed to parse Settings.java: " + settingsParseResult.problems)
        }
        def settingsCu = settingsParseResult.result.get()
        def md = new StringBuilder()

        md.append("# Settings\n*All default values should show vanilla behavior.\nIf that is not the case, please submit a bug report.*\n\n")

        settingsCu.findAll(FieldDeclaration.class).each { field ->
            boolean hasConfig = field.annotations.any { it.nameAsString == 'Config' }
            if (!hasConfig) return

            def variable = field.variables[0]
            def fieldName = variable.nameAsString
            def fieldType = field.commonType
            def rawType = fieldType.asString()
            def fieldComment = cleanComment(field.comment)

            String displayType = "unknown"
            String matchedEnumName = null
            String mapKeyEnumName = null

            if (rawType.equalsIgnoreCase("boolean")) {
                displayType = "bool"
            } else if (rawType.equalsIgnoreCase("int") || rawType.equalsIgnoreCase("integer")) {
                displayType = "int"
            } else if (rawType.equalsIgnoreCase("String")) {
                displayType = "string"
            } else if (rawType.startsWith("Map") || rawType.startsWith("HashMap")) {
                displayType = "map"
                // Extract generic Key type from Map<KeyType, ValueType>
                if (fieldType instanceof ClassOrInterfaceType && fieldType.typeArguments.isPresent()) {
                    def typeArgs = fieldType.typeArguments.get()
                    if (!typeArgs.isEmpty()) {
                        def keyTypeSimple = getSimpleName(typeArgs[0].asString())
                        if (enumRegistry.containsKey(keyTypeSimple)) {
                            mapKeyEnumName = keyTypeSimple
                        }
                    }
                }
            } else if (rawType.startsWith("List") || rawType.startsWith("ArrayList")) {
                displayType = "list"
            } else {
                def simpleName = getSimpleName(rawType)
                if (enumRegistry.containsKey(simpleName)) {
                    displayType = "enum"
                    matchedEnumName = simpleName
                } else {
                    displayType = rawType.toLowerCase()
                }
            }

            md.append("### ${fieldName} `${displayType}`\n")

            if (!fieldComment.isEmpty()) {
                md.append(fieldComment).append("\n")
            }

            if (matchedEnumName != null && enumRegistry.containsKey(matchedEnumName)) {
                md.append("> Variants:\n")
                enumRegistry[matchedEnumName].each { variant ->
                    def docStr = variant.doc ? " " + variant.doc.replaceAll(/\n+/, ' ') : ""
                    md.append("> - `${variant.name}`${docStr}\n")
                }
            }

            if (mapKeyEnumName != null && enumRegistry.containsKey(mapKeyEnumName)) {
                md.append("> Keys:\n")
                enumRegistry[mapKeyEnumName].each { variant ->
                    def docStr = variant.doc ? " " + variant.doc.replaceAll(/\n+/, ' ') : ""
                    md.append("> - `${variant.name}`${docStr}\n")
                }
            }

            md.append("\n")
        }

        outputFile.text = md.toString().trim() + "\n"
        logger.lifecycle("Successfully generated ${outputFile.path}")
    }
}