Value Types

open class Value<T : Any>(
    val name: String,
    val aliases: List<String> = emptyList(),
    private var defaultValue: T,
    val valueType: ValueType,
    var independentDescription: Boolean = false
)

val enabled by boolean("Enabled", true)

fun boolean(name: String, default: Boolean): BooleanValue

val count by int("Count", 10, 1..100)

fun int(name: String, default: Int, range: IntRange): IntValue

val speed by float("Speed", 1.0f, 0.1f..5.0f)

fun float(name: String, default: Float, range: ClosedFloatingPointRange<Float>): FloatValue

val range by floatRange("Range", 3.0f..5.0f, 0.0f..10.0f)

fun floatRange(
    name: String,
    default: ClosedFloatingPointRange<Float>,
    range: ClosedFloatingPointRange<Float>
): RangedValue<Float>

val message by text("Message", "Hello World")

fun text(name: String, default: String): TextValue

val mode by choices("Mode", arrayOf("Fast", "Slow", "Medium"), "Fast")

fun choices(name: String, choices: Array<String>, default: String): ChoiceValue

val blocks by listValue("Blocks", mutableListOf<Block>())

fun <T> listValue(name: String, default: MutableList<T>): ListValue<T>

val curve by curve("Curve", arrayOf(
    Point(0.0, 0.0),
    Point(1.0, 1.0)
))

fun curve(name: String, default: Array<Point>): CurveValue

val targetBlock by block("Block", Blocks.STONE)

fun block(name: String, default: Block): BlockValue

val color by color("Color", Color4b(255, 0, 0, 255))

fun color(name: String, default: Color4b): ColorValue

val keybind by bind("Key", InputBind(
    type = InputConstants.Type.KEYSYM,
    value = GLFW.GLFW_KEY_R,
    action = InputBind.BindAction.TOGGLE
))

fun bind(name: String, default: InputBind): BindValue

private val modes = choices("Mode",
    ModeA,
    ModeB,
    ModeC
)

object ModeA : ChoiceConfigurable(this, "ModeA") {
    val speed by float("Speed", 1.0f, 0.1f..5.0f)
    val ticks by int("Ticks", 20, 1..100)
}

object ModeB : ChoiceConfigurable(this, "ModeB") {
    val power by float("Power", 2.0f, 0.1f..10.0f)
}

fun choices(name: String, vararg choices: ChoiceConfigurable): ModeValue

val enabled by boolean("Enabled", true)
val speed by float("Speed", 1.0f, 0.1f..5.0f)
    .listen { enabled } // Only visible when enabled is true

val mode by choices("Mode", modes, "Fast")
    .onChange { newValue ->
        // React to value change
        println("Mode changed to: $newValue")
        newValue // Must return value
    }

val range by float("Range", 3.0f, 1.0f..6.0f)
    .onChanged { newValue ->
        // Called after value changed
        updateRangeDisplay(newValue)
    }

val internal by boolean("Internal", true)
    .notAnOption() // Hidden from REST API

val temporary by text("Temp", "")
    .doNotIncludeAlways() // Never saved to config

val constant by int("Version", 1)
    .immutable() // Cannot be changed

val position by vec3("Position", Vec3(0.0, 64.0, 0.0))

val configFile by file("Config", File("config.json"))

val blocks by multiChoice("Blocks", mutableListOf("Stone", "Dirt"))

object MyModule : ClientModule(...) {
    val tree by tree("Advanced") {
        val option1 by boolean("Option1", true)
        val option2 by float("Option2", 1.0f, 0.1f..5.0f)
    }
}

val autoBlock by toggleable("AutoBlock", false) {
    val blockDelay by int("Delay", 50, 0..500)
    val onlyWhileSprinting by boolean("OnlyWhileSprinting", false)
}

object ModuleKillAura : ClientModule(
    name = "KillAura",
    category = ModuleCategories.COMBAT
) {
    // Range settings
    val range by floatRange("Range", 3.0f..4.2f, 1.0f..6.0f)
    
    // Target selection
    val priority by choices("Priority", 
        arrayOf("Distance", "Health", "Direction", "Armor"),
        "Distance"
    )
    
    // Attack settings
    val maxCPS by int("MaxCPS", 12, 1..20)
    val minCPS by int("MinCPS", 8, 1..20)
        .listen { it <= maxCPS }
    
    // Rotation settings  
    val rotations by toggleable("Rotations", true) {
        val speed by float("Speed", 2.0f, 0.1f..180.0f)
        val smoothing by boolean("Smoothing", true)
    }
    
    // Mode selection with sub-settings
    private val modes = choices("Mode", Single, Multi)
    
    object Single : ChoiceConfigurable(this, "Single") {
        val switchDelay by int("SwitchDelay", 15, 1..40)
    }
    
    object Multi : ChoiceConfigurable(this, "Multi") {
        val maxTargets by int("MaxTargets", 3, 1..10)
    }
}

val useCustomSpeed by boolean("UseCustomSpeed", false)
val customSpeed by float("CustomSpeed", 1.0f, 0.1f..5.0f)
    .listen { useCustomSpeed } // Only show when enabled

val mode by choices("Mode", arrayOf("Fast", "Slow"), "Fast")
val fastModeBoost by float("Boost", 2.0f, 1.0f..5.0f)
    .listen { mode == "Fast" } // Only for Fast mode

val autoRespawn by boolean("AutoRespawn", true)
    .onChanged { enabled ->
        if (enabled && player.health <= 0) {
            player.respawn()
        }
    }

val theme by choices("Theme", arrayOf("Dark", "Light"), "Dark")
    .onChange { newTheme ->
        applyTheme(newTheme)
        newTheme
    }