package io.oxygenhub.android.ui.proposals

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.Check

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.Proposal

import io.oxygenhub.android.api.WriteScope

import io.oxygenhub.android.api.lackedScope

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

import kotlinx.coroutines.coroutineScope

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.launch

/** A proposal and the checks on what it would land; [checks] is null when they could not be read. */

data class ProposalPage(val proposal: Proposal, val checks: List<Check>?)

/** What landing (or setting it to land by itself) is doing, or did. */

sealed interface LandAction {

    data object Idle : LandAction

    data object Working : LandAction

    data class Done(val message: String) : LandAction

    /** [needsWrite]: the token may not change things; signing in again asks for it. */

    data class Failed(val message: String, val needsWrite: Boolean = false) : LandAction

}

/** One proposal, with its checks; lands it, or sets it to land when its checks pass. */

class ProposalViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val number: Long,

) : ViewModel() {

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

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

    private val _action = MutableStateFlow<LandAction>(LandAction.Idle)

    val action: StateFlow<LandAction> = _action.asStateFlow()

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) {

            coroutineScope {

                // The checks are part of the picture, not the page: without them it still shows.

                val checks = async {

                    try {

                        api.checks(owner, name, number)

                    } catch (e: CancellationException) {

                        throw e

                    } catch (_: Exception) {

                        null

                    }

                }

                ProposalPage(api.proposal(owner, name, number), checks.await())

            }

        }

    }

    fun land() = act { p ->

        val landed = api.land(owner, name, number)

        landed to "Landed #$number into ${p.target}."

    }

    fun setAutoLand(on: Boolean) = act { _ ->

        val after = api.setAutoLand(owner, name, number, on)

        after to if (on) {

            if (after.landed != null) "Its checks had passed: landed #$number." else "#$number will land when its checks pass."

        } else {

            "#$number will not land by itself."

        }

    }

    fun dismiss() {

        _action.value = LandAction.Idle

    }

    private fun act(work: suspend (Proposal) -> Pair<Proposal, String>) {

        val page = _state.value.valueOrNull ?: return

        if (_action.value == LandAction.Working) return

        _action.value = LandAction.Working

        viewModelScope.launch {

            _action.value = try {

                val (after, message) = work(page.proposal)

                _state.value = Load.Ready(page.copy(proposal = after))

                LandAction.Done(message)

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                failure(e)

            }

            // What the hub thinks now: blockers, checks, who set auto-land.

            refresh()

        }

    }

    companion object {

        fun failure(e: Exception): LandAction.Failed = when {

            e.lackedScope == WriteScope -> LandAction.Failed(

                "This phone was signed in to read only. Sign in again to allow landing.",

                needsWrite = true,

            )

            // The hub's own reason: blockers, a conflict, a race with another landing.

            e is HubException.Http && e.status == 409 -> LandAction.Failed(e.detail)

            else -> LandAction.Failed(e.userMessage())

        }

    }

}