package io.oxygenhub.android.ui.inbox

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.Inbox

import io.oxygenhub.android.api.Notification

import io.oxygenhub.android.api.userMessage

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.common.load

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.flow.update

import kotlinx.coroutines.launch

/**

 * The inbox, shared by the inbox screen, the dashboard's unread count and

 * the navigation badge. Marking read shows at once and is put back if the

 * hub refuses it.

 */

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

    private val _state = MutableStateFlow<Load<Inbox>>(Load.Loading)

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

    /** A one-line message for a snackbar (a failed mark-read). */

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

    val message: StateFlow<String?> = _message.asStateFlow()

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.inbox(LIMIT) }

    }

    /** Marks [n] read (if it is not already); the caller then opens its page. */

    fun markRead(n: Notification) {

        if (n.read) return

        val before = _state.value

        edit { inbox ->

            inbox.copy(

                unread = (inbox.unread - 1).coerceAtLeast(0),

                items = inbox.items.map { if (it.id == n.id) it.copy(read = true) else it },

            )

        }

        viewModelScope.launch {

            try {

                api.markRead(n.id)

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                _state.value = before

                _message.value = "Couldn't mark it read: ${e.userMessage()}"

            }

        }

    }

    fun markAllRead() {

        val before = _state.value

        if ((before.valueOrNull?.unread ?: 0) == 0L) return

        edit { inbox -> inbox.copy(unread = 0, items = inbox.items.map { it.copy(read = true) }) }

        viewModelScope.launch {

            try {

                api.markAllRead()

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                _state.value = before

                _message.value = "Couldn't mark the inbox read: ${e.userMessage()}"

            }

        }

    }

    fun messageShown() {

        _message.value = null

    }

    private fun edit(change: (Inbox) -> Inbox) {

        _state.update { s -> if (s is Load.Ready) s.copy(value = change(s.value)) else s }

    }

    companion object {

        const val LIMIT = 100

    }

}