dependencies {
    implementation("io.github.maniramezan.kommon:sync:<version>")
    testImplementation("io.github.maniramezan.kommon:testing:<version>")
}

val engine = SyncEngine(cursorStore = roomCursorStore, telemetry = analyticsSyncTelemetry)

engine.sync(tasksAdapter)                              // one resource
engine.syncAll(listOf(tasksAdapter, decksAdapter))     // isolated: one failure doesn't stop the rest
    .onFailure { error -> logger.warning("Sync", "sync failed", error) }

data class LessonsState(val lessons: LoadingState<List<Lesson>> = LoadingState.Idle)

class LessonsViewModel(private val repo: LessonRepository) : BaseViewModel<LessonsState, LessonsEvent>(LessonsState()) {
    override fun onEvent(event: LessonsEvent) {
        when (event) {
            LessonsEvent.Load -> viewModelScope.launch {
                updateState { copy(lessons = LoadingState.Loading) }
                val lessons = loadingStateOf { repo.fetchLessons() }   // Loaded, or Failed(LoadingError)
                updateState { copy(lessons = lessons) }
            }
        }
    }
}

// Logging: plant once at startup, then inject the logger wherever a KommonLogger is needed.
TimberLogger.setup(isDebug = BuildConfig.DEBUG) { _, tag, message, error ->
    crashlytics.log("$tag: $message")
    error?.let(crashlytics::recordError)
}
val logger: KommonLogger = TimberLogger(tagPrefix = "MyApp")

val initializer = AuthSessionInitializer(authRepository, tokenProvider, sessionStore, logger, appScope)
initializer.start()   // warms the token before the first request, then tracks sign-in state

val message = error.authSignInErrorMessage(providerName = "Google")

val analytics: AnalyticsClient =
    CompositeAnalyticsClient(listOf(firebaseAnalytics, amplitudeAnalytics), logger)   // failures isolated per client

// Debug builds: capture every call for an in-app "recent events" screen.
val debugStore = InMemoryAnalyticsDebugStore(capacity = 200)
val debugAnalytics = AnalyticsCaptureClient(delegate = analytics, debugStore = debugStore)

// Spans: time a block, recording OK / ERROR (with error.type) automatically.
val otel = AnalyticsOpenTelemetryClient(analytics)
val words = otel.trace("fetch_words", SpanKind.CLIENT, mapOf("deck" to deckId)) { api.fetchWords(deckId) }

object AppConfigKeys {
    val NEW_ONBOARDING = ConfigKey.bool("new_onboarding", "Show the redesigned onboarding", default = false)
    val THEME = ConfigKey.string("theme", "UI theme", default = "system", allowedValues = listOf("light", "dark", "system"))
    val ALL_KEYS = listOf(NEW_ONBOARDING, THEME)
}

class FirebaseConfigClient(
    private val firebase: FirebaseRemoteConfig,
    overrides: LocalOverrideStore?,                     // remoteconfig-debug; pass null in release
) : RemoteConfigClient {
    private val resolver = ConfigResolver(AppConfigKeys.ALL_KEYS, overrides) { key -> firebase.readTyped(key) }

    override suspend fun fetchAndActivate() { firebase.fetchAndActivate().await() }
    override fun value(key: ConfigKey): ConfigValue = resolver.resolve(key).value   // override -> remote -> default
    override fun allValues(): List<ResolvedConfigEntry> = resolver.resolveAll()
}

LocalizedValueParser().parse("""{"en_us":"Hello","fr":"Bonjour"}""")   // "Hello"
LocalizedValueParser(listOf("fr")).parse("""{"en_us":"Hello","fr":"Bonjour"}""")   // "Bonjour"
JsonEncodedStringArrayParser.parseOrPassthrough("""["one","two"]""")   // "one\ntwo"

val analytics = RecordingAnalyticsClient()
val auth = FakeAuthRepository().apply { nextFailure = IOException("offline") }
val config = FakeRemoteConfigClient(keys = AppConfigKeys.ALL_KEYS).apply { set(AppConfigKeys.NEW_ONBOARDING, ConfigValue.Bool(true)) }
val logger = RecordingLogger()

// ...exercise the subject...
assertEquals(listOf("onboarding_started"), analytics.trackedEventNames)
assertTrue(logger.entriesAt(RecordingLogger.Level.ERROR).isEmpty())