// In your build.gradle.kts
dependencies {
    // Core (required)
    implementation("io.github.mlmgames:kmp-settings-core:<version>")
    
    // KSP processor (required for code generation)
    ksp("io.github.mlmgames:kmp-settings-ksp:<version>")
    
    // Compose UI (optional)
    implementation("io.github.mlmgames:kmp-settings-ui-compose:<version>")
}

import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import io.github.mlmgames.settings.core.SettingsRepository
import io.github.mlmgames.settings.core.annotations.*
import io.github.mlmgames.settings.core.types.*
import io.github.mlmgames.settings.ui.AutoSettingsScreen
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.stateIn

// Define categories
@CategoryDefinition(order = 0)
object General

@CategoryDefinition(order = 1)
object Appearance

// Define settings data class
@kotlinx.serialization.Serializable
data class AppSettings(
    @Setting(
        title = "Dark Mode",
        category = Appearance::class,
        type = Toggle::class
    )
    val darkMode: Boolean = false,
    
    @Setting(
        title = "Font Size",
        category = Appearance::class,
        type = Slider::class,
        min = 12f,
        max = 24f,
        step = 1f
    )
    val fontSize: Float = 16f,
    
    @Setting(
        title = "Language",
        category = General::class,
        type = Dropdown::class,
        options = ["English", "Spanish", "French"]
    )
    val language: Int = 0,
    
    // Persisted but not shown in UI
    @Persisted
    val lastSyncTime: Long = 0L
)

class SettingsViewModel(
    dataStore: DataStore<Preferences>,
) : ViewModel() {
    private val repository = SettingsRepository(
        dataStore = dataStore,
        schema = AppSettingsSchema,
    )
    
    val settings = repository.flow.stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(),
        initialValue = AppSettingsSchema.default
    )
    
    fun updateSetting(name: String, value: Any?) {
        viewModelScope.launch {
            repository.set(name, value)
        }
    }
}

@Composable
fun SettingsScreen(viewModel: SettingsViewModel = viewModel()) {
    val settings by viewModel.settings.collectAsState()
    
    AutoSettingsScreen(
        schema = AppSettingsSchema,
        value = settings,
        onSet = viewModel::updateSetting
    )
}

@Setting(
    titleKey = "settings.appearance.dark_mode",
    descriptionKey = "settings.appearance.dark_mode.description",
    optionsKey = "settings.appearance.theme.options",
    category = Appearance::class,
    type = Toggle::class,
)
val darkMode: Boolean = false

ProvideStringResources(
    AndroidStringResourceProvider(context) { key ->
        when (key) {
            "settings.appearance.dark_mode" -> R.string.dark_mode
            else -> 0
        }
    }
) {
    AutoSettingsScreen(/* ... */)
}

@Setting(
    title = "Android-only Feature",
    category = General::class,
    type = Toggle::class,
    platforms = [SettingPlatform.ANDROID]  // Hidden on iOS/Desktop
)
val androidFeature: Boolean = false

@Setting(
    title = "Enable Notifications",
    category = General::class,
    type = Toggle::class
)
val notificationsEnabled: Boolean = false

@Setting(
    title = "Notification Sound",
    category = General::class,
    type = Toggle::class,
    dependsOn = "notificationsEnabled"  // Disabled when above is false
)
val notificationSound: Boolean = true

MigrationManager(dataStore, currentVersion = 3, schema = AppSettingsSchema)
    .addValueTransform(
        fromVersion = 2,
        toVersion = 3,
        oldKey = "block_media_previews",
        oldKind = PreferenceKind.BOOLEAN,
        newField = "mediaPreviews",
    ) { blocked -> if (blocked == true) "Off" else "On" }

val sync = SettingsRemoteSync(
    repository = settingsRepository,
    schema = AppSettingsSchema,
    store = accountDataStore,
    bindings = listOf(RemoteBinding(field = "mediaPreviews")),
    pullPolicy = RemotePullPolicy.ONCE_PER_ATTACH,
)

LaunchedEffect(activeId) { sync.attach(this) }
DisposableEffect(Unit) { onDispose { sync.detach() } }

AutoSettingsScreen(
    schema = AppSettingsSchema,
    value = settings,
    onSet = viewModel::updateSetting,
    remoteStates = sync.states.collectAsState().value,
)

@Setting(
    title = "Server URL",
    category = General::class,
    type = TextInput::class
)
@Pattern("^https?://.*")  // Regex validation
val serverUrl: String = "https://api.example.com"

@Setting(
    title = "Delete All Data",
    category = General::class,
    type = Button::class
)
@RequiresConfirmation(
    title = "Confirm Deletion",
    message = "This cannot be undone. Continue?",
    isDangerous = true
)
@ActionHandler(DeleteDataAction::class)
val deleteData: Unit = Unit

val backupManager = SettingsBackupManager(
    dataStore = dataStore,
    schema = AppSettingsSchema,
    appId = "com.example.myapp",
    schemaVersion = 1
)

// Export
when (val result = backupManager.export()) {
    is ExportResult.Success -> saveToFile(result.json)
    is ExportResult.Error -> showError(result.message)
}

// Import with validation
val jsonString = readFromFile()
when (val result = backupManager.import(jsonString)) {
    is ImportResult.Success -> showSuccess("Imported ${result.appliedCount} settings")
    is ImportResult.Error -> when (result.error) {
        ImportError.APP_MISMATCH -> showError("Wrong app backup")
        ImportError.VERSION_TOO_NEW -> showError("Backup from newer version")
        ImportError.CHECKSUM_MISMATCH -> showError("Corrupted backup file")
        else -> showError(result.message)
    }
}

AutoSettingsScreen(
    schema = AppSettingsSchema,
    value = settings,
    onSet = viewModel::updateSetting,
    customTypeHandlers = listOf(
        CustomTypeHandler(
            typeClass = ColorPicker::class,
            render = { field, meta, value, enabled, onSet ->
                val color = (field as SettingField<AppSettings, String>).get(value)
                ColorPickerButton(
                    color = color,
                    enabled = enabled,
                    onColorSelected = { onSet(field.name, it) }
                )
            }
        )
    )
)