import "go/format"

src := goSourceCode() // []byte だか string だか
format.Source(src)

val src = kotlinSourceCode()
val formatted = Ktlint.format(src)

task ktlint(type: JavaExec, group: LifecycleBasePlugin.VERIFICATION_GROUP) {
  description = "Check Kotlin code style."
  classpath = configurations.ktlint
  main = 'com.pinterest.ktlint.Main'
  args '*/src/**/*.kt'
}

fun main(args: Array<String>) {
    val ktlintCommand = KtlintCommandLine()
    // ...

    @Option(
        names = ["--format", "-F"],
        description = ["Fix any deviations from the code style"]
    )
    private var format: Boolean = false

        if (format) {
            val formattedFileContent = try {
                formatFile(
                    fileName,
                    fileContent,
                    ruleSetProviders.map { it.value.get() },
                    userData,
                    editorConfigPath,
                    debug
                ) { err, corrected ->
            // ...

internal fun formatFile(
    fileName: String,
    fileContents: String,
    ruleSets: Iterable<RuleSet>,
    userData: Map<String, String>,
    editorConfigPath: String?,
    debug: Boolean,
    cb: (e: LintError, corrected: Boolean) -> Unit
): String =
    KtLint.format(
        KtLint.Params(
            fileName = fileName,
            text = fileContents,
            ruleSets = ruleSets,
            userData = userData,
            script = !fileName.endsWith(".kt", ignoreCase = true),
            editorConfigPath = editorConfigPath,
            cb = cb,
            debug = debug
        )
    )

    public fun format(params: Params): String {
        // ...

    /**
     * @param fileName path of file to lint/format
     * @param text Contents of file to lint/format
     * @param ruleSets a collection of "RuleSet"s used to validate source
     * @param userData Map of user options
     * @param cb callback invoked for each lint error
     * @param script true if this is a Kotlin script file
     * @param editorConfigPath optional path of the .editorconfig file (otherwise will use working directory)
     * @param debug True if invoked with the --debug flag
     */
    public data class Params(
        val fileName: String? = null,
        val text: String,
        val ruleSets: Iterable<RuleSet>,
        val userData: Map<String, String> = emptyMap(),
        val cb: (e: LintError, corrected: Boolean) -> Unit,
        val script: Boolean = false,
        val editorConfigPath: String? = null,
        val debug: Boolean = false
    ) {

    fun run() {
        failOnOldRulesetProviderUsage()

        val start = System.currentTimeMillis()

        val ruleSetProviders = rulesets.loadRulesets(experimental, debug)
        val reporter = loadReporter()
        val userData = listOfNotNull(
            "android" to android.toString(),
            if (disabledRules.isNotBlank()) "disabled_rules" to disabledRules else null
        ).toMap()

        reporter.beforeAll()
        if (stdin) {
            lintStdin(ruleSetProviders, userData, reporter)
        } else {
            lintFiles(ruleSetProviders, userData, reporter)
        }
        // ...

    private fun loadRulesets(externalRulesetsJarPaths: List<String>) = ServiceLoader
        .load(
            RuleSetProvider::class.java,
            URLClassLoader(externalRulesetsJarPaths.toFilesURIList().toTypedArray())
        )
        // ...

class StandardRuleSetProvider : RuleSetProvider {
    // ...

package com.example

import com.pinterest.ktlint.core.KtLint
import com.pinterest.ktlint.ruleset.standard.StandardRuleSetProvider

fun main() {
    val code = """
        class Foo(
        val id : String, val age : Int,
        val name:String )
        {
            fun foo() : Boolean { return name.isEmpty()
        }
        }
    """.trimIndent()

    val ruleSets = setOf(
        StandardRuleSetProvider().get()
    )
    val formatted = KtLint.format(
        KtLint.Params(
            fileName = null,
            text = code,
            ruleSets = ruleSets,
            userData = emptyMap(),
            cb = { _, _ -> run {} },
            script = false,
            editorConfigPath = null,
            debug = false
        )
    )

    println(formatted)
}

// Output:
//
// class Foo(
//     val id: String,
//     val age: Int,
//     val name: String
// ) {
//     fun foo(): Boolean {
//         return name.isEmpty()
//     }
// }