package io.oxygenhub.android.ui.dashboard

import androidx.lifecycle.ViewModel

import io.oxygenhub.android.api.Avatar

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.IssueBrief

import io.oxygenhub.android.api.Repository

import io.oxygenhub.android.api.User

import io.oxygenhub.android.api.UserSky

import io.oxygenhub.android.api.UserProposals

import io.oxygenhub.android.auth.Session

import io.oxygenhub.android.ui.common.Avatars

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.async

import kotlinx.coroutines.coroutineScope

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import java.util.Calendar

data class Dashboard(

    val greeting: String,

    /** The account, or null when the token may not read it (no `user:read`). */

    val user: User?,

    /** The account's avatar (#13), or null while the hub has none this app can draw. */

    val avatar: Avatar? = null,

    /** Whose avatar: the signed-in account's name. */

    val username: String = "",

    /** Proposals to review and the account's own (#18); null when the hub cannot say. */

    val proposals: UserProposals? = null,

    /** Open issues assigned to the account (#31); null when the hub cannot say. */

    val assigned: List<IssueBrief>? = null,

    /** The newest-updated repositories: the user's own, or everyone's when they own none. */

    val recent: List<Repository>,

    val recentAreYours: Boolean,

    val repositoryCount: Int,

    /** Your sky (#23), the backdrop's data; null when the hub cannot give it. */

    val sky: UserSky? = null,

)

class DashboardViewModel(

    private val api: HubApi,

    private val session: Session,

    private val hourOfDay: () -> Int = { Calendar.getInstance().get(Calendar.HOUR_OF_DAY) },

) : ViewModel() {

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { fetch() }

    }

    /**

     * The dashboard is in front again (back from a proposal, or the app

     * brought back): fetch afresh, keeping what shows meanwhile, so a

     * proposal just landed no longer shows as open (#35). Not while the

     * first load is still on its way.

     */

    fun resumed() {

        if (_state.value !is Load.Loading) refresh()

    }

    private suspend fun fetch(): Dashboard = coroutineScope {

        // The account is a nicety (a display name); the repositories are the page.

        val user = async {

            try {

                api.user()

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                null

            }

        }

        // As are the proposals: a hub without the call shows none.

        val proposals = async {

            try {

                api.userProposals()

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                null

            }

        }

        // As are the issues assigned to it (a hub before oxygenhub#359 answers 404).

        val assigned = async {

            try {

                api.userIssues()

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                null

            }

        }

        // As is the sky behind it all.

        val sky = async {

            try {

                api.userSky()

            } catch (e: CancellationException) {

                throw e

            } catch (_: Exception) {

                null

            }

        }

        // As is the avatar: its failure leaves the last one, or the initial.

        val avatar = async { Avatars.load(api, session.username) }

        val repos = api.repositories()

        val me = user.await()

        val username = me?.username ?: session.username

        val mine = repos.filter { it.owner == username }

        val pool = mine.ifEmpty { repos }

        Dashboard(

            greeting = greeting(hourOfDay(), me?.shownName ?: session.username),

            user = me,

            avatar = avatar.await(),

            username = username,

            proposals = proposals.await(),

            assigned = assigned.await(),

            recent = pool.sortedByDescending { it.updatedMs }.take(RECENT),

            recentAreYours = mine.isNotEmpty(),

            repositoryCount = mine.size,

            sky = sky.await(),

        )

    }

    companion object {

        const val RECENT = 5

        fun greeting(hour: Int, name: String): String {

            val part = when (hour) {

                in 5..11 -> "Good morning"

                in 12..17 -> "Good afternoon"

                else -> "Good evening"

            }

            return "$part, $name"

        }

    }

}