package io.oxygenhub.android.ui.releases

import androidx.compose.foundation.clickable

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.fillMaxSize

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.lazy.LazyColumn

import androidx.compose.foundation.lazy.items

import androidx.compose.foundation.text.KeyboardActions

import androidx.compose.foundation.text.KeyboardOptions

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.outlined.Download

import androidx.compose.material.icons.outlined.NewReleases

import androidx.compose.material.icons.outlined.Search

import androidx.compose.material3.ElevatedCard

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.ListItem

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.OutlinedTextField

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.saveable.rememberSaveable

import androidx.compose.runtime.setValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.platform.LocalUriHandler

import androidx.compose.ui.text.input.ImeAction

import androidx.compose.ui.unit.dp

import androidx.lifecycle.ViewModel

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import androidx.lifecycle.viewModelScope

import com.mikepenz.markdown.m3.Markdown

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.Release

import io.oxygenhub.android.api.SearchHit

import io.oxygenhub.android.ui.code.bytes

import io.oxygenhub.android.ui.common.AppScreen

import io.oxygenhub.android.ui.common.EmptyState

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

import io.oxygenhub.android.ui.common.LoadContent

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

import io.oxygenhub.android.ui.common.relativeTime

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.Job

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.launch

/** A repository's releases, newest first. */

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

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.releases(owner, name).sortedByDescending { it.createdMs } }

    }

}

/** Issues and proposals found across the account's repositories. */

class SearchViewModel(private val api: HubApi) : ViewModel() {

    private val _state = MutableStateFlow<Load<List<SearchHit>>?>(null)

    /** Null before the first search. */

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

    private var job: Job? = null

    fun search(query: String) {

        val q = query.trim()

        if (q.isEmpty()) return

        job?.cancel()

        _state.value = Load.Loading

        job = viewModelScope.launch {

            _state.value = try {

                Load.Ready(api.search(q))

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                Load.failed(e)

            }

        }

    }

}

/** The releases tab: each release's notes rendered and its files to download. */

@Composable

fun ReleaseList(vm: ReleasesViewModel) {

    val state by vm.state.collectAsStateWithLifecycle()

    val uri = LocalUriHandler.current

    LoadContent(state, onRefresh = vm::refresh) { releases ->

        if (releases.isEmpty()) {

            EmptyState(Icons.Outlined.NewReleases, "No releases", "Tagged releases of ${vm.owner}/${vm.name} show here.")

        } else {

            LazyColumn(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {

                items(releases, key = { it.tag }) { r ->

                    ElevatedCard(Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 4.dp)) {

                        Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {

                            Text(r.title.ifEmpty { r.tag }, style = MaterialTheme.typography.titleMedium)

                            Text(

                                listOfNotNull(

                                    r.tag,

                                    "latest".takeIf { r.latest },

                                    "pre-release".takeIf { r.prerelease },

                                    r.signer?.let { "signed by $it" },

                                    relativeTime(r.createdMs).takeIf { it.isNotEmpty() },

                                ).joinToString(" · "),

                                style = MaterialTheme.typography.labelMedium,

                                color = MaterialTheme.colorScheme.onSurfaceVariant,

                            )

                            if (r.notes.isNotBlank()) Markdown(r.notes)

                            r.assets.forEach { a ->

                                ListItem(

                                    modifier = Modifier.clickable { if (a.url.isNotBlank()) uri.openUri(a.url) },

                                    leadingContent = { Icon(Icons.Outlined.Download, contentDescription = "Download") },

                                    headlineContent = { Text(a.name) },

                                    supportingContent = { Text("${bytes(a.size)} · ${a.downloads} downloads") },

                                )

                            }

                        }

                    }

                }

            }

        }

    }

}

/** Search issues and proposals; a result opens on its own screen. */

@Composable

fun SearchScreen(vm: SearchViewModel, onBack: () -> Unit, onOpen: (SearchHit) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    var query by rememberSaveable { mutableStateOf("") }

    AppScreen(title = "Search", onBack = onBack) {

        Column(Modifier.fillMaxSize()) {

            OutlinedTextField(

                query,

                { query = it },

                label = { Text("Issues and proposals") },

                singleLine = true,

                leadingIcon = { Icon(Icons.Outlined.Search, contentDescription = null) },

                keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),

                keyboardActions = KeyboardActions(onSearch = { vm.search(query) }),

                modifier = Modifier.fillMaxWidth().padding(12.dp),

            )

            when (val s = state) {

                null -> EmptyState(Icons.Outlined.Search, "Search", "Words from titles, bodies and comments, in every repository you can read.")

                else -> LoadContent(s, onRefresh = { vm.search(query) }) { hits ->

                    if (hits.isEmpty()) {

                        EmptyState(Icons.Outlined.Search, "Nothing found", "No issue or proposal matches \"$query\".")

                    } else {

                        LazyColumn {

                            items(hits, key = { "${it.repository}#${it.number}" }) { h ->

                                ListItem(

                                    modifier = Modifier.clickable { onOpen(h) },

                                    overlineContent = { Text("${h.repository} · ${h.kind} #${h.number}") },

                                    headlineContent = { Text(h.title) },

                                    supportingContent = if (h.snippet.isNotBlank()) {

                                        { Text(h.snippet, maxLines = 2) }

                                    } else {

                                        null

                                    },

                                )

                                HorizontalDivider()

                            }

                        }

                    }

                }

            }

        }

    }

}