package io.oxygenhub.android.ui.code

import androidx.lifecycle.ViewModel

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.TreeEntry

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.common.load

import kotlinx.coroutines.Job

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

/**

 * A repository's code (#3): a directory of its tree at a bookmark, tag or

 * change, folders first, and the directory's README to show below it.

 */

class CodeViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    /** The bookmark to start at; the repository's default when not given. */

    defaultRef: String? = null,

) : ViewModel() {

    /** What a directory holds, and its README's text when it has one. */

    data class Dir(val ref: String, val path: String, val entries: List<TreeEntry>, val readme: Readme?)

    data class Readme(val path: String, val text: String)

    private val _ref = MutableStateFlow(defaultRef.orEmpty())

    val ref: StateFlow<String> = _ref.asStateFlow()

    private val _path = MutableStateFlow("")

    val path: StateFlow<String> = _path.asStateFlow()

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

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

    /** The bookmarks and tags to browse at, fetched once the picker opens. */

    private val _refs = MutableStateFlow<Load<Pair<List<String>, List<String>>>>(Load.Loading)

    val refs: StateFlow<Load<Pair<List<String>, List<String>>>> = _refs.asStateFlow()

    private var job: Job? = null

    private var refsJob: Job? = null

    init {

        refresh()

    }

    fun open(path: String) {

        if (path == _path.value) return

        _path.value = path

        _state.value = Load.Loading

        refresh()

    }

    /** One directory up; false at the top. */

    fun up(): Boolean {

        val p = _path.value

        if (p.isEmpty()) return false

        open(p.substringBeforeLast('/', ""))

        return true

    }

    fun setRef(ref: String) {

        if (ref == _ref.value) return

        _ref.value = ref

        _state.value = Load.Loading

        refresh()

    }

    fun loadRefs() {

        if (_refs.value is Load.Ready) return

        refsJob = load(_refs, refsJob) { api.refs(owner, name) }

    }

    fun refresh() {

        val path = _path.value

        job = load(_state, job) {

            val ref = _ref.value.ifEmpty { api.repository(owner, name).defaultBookmark.also { _ref.value = it } }

            val entries = order(api.tree(owner, name, ref, path))

            val readme = readmeOf(entries)?.let { e ->

                // A README that will not load is left out, not an error.

                runCatching { Readme(e.path, api.file(owner, name, ref, e.path)) }.getOrNull()

            }

            Dir(ref, path, entries, readme)

        }

    }

    companion object {

        /** Folders first, then files, each by name as a person reads them. */

        fun order(entries: List<TreeEntry>): List<TreeEntry> =

            entries.sortedWith(compareBy<TreeEntry> { !it.isDir }.thenBy(String.CASE_INSENSITIVE_ORDER) { it.name })

        /** The README a directory shows: Markdown first. */

        fun readmeOf(entries: List<TreeEntry>): TreeEntry? {

            val files = entries.filter { !it.isDir }

            return listOf("README.md", "readme.md", "README.markdown", "README", "README.txt")

                .firstNotNullOfOrNull { n -> files.firstOrNull { it.name.equals(n, ignoreCase = false) } }

                ?: files.firstOrNull { it.name.lowercase().startsWith("readme") }

        }

    }

}

/** A file at a reference: its text, to show highlighted, or rendered when it is Markdown. */

class FileViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val ref: String,

    val path: String,

) : ViewModel() {

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.file(owner, name, ref, path) }

    }

    val isMarkdown: Boolean get() = path.lowercase().let { it.endsWith(".md") || it.endsWith(".markdown") }

}