package io.oxygenhub.android.ui.flow

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.FlowRun

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.LogLine

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

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.isActive

import kotlinx.coroutines.launch

/** A repository's runs, newest first (#5). */

class RunsViewModel(private val api: HubApi, val owner: String, val name: String) : ViewModel() {

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.runs(owner, name) }

    }

}

/**

 * One run and its jobs, fetched again every few seconds while it is queued

 * or running, so its jobs' states follow; rerun and cancel it.

 */

class RunViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val number: Long,

    /** How often a live run is fetched again; 0 not at all (tests). */

    private val pollMs: Long = 3000,

) : ViewModel() {

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

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

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

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

    private var job: Job? = null

    init {

        refresh()

        if (pollMs > 0) {

            viewModelScope.launch {

                while (isActive) {

                    delay(pollMs)

                    if ((_state.value as? Load.Ready)?.value?.live == true) poll()

                }

            }

        }

    }

    fun refresh() {

        job = load(_state, job) { api.run(owner, name, number) }

    }

    /** Fetch it again without a spinner. */

    suspend fun poll() {

        try {

            _state.value = Load.Ready(api.run(owner, name, number))

        } catch (e: CancellationException) {

            throw e

        } catch (_: Exception) {

            // The next tick tries again; the last state stays shown.

        }

    }

    fun rerun() = act { api.rerunRun(owner, name, number) }

    fun rerunJob(job: String) = act { api.rerunJob(owner, name, number, job) }

    fun cancel() = act { api.cancelRun(owner, name, number) }

    /** Approve, or reject, a job that waits for a person (#5). */

    fun decide(job: String, approve: Boolean) = act { api.decideJob(owner, name, number, job, approve) }

    /** Make the run urgent, saying why (#5). */

    fun expedite(reason: String) = act { api.expediteRun(owner, name, number, reason.trim()) }

    private fun act(step: suspend () -> Unit) {

        _error.value = null

        viewModelScope.launch {

            try {

                step()

                poll()

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                _error.value = e.userMessage()

            }

        }

    }

}

/**

 * A job's log, followed while the job runs: new lines are asked for after

 * the last one held, every couple of seconds, until the job has finished.

 */

class JobLogViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val number: Long,

    val job: String,

    private val pollMs: Long = 2000,

) : ViewModel() {

    data class Log(val lines: List<LogLine>, val status: String, val live: Boolean)

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

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

    init {

        viewModelScope.launch {

            next()

            while (pollMs > 0 && isActive && (_state.value as? Load.Ready)?.value?.live != false) {

                delay(pollMs)

                next()

            }

        }

    }

    /** The lines after the last one held, and whether the job still runs. */

    suspend fun next() {

        val held = (_state.value as? Load.Ready)?.value

        try {

            val after = held?.lines?.lastOrNull()?.seq ?: 0

            val more = api.jobLog(owner, name, number, job, after)

            val j = api.run(owner, name, number).jobs.firstOrNull { it.name == job }

            _state.value = Load.Ready(Log((held?.lines.orEmpty()) + more, j?.status ?: held?.status.orEmpty(), j?.live ?: false))

        } catch (e: CancellationException) {

            throw e

        } catch (e: Exception) {

            if (held == null) _state.value = Load.failed(e)

        }

    }

    fun retry() {

        _state.value = Load.Loading

        viewModelScope.launch { next() }

    }

}