package io.oxygenhub.android.ui.signin

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.DeviceAuth

import io.oxygenhub.android.api.DeviceCode

import io.oxygenhub.android.api.DeviceFlowException

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.normalizeHubUrl

import io.oxygenhub.android.api.userMessage

import io.oxygenhub.android.auth.Session

import io.oxygenhub.android.auth.SessionManager

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.Job

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.launch

sealed interface SignInState {

    /** Ready to start; [error] says why the last try ended. */

    data class Idle(val error: String? = null) : SignInState

    /** Asking the hub for a code. */

    data object Requesting : SignInState

    /** Showing the code while the user approves it on the web. */

    data class Approving(val code: DeviceCode) : SignInState

    /** Approved: checking the token and saving it. */

    data object Finishing : SignInState

}

class SignInViewModel(

    private val sessions: SessionManager,

    private val authFor: (hub: String) -> DeviceAuth,

    private val clientName: String,

    defaultHub: String,

) : ViewModel() {

    private val _hub = MutableStateFlow(sessions.lastHub ?: defaultHub)

    val hub: StateFlow<String> = _hub.asStateFlow()

    private val _state = MutableStateFlow<SignInState>(SignInState.Idle())

    val state: StateFlow<SignInState> = _state.asStateFlow()

    /** Why the last session ended, if the hub ended it. */

    val ended: StateFlow<String?> = sessions.ended

    private var job: Job? = null

    fun setHub(value: String) {

        _hub.value = value

        if (_state.value is SignInState.Idle) _state.value = SignInState.Idle()

    }

    fun signIn() {

        if (job?.isActive == true) return

        val hub = normalizeHubUrl(_hub.value)

        if (hub == null) {

            _state.value = SignInState.Idle("Enter the hub's HTTPS address, such as https://oxygenhub.io.")

            return

        }

        _hub.value = hub

        sessions.rememberHub(hub)

        sessions.dismissEnded()

        job = viewModelScope.launch {

            _state.value = SignInState.Requesting

            try {

                val auth = authFor(hub)

                val code = auth.requestCode(clientName)

                _state.value = SignInState.Approving(code)

                val grant = auth.awaitToken(code)

                _state.value = SignInState.Finishing

                val username = try {

                    auth.whoAmI(grant.accessToken).username

                } catch (e: HubException.Http) {

                    // Approved without user:read: the token's answer names the account too.

                    if (e.status == 403 && grant.username.isNotBlank()) grant.username else throw e

                }

                sessions.signedIn(Session(hub, username, grant.accessToken, grant.scopes))

                _state.value = SignInState.Idle()

            } catch (e: CancellationException) {

                throw e

            } catch (e: DeviceFlowException) {

                _state.value = SignInState.Idle(e.message)

            } catch (e: Exception) {

                _state.value = SignInState.Idle(e.userMessage())

            }

        }

    }

    /** Stops waiting. The code is left to expire on the hub (it has no call to withdraw one). */

    fun cancel() {

        job?.cancel()

        job = null

        _state.value = SignInState.Idle()

    }

}