interface ArticlesDataSource
class RemoteArticlesDataSource(
  val client: HttpClient,
  val baseUrl: BaseUrlProvider
) : ArticlesDataSource
class ArticlesRepository(val source: ArticlesDataSource)

object AppModule : Di.Module {
  override fun init() = Di.appScope {
    register { BaseUrlProvider("https://ivy-apps.com") }
    singleton { HttpClient(CIO) }
    autoWire(::RemoteArticlesDataSource)
    bind<ArticlesDataSource, RemoteArticlesDataSource>()
    autoWireSingleton(::ArticlesRepository)
  }
}

fun main() {
  Di.init(AppModule) // activates the AppModule (i.e. executes its code)
  val repo = Di.get<ArticlesRepository>() // ArticlesRepository instance created
}

class A
class B(val a: A)

Di.appScope {
  register { A() }
  register { B(a = Di.get()) }
}

// instances of B and its dependencies will be created
Di.get<B>() // instance 1 of B
Di.get<B>() // instance 2 of B

class Counter(var x: Int = 0) {
  init {
    print("Counter created. ")
  }
}

Di.appScope {
  singleton {
    Counter() // instance won't be created here 
  }
}

println(Di.get<Counter>().x) // Counter created. 0
Di.get<Counter>().x  
println(Di.get<Counter>().x) // 1

class A
class B(val a: A)
class C(val a: A, val b: B)
class D(val a: A, val b: B, val c: C)

Di.appScope {
  autoWire(::A)
  // equivalent to register { A() }
  autoWireSingleton(::B) // for singletons
  // equivalent to singleton { B(a = Di.get()) }
  autoWire(::C)
  // equivalent to register { C(Di.get(), Di.get()) }
  autoWire(::D)
  // equivalent to register { D(Di.get(), Di.get(), Di.get()) }
}
Di.get<D>() // instance of D created

interface Platform
class AndroidPlatform : Platform

Di.appScope {
  autoWire(::AndroidPlatform)
  bind<Platform, AndroidPlatform>()
  // equivalent to:
  // register<Platform> { AndroidPlatform() }
}
Di.get<Platform>() // AndroidPlatform instance

interface TimeFormatter
class H24TimeFormatter : TimeFormatter
class AmPmTimeFormatter : TimeFormatter

Di.appScope {
  autoWire(::H24TimeFormatter)
  autoWire(::AmPmTimeFormatter)
  bind<TimeFormatter, H24TimeFormatter>() // default
  bind<TimeFormatter, AmPmTimeFormatter>(named = "am-pm")
}

Di.get<TimeFormatter>() // H24TimeFormatter
Di.get<TimeFormatter>(named = "am-pm") // AmPmTimeFormatter

object DataModule : Di.Module {
  override fun init() = Di.appScope {
    singleton { HttpClient(CIO) }
    register { Json() }
    autoWire(::LoginService)
    autoWireSingleton(::AnalyticsService)
  }
}

object DomainModel : Di.Module {
  override fun init() = Di.app {
    autoWire(::LoginUseCaseImpl)
    bind<LoginUseCase, LoginUseCaseImpl>()
    autoWireSingleton(::SessionManager)
  }
}

Di.init(
  // Registers the following modules in the DI container
  DataModule,
  DomainModule
)
Di.get<LoginUseCase>() // instance of LoginUseCaseImpl created

data class UserInfo(val id: String, val name: String)

val UserScope = Di.newScope("user")
fun Di.userScope(block: Di.Scope.() -> Unit) = Di.inScope(UserScope, block) // helper function (optional)

suspend fun login() {
  val userInfo = loginInternally() // UserInfo("1", "John")
  Di.userScope {
    // Register dependencies for the lifecycle of a user
    singleton { userInfo }
  }
}

// Note: This function must be called only for logged-in users,
// otherwise Di.get() will throw an exception.
suspend fun dashboard() {
  // Use user related dependencies
  val userInfo = Di.get<UserInfo>()
  println("Hello, ${userInfo.name}") // "Hello, John"
}

suspend fun logout() {
  logoutInternally()
  // Frees all dependencies in UserScope
  Di.clear(UserScope) // UserInfo("1", "John") gets cleared
}

data class Screen(val name: String)
Di.appScope {
  register<String> { "Hello from app!" }
  autoWire(::Screen)
}
Di.featureScope {
  register<String> { "Hello from feature!" }
  autoWire(::Screen)
}

Di.get<String>(affinity = AppScope) // "Hello from app!"
Di.get<Screen>(affinity = AppScope) // Screen(name="Hello from app!")
Di.get<String>(affinity = FeatureScope) // "Hello from feature!"
Di.get<Screen>(affinity = FeatureScope) // Screen(name="Hello from feature!")

class ArticlesDataSource(val client: Lazy<HttpClient>) {
  suspend fun fetchLatest(): List<Article> = client.value.get("url") // .value gets an instance of the HttpClient
}
class ArticlesRepository(val source: ArticlesDataSource) {
  suspend fun fetchLatest(): List<Article> = source.fetchLatest()
}

Di.appScope {
  singleton { HttpClient(CIO) }
  register {
    // autoWire won't work because you need to explicitly call Di.getLazy() instead of Di.get()
    ArticlesDataSource(Di.getLazy())
  }
  autoWire(::ArticlesRepository)
}
val repo = Di.get<ArticlesRepository>() // HttpClient instance not created
repo.fetchLatest() // HttpClient instance created

class Container<T>(val value: T)

Di.appScope {
  register {
    // perceived as Container<*>, information for the Int generic type is lost
    Container<Int>(42)
  }
  register { Container<String>("hello") } // will override the factory for Container<Int>
}

val intContainer = Di.get<Container<Int>>() // Container<String>("hello") instance created.
intContainer.value // "hello" (String) even tough we requested Container<Int>!
val x = intContainer.value   1 // ClassCastException: class java.lang.String cannot be cast to class java.lang.Number
Di.get<Container<String>>() // Container<String>("hello") instance created

class Container<T>(val value: T)

@JvmInline
value class IntContainer(val value: Container<Int>)

@JvmInline
value class StringContainer(val value: Container<String>)

Di.appScope {
  register { IntContainer(Container(42)) }
  register { StringContainer(Container("hello")) }
}

Di.get<IntContainer>().value // Container<Int>(42) instance created
Di.get<StringContainer>().value // Container<String>("hello") instance created