repositories {
    maven {
        url = uri("https://jitpack.io")
    }
}

dependencies {
    implementation("cc.ekblad:4koma:1.0.1")
}

import cc.ekblad.toml.decode
import cc.ekblad.toml.tomlMapper
import java.nio.file.Path

data class Config(
    val settings: Settings,
    val user: List<User>
) {
    data class User(val name: String, val password: String)
    data class Settings(val maxLoginRetries: Int)
}

fun main() {
    // Create a TOML mapper without any custom configuration
    val mapper = tomlMapper { }

    // Read our config from file
    val tomlFile = Path.of("test.toml")
    val config = mapper.decode<Config>(tomlFile)
    println(config)
}

import cc.ekblad.toml.decodeWithDefaults
import cc.ekblad.toml.tomlMapper
import java.nio.file.Path

// We extend our config with extra fields (e.g. isAdmin, realmName and useTLS)
// which are not configured in our example TOML document.
data class Config(
    val settings: Settings,
    val user: List<User>
) {
    data class User(val name: String, val password: String, val isAdmin: Boolean)
    data class Settings(val maxLoginRetries: Int, val realmName: String, val useTLS: Boolean)
}

// Then, we define a default configuration, from which we will fill in any missing values when we read the config.
val defaultConfig = Config(
    settings = Config.Settings(
        maxLoginRetries = 5,
        realmName = "Example Realm",
        useTLS = true
    ),
    user = emptyList()
)

// We also define a default value for our user type, as we extended it with an extra field.
val defaultUser = Config.User(
    name = "default name",
    password = "default password",
    isAdmin = false
)

fun main() {
    // Create a TOML mapper with default fields configured for our Config.User type.
    val mapper = tomlMapper {
        default(defaultUser)
    }

    // Read our config from file, replacing any missing values with the defaults from defaultConfig and defaultUser.
    val tomlFile = Path.of("test.toml")
    val config = mapper.decodeWithDefaults<Config>(defaultConfig, tomlFile)
    println(config)
}

import cc.ekblad.toml.decode
import cc.ekblad.toml.tomlMapper
import java.nio.file.Path

data class Config(
    val settings: Settings,
    val users: List<User>
) {
    data class User(val userName: String, val password: String)
    data class Settings(val retriesAfterWhichToDisableLogin: Int)
}

fun main() {
    // Set up a mapper which maps "user", "name", etc. fields found in the TOML file onto fields "users", "userName",
    // etc. in their respective Kotlin data types
    val mapper = tomlMapper {
        mapping<Config>("user" to "users")
        mapping<Config.User>(
            "name" to "userName",
            "password" to "userSecret"
        )
        mapping<Config.Settings>(
            "maxLoginRetries" to "retriesAfterWhichToDisableLogin"
        )
    }

    // Read our config from file, using our custom field name mappings
    val tomlFile = Path.of("test.toml")
    val config = mapper.decode<Config>(tomlFile)
    println(config)
}

import cc.ekblad.toml.decode
import cc.ekblad.toml.model.TomlValue
import cc.ekblad.toml.tomlMapper
import java.nio.file.Path

fun main() {
    // Set up a mapper which replaces any string appearing in the list of bad words with a number of asterisks
    val listOfBadWords = listOf("poop", "darn", "blockchain")
    val mapper = tomlMapper {
        decoder { it: TomlValue.String ->
            if (it.value in listOfBadWords) {
                // We don't allow any swearing in our strings!
                it.value.map { '*' }.joinToString("")
            } else {
                it.value
            }
        }
    }

    // Read an arbitrary TOML document from file, using our custom string decoder
    val tomlFile = Path.of("test.toml")
    val config = mapper.decode<Map<String, Any>>(tomlFile)
    println(config)
}