package io.oxygenhub.android.ui.projects

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.Board

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.Project

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

import kotlinx.coroutines.coroutineScope

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.launch

/**

 * The boards the account can see: its own and those of the owners of its

 * repositories (its organisations), open ones first, newest first.

 */

class ProjectsViewModel(private val api: HubApi, private val username: String) : ViewModel() {

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) {

            val owners = (listOf(username) + api.repositories().map { it.owner }).distinct()

            val found = coroutineScope {

                // An owner whose boards will not load is left out, not the list.

                owners.map { o -> async { runCatching { api.projects(o) }.getOrDefault(emptyList()) } }.awaitAll().flatten()

            }

            order(found)

        }

    }

    companion object {

        fun order(projects: List<Project>): List<Project> =

            projects.distinctBy { it.owner to it.number }.sortedWith(compareBy<Project> { it.closed }.thenByDescending { it.updatedMs })

    }

}

/** One board: its columns and cards; a card moves to another column. */

class BoardViewModel(private val api: HubApi, val owner: String, val number: Long) : ViewModel() {

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

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

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

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

    }

    /** Move [card] to [column]: shown at once, put back if the hub refuses. */

    fun move(card: Long, column: String) {

        val before = (_state.value as? Load.Ready)?.value ?: return

        val moving = before.columns.flatMap { it.cards }.firstOrNull { it.id == card } ?: return

        if (before.columns.firstOrNull { c -> c.cards.any { it.id == card } }?.name == column) return

        _state.value = Load.Ready(

            before.copy(columns = before.columns.map { c ->

                val rest = c.cards.filter { it.id != card }

                if (c.name == column) c.copy(cards = rest + moving) else c.copy(cards = rest)

            }),

        )

        _error.value = null

        viewModelScope.launch {

            try {

                api.moveCard(owner, number, card, column)

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                _state.value = Load.Ready(before)

                _error.value = e.userMessage()

            }

        }

    }

    fun dismissError() {

        _error.value = null

    }

}