package io.oxygenhub.android.ui.owners

import androidx.compose.foundation.clickable

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.ExperimentalLayoutApi

import androidx.compose.foundation.layout.FlowRow

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.fillMaxSize

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.lazy.LazyColumn

import androidx.compose.foundation.lazy.items

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.outlined.Lock

import androidx.compose.material.icons.outlined.ViewKanban

import androidx.compose.material3.AssistChip

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.ListItem

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.getValue

import androidx.compose.ui.Alignment

import androidx.compose.ui.Modifier

import androidx.compose.ui.unit.dp

import androidx.lifecycle.ViewModel

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.Owner

import io.oxygenhub.android.api.Project

import io.oxygenhub.android.api.Repository

import io.oxygenhub.android.api.Visibility

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

import io.oxygenhub.android.ui.common.AvatarImage

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 io.oxygenhub.android.ui.common.rememberAvatar

import io.oxygenhub.android.ui.theme.Tones

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

/** An owner's page: who they are, their repositories (those you can read) and boards. */

data class OwnerPage(val owner: Owner, val repositories: List<Repository>, val projects: List<Project>)

/** An account's or organisation's page; a name is tried as an account, then as an organisation. */

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

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) {

            coroutineScope {

                val repos = async { api.repositories().filter { it.owner.equals(name, ignoreCase = true) }.sortedByDescending { it.updatedMs } }

                val projects = async { runCatching { api.projects(name) }.getOrDefault(emptyList()).filter { !it.closed } }

                val owner = try {

                    Owner.Person(api.account(name))

                } catch (e: HubException.Http) {

                    if (e.status != 404) throw e

                    Owner.Org(api.organisation(name))

                }

                OwnerPage(owner, repos.await(), projects.await())

            }

        }

    }

}

@OptIn(ExperimentalLayoutApi::class)

@Composable

fun OwnerScreen(

    vm: OwnerViewModel,

    api: HubApi,

    onBack: () -> Unit,

    onOpenOwner: (String) -> Unit,

    onOpenRepository: (Repository) -> Unit,

    onOpenProject: (Project) -> Unit,

) {

    val state by vm.state.collectAsStateWithLifecycle()

    AppScreen(title = vm.name, onBack = onBack) {

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

            LazyColumn(Modifier.fillMaxSize()) {

                item {

                    Row(Modifier.padding(16.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(16.dp)) {

                        AvatarImage(rememberAvatar(api, page.owner.name), page.owner.name, size = 64.dp)

                        Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {

                            Text(page.owner.shownName, style = MaterialTheme.typography.titleLarge)

                            Text(

                                when (val o = page.owner) {

                                    is Owner.Person -> listOfNotNull(

                                        o.user.username.takeIf { it != o.shownName },

                                        "joined ${relativeTime(o.user.createdMs)}".takeIf { o.user.createdMs > 0 },

                                    ).joinToString(" · ")

                                    is Owner.Org -> "organisation · ${o.org.members.size} ${if (o.org.members.size == 1) "member" else "members"}"

                                },

                                style = MaterialTheme.typography.bodyMedium,

                                color = MaterialTheme.colorScheme.onSurfaceVariant,

                            )

                        }

                    }

                    (page.owner as? Owner.Org)?.let { o ->

                        Column(Modifier.padding(horizontal = 16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {

                            if (o.org.description.isNotBlank()) Text(o.org.description, style = MaterialTheme.typography.bodyMedium)

                            FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                                o.org.members.forEach { m ->

                                    AssistChip(

                                        onClick = { onOpenOwner(m) },

                                        label = { Text(m) },

                                        leadingIcon = { AvatarImage(rememberAvatar(api, m), m, size = 18.dp) },

                                    )

                                }

                            }

                        }

                    }

                }

                if (page.projects.isNotEmpty()) {

                    item { Section("Projects") }

                    items(page.projects, key = { "p${it.number}" }) { p ->

                        ListItem(

                            modifier = Modifier.clickable { onOpenProject(p) },

                            leadingContent = { Icon(Icons.Outlined.ViewKanban, contentDescription = null, tint = Tones.project) },

                            headlineContent = { Text(p.title.ifBlank { "Project ${p.number}" }) },

                            supportingContent = if (p.description.isNotBlank()) {

                                { Text(p.description, maxLines = 2) }

                            } else {

                                null

                            },

                        )

                    }

                }

                item { Section(if (page.repositories.isEmpty()) "No repositories you can read" else "Repositories") }

                items(page.repositories, key = { it.slug }) { r ->

                    ListItem(

                        modifier = Modifier.clickable { onOpenRepository(r) },

                        headlineContent = { Text(r.name) },

                        supportingContent = {

                            Text(

                                listOfNotNull(r.description.takeIf { it.isNotBlank() }, "updated ${relativeTime(r.updatedMs)}".takeIf { r.updatedMs > 0 })

                                    .joinToString(" · "),

                                maxLines = 2,

                            )

                        },

                        trailingContent = if (r.visibility != Visibility.Public) {

                            { Icon(Icons.Outlined.Lock, contentDescription = "Not public", tint = Tones.restricted) }

                        } else {

                            null

                        },

                    )

                    HorizontalDivider()

                }

            }

        }

    }

}

@Composable

private fun Section(title: String) {

    Text(

        title,

        modifier = Modifier.padding(start = 16.dp, end = 16.dp, top = 20.dp, bottom = 4.dp),

        style = MaterialTheme.typography.titleSmall,

        color = MaterialTheme.colorScheme.primary,

    )

}