package io.oxygenhub.android.ui.issues

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.Comment

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.Issue

import io.oxygenhub.android.api.Label

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

/**

 * One issue (#4): it and its comments; comment, close or reopen, and set

 * its labels. What the hub refuses is said in [error], and the page stays.

 */

class IssueViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val number: Long,

) : ViewModel() {

    data class Thread(val issue: Issue, val comments: List<Comment>)

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

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

    private val _working = MutableStateFlow(false)

    val working: StateFlow<Boolean> = _working.asStateFlow()

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

    val error: StateFlow<String?> = _error.asStateFlow()

    /** The repository's labels, once the label picker asks. */

    private val _labels = MutableStateFlow<Load<List<Label>>>(Load.Loading)

    val labels: StateFlow<Load<List<Label>>> = _labels.asStateFlow()

    private var job: Job? = null

    private var labelsJob: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) {

            coroutineScope {

                val issue = async { api.issue(owner, name, number) }

                val comments = async { api.issueComments(owner, name, number) }

                Thread(issue.await(), comments.await())

            }

        }

    }

    fun loadLabels() {

        if (_labels.value is Load.Ready) return

        labelsJob = load(_labels, labelsJob) { api.labels(owner, name) }

    }

    /** Post [body]; true once the hub has it (the box empties then). */

    fun comment(body: String, then: (Boolean) -> Unit = {}) = act({

        val c = api.comment(owner, name, number, body.trim())

        current()?.let { t -> _state.value = Load.Ready(t.copy(comments = t.comments + c, issue = t.issue.copy(comments = t.issue.comments + 1))) }

    }, then)

    fun close(reason: String = "completed") = act({ swap(api.setIssueState(owner, name, number, open = false, reason = reason)) })

    fun reopen() = act({ swap(api.setIssueState(owner, name, number, open = true)) })

    fun setLabels(names: List<String>) = act({ swap(api.setIssueLabels(owner, name, number, names)) })

    fun dismissError() {

        _error.value = null

    }

    private fun current(): Thread? = (_state.value as? Load.Ready)?.value

    private fun swap(issue: Issue) {

        current()?.let { _state.value = Load.Ready(it.copy(issue = issue)) }

    }

    private fun act(step: suspend () -> Unit, then: (Boolean) -> Unit = {}) {

        if (_working.value) return

        _working.value = true

        _error.value = null

        viewModelScope.launch {

            val ok = try {

                step()

                true

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                _error.value = e.userMessage()

                false

            } finally {

                _working.value = false

            }

            then(ok)

        }

    }

}

/** A new issue: its title and body, opened on the hub. */

class NewIssueViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

) : ViewModel() {

    private val _working = MutableStateFlow(false)

    val working: StateFlow<Boolean> = _working.asStateFlow()

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

    val error: StateFlow<String?> = _error.asStateFlow()

    fun open(title: String, body: String, opened: (Issue) -> Unit) {

        if (_working.value || title.isBlank()) return

        _working.value = true

        _error.value = null

        viewModelScope.launch {

            try {

                opened(api.createIssue(owner, name, title.trim(), body.trim()))

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                _error.value = e.userMessage()

            } finally {

                _working.value = false

            }

        }

    }

}