implementation("io.sellmair:evas:1.0.0-beta02")

implementation("io.sellmair:evas-compose:1.0.0-beta02")

val events = Events() // <- create new instance
val states = States() // <- create new instance
withContext(events + states) {

}

val events = Events() // <- create new instance
val states = States() // <- create new instance

@Composable
fun App() {
    installEvas(events, states) {
        MainPage()
    }
}

object LogoutEvent: Event

data class LoginEvent(val userName: String, val token: String): Event

/**
 * Use 'collectEvents' to subscribe to all events of type [LogoutEvent]
 */
suspend fun listenForLogout() = collectEvents<LogoutEvent> {
    println("User logged out")
}

/**
 * Use 'collectEvents' to subscribe to all events of type [LoginEvent]
 */
suspend fun listenForLogin() = collectEvents<LoginEvent> { event ->
    println("User: ${event.userName} logged in")
}

/**
 * Example function 'login' which will pretend to login a user and then
 * emits a [LoginEvent]
 */
suspend fun login(userName: String, password: String) {
    val token = httpClient().login(userName, password) ?: return
    LoginEvent(userName, token).emit()
                    //          ^
                    // emit the event and suspend until
                    // All listeners have finished processing this event
}

/**
 * Example function 'logout' which will pretend to delete user data and then
 * emits a [LogoutEvent]
 */
suspend fun logout() {
    deleteUserData()
    LogoutEvent.emit()
    //          ^
    // emit the event and suspend until
    // All listeners have finished processing this event
}

/**
 * Pretend: Our application cares about the number of 'clicks' the user has performed.
 * We define our [ClickCounterState] here which holds this information.
 */
data class ClickCounterState(val count: Int) : State {
    /*
    Using the 'companion object' as Key, defining '0' as the default state
     */
    companion object Key : State.Key<ClickCounterState> {
        override val default: ClickCounterState = ClickCounterState(count = 0)
    }
}

/**
 * Launching the coroutine, which will produce the [ClickCounterState].
 * It will collect the [ClickEvent]s and update the [ClickCounterState] by incrementing for each click it receives.
 */
fun CoroutineScope.launchClickCounterState() = launchState(ClickCounterState) {
    var count = 0
    collectEvents<ClickEvent> {
        count++
        ClickCounterState(count).emit()
        //                        ^
        //                 Emit State Update
    }
}

/**
 * Imaginary 'onClick' method which will send the [ClickEvent] to the application
 */
suspend fun onClick() {
    ClickEvent.emit()
    //          ^
    // emit event and wait for all listening coroutines to finish
}

fun CoroutineScope.launchClickCounterPrinter() = launch {
    ClickCounterState.collect { state ->
        println("Click Count: ${state.count}")
    }
}

/**
* Defining an imaginary [UserLoginState] which knows about if the User is currently logged into our
* application (or currently attempting to)
*
* In this example 'null' is chosen as the default state, representing that it is "unknown"
*/
sealed class UserLoginState : State {
   companion object Key : State.Key<UserLoginState?> {
       override val default: UserLoginState? = null
   }

   data object LoggedOut : UserLoginState()
   data object LoggingIn : UserLoginState()
   data class LoggedIn(val userId: UserId) : UserLoginState()
}

/**
* Launching the [UserLoginState] producing coroutine:
* This coroutine will:
* - Try to find the currently logged-in user data from a local database
* - Handle [LoginRequest] events and tries to log a user in, if received
*/
fun CoroutineScope.launchUserLoginState() = launchState(UserLoginState) {
   val user = getUserFromDatabase()
   if (user != null) {
       LoggedIn(user.userId).emit()
       return@launchState
   }

   /**
    * Oh, oh: User wasn't found in the local database:
    * We're setting the state to [LoggedOut]
    */
   LoggedOut.emit()

   /**
    * From here on, we collect all [LoginRequest] events and try to log the user in, by hitting
    * the network.
    */
   collectEvents<LoginRequest> { request ->
       LoggingIn.emit()

       val response = sendLoginRequestToServer(request.user, request.password)
       if (response.isSuccess) {
           LoggedIn(response.userId).emit()
       } else {
           LoggedOut.emit()
       }
   }
}

@Composable
fun App() {
   val loginState = UserLoginState.composeValue()
   //                                   ^
   //         Will trigger re-composition if the state changes

   when (loginState) {
       is LoggedOut -> ShowLoginScreen()
       is LoggingIn -> ShowLoginSpinner()
       is LoggedIn -> ShowMainScreen()
       null -> Unit
   }
}