sourceSets {
    commonMain.dependencies {
        implementation("io.github.ktomek:initspark:1.0.0") // Replace with latest version
    }
}

dependencies {
    implementation("io.github.ktomek:initspark:1.0.0")
}

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

dependencies {
    implementation("com.github.ktomek:initspark:<version>")
}

class DatabaseSpark @Inject constructor(...) : Spark {
    override suspend fun execute() { /* initialize database */ }
}

val sparks = setOf(
    DatabaseSpark(),
    NotificationSpark(),
    AnalyticsSpark(),
    /* ... */
)

val config = buildSparks(sparks) {
    // Sequential, must complete before next spark starts
    await { System.loadLibrary("crypto-lib") }
    await<LoggerSpark>()
    await<ActivityLifecycleSpark>()

    val ioContext = Dispatchers.IO
    val coreDeps = setOf(Key("Database"))

    // Parallel, completion is tracked
    async<DatabaseSpark>(
        key = "Database".asKey(),
        context = ioContext
    )
    async<NotificationSpark>(
        context = ioContext,
        needs = coreDeps,
        policy = SparkPolicy(importance = SparkImportance.OPTIONAL)
    )
    async<AnalyticsSpark>(
        context = ioContext,
        needs = coreDeps,
        policy = SparkPolicy(
            retry = RetryPolicy(
                retryCount = 3,
                backoff = Backoff.Exponential(initialDelayMillis = 200)
            )
        )
    )

    // Parallel, fire-and-forget (not tracked)
    spark<ConsentManagerSpark>(context = ioContext, needs = coreDeps)
}

val initSpark = InitSpark(config, CoroutineScope(Dispatchers.Default))

// Suspending version (preferred)
initSpark.initialize()

// Blocking version (for Java interop or legacy code)
initSpark.initializeBlocking()

// String-backed key (default)
"Database".asKey()           // or Key("Database")

// Custom key type (recommended for robustness)
data object DatabaseKey : Key
enum class AppKey : Key { DATABASE, ANALYTICS }

// CRITICAL (default): failure throws and halts initialization
async<DatabaseSpark>(policy = SparkPolicy(importance = SparkImportance.CRITICAL))

// OPTIONAL: failure is logged and emitted as a SparkEvent.Failed, but other sparks continue
async<AnalyticsSpark>(policy = SparkPolicy(importance = SparkImportance.OPTIONAL))

val policy = SparkPolicy(
    retry = RetryPolicy(
        retryCount = 3,
        backoff = Backoff.Exponential(initialDelayMillis = 100L, factor = 2.0)
    )
)

launch {
    initSpark.events.collect { event ->
        when (event) {
            is SparkEvent.Started   -> log("▶ ${event.key} started")
            is SparkEvent.Completed -> log("✅ ${event.key} done in ${event.duration}")
            is SparkEvent.Failed    -> log("❌ ${event.key} failed: ${event.error}")
            is SparkEvent.Retry     -> log("🔁 ${event.key} retry #${event.retryCount}")
        }
    }
}

// Suspend until all TRACKABLE sparks are done
initSpark.waitUntilTrackableInitialized()

// Suspend until ALL sparks (including fire-and-forget) are done
initSpark.waitUntilInitialized()

// Or observe via StateFlow
initSpark.isTrackableInitialized.collect { ready -> if (ready) onReady() }
initSpark.isInitialized.collect { ready -> if (ready) onFullyReady() }

initSpark.waitUntilInitialized()

with(initSpark.timing) {
    // Per-spark durations
    allDurations().forEach { (declaration, duration) ->
        Timber.d("Spark '${declaration.key}' [${declaration.type}] took $duration")
    }

    // Cumulative total (sum of all individual durations)
    Timber.d("Sum of all durations: ${sumOfDurations()}")
    Timber.d("Sum by type: ${sumOfDurationsByType()}")

    // Wall-clock window (first start → last finish)
    Timber.d("Total wall-clock time: ${executionDelta()}")
    Timber.d("Wall-clock by type: ${executionDeltaByType()}")
}