Winter

dependencies {
    // Core
    implementation("io.jentz.winter:winter:0.10.0-alpha1")
    // Property delegates for classes that can't use constructor injection
    implementation("io.jentz.winter:winter-delegate:0.10.0-alpha1")
    // AndroidX support (includes winter-delegate)
    implementation("io.jentz.winter:winter-androidx:0.10.0-alpha1")
    // JUnit 4 and JUnit 5 support
    testImplementation("io.jentz.winter:winter-junit4:0.10.0-alpha1")
    testImplementation("io.jentz.winter:winter-junit5:0.10.0-alpha1")
}

repositories {
    maven("https://central.sonatype.com/repository/maven-snapshots/")
}

interface Pump
class RotaryPump : Pump
class Heater
class CoffeeMaker(val heater: Heater, val pump: Pump)

val coffeeComponent = component {
    singleton { Heater() }
    singleton<Pump> { RotaryPump() }
    prototype { CoffeeMaker(instance(), instance()) }
}

val graph = coffeeComponent.createGraph()
val coffeeMaker: CoffeeMaker = graph.instance()

// an instance, the type is inferred from the declaration or given explicitly
val heater: Heater = graph.instance()
val pump = graph.instance<Pump>()

// an optional instance, null if Grinder isn't registered
val grinder: Grinder? = graph.instance()

// a function that resolves the instance on every call
val heaterProvider: () -> Heater = graph.provider()

// resolved on first access
val lazyHeater: Lazy<Heater> = graph.lazyInstance()

// call a constructor with arguments from the graph
val coffeeMaker = graph.new(::CoffeeMaker)

val Session = qualifier("session")

val appComponent = component {
    singleton { HttpClient() }

    subcomponent(Session) {
        singleton { LoginController(instance(), instance()) }
    }
}

val appGraph = appComponent.createGraph()

// A subgraph can be extended with a builder block, e.g. to add runtime values.
val sessionGraph = appGraph.createSubgraph(Session) {
    constant(User("ada"))
}

val controller: LoginController = sessionGraph.instance()

sessionGraph.close()
appGraph.close()

CoffeeShop.component {
    singleton { Heater() }
    singleton<Pump> { RotaryPump() }
    prototype { CoffeeMaker(instance(), instance()) }

    subcomponent(Session) {
        singleton { ProfileController(instance()) }
    }
}

val appGraph: Graph = CoffeeShop.openGraph()
// anywhere else in the application
val coffeeMaker: CoffeeMaker = CoffeeShop.graph.instance()

// e.g. when the application terminates
CoffeeShop.closeGraph()

object CoffeeShop : WinterApplication()

class CoffeeScreen {
    private val injector by CoffeeShop

    // retrieved when inject() is called
    private val coffeeMaker: CoffeeMaker by injector()
    // retrieved on first access
    private val heater: Heater by injector.lazyInstance()
    // resolves a new instance on every call
    private val pumpProvider: () -> Pump by injector.provider()
    // maps the instance
    private val pumpName: String by injector<Pump>().map { it.javaClass.simpleName }

    fun onCreate() {
        injector.inject()
    }
}

CoffeeShop.component {
    singleton { Heater() }
    singleton<Pump> { RotaryPump() }
    singleton { CoffeeMaker(instance(), instance()) }

    // OrderScreen gets its dependencies from a new screen subgraph
    graphResolver<OrderScreen> { appGraph, screen ->
        appGraph.createSubgraph(ScreenScope)
    }

    subcomponent(ScreenScope) {
        singleton { OrderList(instance()) }
    }
}

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        Winter.component {
            singletonOf(::GitHubApi)

            // creates the view model and activity subgraphs for RepoListActivity
            activityGraphResolver<RepoListActivity>()

            // survives configuration changes and is closed when the activity is finished
            subcomponent(ViewModelScope) {
                singletonOf(::RepoListViewModel)

                // created for every activity instance and closed when it is destroyed
                subcomponent(ActivityScope) {
                    singleton { ImageLoader(instance()) }
                }
            }
        }

        Winter.openGraph {
            // registers the Application, its Context and the process lifecycle
            application(this@MyApplication)
        }
    }
}

class RepoListActivity : ComponentActivity() {
    private val injector by Winter
    private val viewModel: RepoListViewModel by injector()
    private val imageLoader: ImageLoader by injector()

    override fun onCreate(savedInstanceState: Bundle?) {
        injector.inject()
        super.onCreate(savedInstanceState)
    }
}

activityGraphResolver<RepoDetailActivity>(
    // called once per view model subgraph, don't keep a reference to the activity here
    viewModelScope = { activity ->
        constant(RepoId(activity.intent.getStringExtra("repoId")!!))
    },
    // called for every activity instance
    activityScope = { activity ->
        constant<Intent>(activity.intent)
    }
)

val uninstall = CoffeeShop.plugin {
    // derive the component of every new graph with the qualifier Session
    extend(Session) {
        constant(User("guest"))
    }
    // called for every new graph
    withNewGraph { }
    // called for every graph that gets closed
    withClosingGraph { }
    // called for every new instance of Heater
    withNewInstance<Heater> { scope, heater ->
    }
}

// later
uninstall()

val graph = graph {
    singleton { Parent(instance()) }
    singleton { Child() }
        .onPostConstruct { it.parent = instance() }
}