package io.oxygenhub.android.secondfactor

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.PendingApproval

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.delay

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.launch

/**

 * Approvals waiting for this phone (#32, oxygenhub#356): looked for every

 * few seconds while the app is in front (and when an alert wakes it), one

 * shown at a time; answering signs with the phone's key.

 */

class ApprovalsViewModel(private val api: HubApi) : ViewModel() {

    private val _waiting = MutableStateFlow<PendingApproval?>(null)

    val waiting: StateFlow<PendingApproval?> = _waiting.asStateFlow()

    /** What the last answer came to, to say once. */

    private val _said = MutableStateFlow<String?>(null)

    val said: StateFlow<String?> = _said.asStateFlow()

    private val _busy = MutableStateFlow(false)

    val busy: StateFlow<Boolean> = _busy.asStateFlow()

    /** Answered or put aside here: not shown again. */

    private val done = mutableSetOf<String>()

    /** Look now. */

    suspend fun check() {

        val list = try {

            api.approvals()

        } catch (e: CancellationException) {

            throw e

        } catch (_: Exception) {

            return

        }

        if (!_busy.value) _waiting.value = list.firstOrNull { it.id !in done }

    }

    /** Look every [everyMs] for as long as the caller's scope lives (the app in front). */

    suspend fun watch(everyMs: Long = 3_000) {

        while (true) {

            check()

            delay(everyMs)

        }

    }

    /** Approve with [number]: [sign] signs the message after the system's prompt, or gives null when the person backs out. */

    fun approve(a: PendingApproval, number: Long, sign: suspend (ByteArray) -> ByteArray?) {

        viewModelScope.launch {

            _busy.value = true

            try {

                val signature = sign(ApprovalMessage.of(a.id, number, true))

                if (signature == null) {

                    _said.value = "Not approved: the phone's check did not finish."

                    return@launch

                }

                val state = api.answerApproval(a.id, true, number, signature.toHex()).state

                _said.value = when (state) {

                    "approved" -> if (a.kind == "signin") "Approved: the browser is signing in." else "Approved."

                    else -> "That was not the number the browser showed, so it was refused. Start again in the browser."

                }

                finish(a)

            } catch (e: CancellationException) {

                throw e

            } catch (e: HubException) {

                _said.value = e.message ?: "The hub did not take the answer."

                finish(a)

            } finally {

                _busy.value = false

            }

        }

    }

    /** Say no: the browser is told, and nobody gets in. */

    fun deny(a: PendingApproval) {

        viewModelScope.launch {

            _busy.value = true

            try {

                api.answerApproval(a.id, false, 0, "")

                _said.value = "Refused. If that was not you, change your password."

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                _said.value = "Refused here; the hub could not be told."

            } finally {

                _busy.value = false

                finish(a)

            }

        }

    }

    fun shown() {

        _said.value = null

    }

    private fun finish(a: PendingApproval) {

        done += a.id

        if (_waiting.value?.id == a.id) _waiting.value = null

    }

}