package io.oxygenhub.android.ui.issues

import androidx.compose.material.icons.outlined.PersonAdd

import androidx.compose.material.icons.outlined.Close

import androidx.compose.material.icons.outlined.Add

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

import androidx.compose.foundation.layout.imePadding

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.automirrored.outlined.Label

import androidx.compose.material3.AlertDialog

import androidx.compose.material3.Button

import androidx.compose.material3.Checkbox

import androidx.compose.material3.ElevatedCard

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.IconButton

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.OutlinedButton

import androidx.compose.material3.OutlinedTextField

import androidx.compose.material3.Text

import androidx.compose.material3.TextButton

import androidx.compose.runtime.Composable

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateListOf

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.remember

import androidx.compose.runtime.saveable.rememberSaveable

import androidx.compose.runtime.setValue

import androidx.compose.ui.Alignment

import androidx.compose.ui.Modifier

import androidx.compose.ui.unit.dp

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import com.mikepenz.markdown.m3.Markdown

import io.oxygenhub.android.api.Comment

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

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

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

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

import io.oxygenhub.android.ui.theme.LocalStatusColors

/**

 * An issue (#4): its body and comments rendered, its labels and

 * assignees; comment, close or reopen, and change its labels, when the

 * session may write.

 */

@OptIn(ExperimentalLayoutApi::class)

@Composable

fun IssueScreen(vm: IssueViewModel, canWrite: Boolean, onBack: () -> Unit, me: String = "") {

    val state by vm.state.collectAsStateWithLifecycle()

    val working by vm.working.collectAsStateWithLifecycle()

    val error by vm.error.collectAsStateWithLifecycle()

    var picking by remember { mutableStateOf(false) }

    var assigning by remember { mutableStateOf(false) }

    val status = LocalStatusColors.current

    AppScreen(

        title = "#${vm.number}",

        subtitle = "${vm.owner}/${vm.name}",

        onBack = onBack,

        actions = {

            if (canWrite) {

                IconButton(onClick = {

                    vm.loadLabels()

                    picking = true

                }) { Icon(Icons.AutoMirrored.Outlined.Label, contentDescription = "Labels") }

                IconButton(onClick = { assigning = true }) { Icon(Icons.Outlined.PersonAdd, contentDescription = "Assignees") }

            }

        },

    ) {

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

            val i = t.issue

            LazyColumn(Modifier.imePadding()) {

                item {

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

                        Text(i.title, style = MaterialTheme.typography.titleLarge)

                        Text(

                            (if (i.isOpen) "Open" else "Closed" + if (i.reason == "not_planned") " (not planned)" else "") +

                                " · opened ${relativeTime(i.createdMs)} by ${i.author}",

                            color = if (i.isOpen) status.ok else status.warn,

                            style = MaterialTheme.typography.bodyMedium,

                        )

                        if (i.labels.isNotEmpty()) {

                            FlowRow(horizontalArrangement = Arrangement.spacedBy(4.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {

                                i.labels.forEach { LabelChip(it) }

                            }

                        }

                        if (i.assignees.isNotEmpty()) Text("Assigned to " + i.assignees.joinToString(", "), style = MaterialTheme.typography.bodySmall)

                        i.milestone?.let { Text("Milestone: $it", style = MaterialTheme.typography.bodySmall) }

                        if (i.body.isNotBlank()) Markdown(i.body) else Text("No description.", color = MaterialTheme.colorScheme.onSurfaceVariant)

                    }

                    HorizontalDivider()

                }

                items(t.comments, key = { it.id }) { c -> CommentCard(c) }

                item {

                    error?.let {

                        Text(it, color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(horizontal = 16.dp, vertical = 4.dp))

                    }

                    if (canWrite && !i.locked) {

                        CommentBox(working, isOpen = i.isOpen, onComment = { body, done -> vm.comment(body, done) }, onClose = { vm.close() }, onReopen = vm::reopen)

                    } else if (i.locked) {

                        Text("Locked: only collaborators may comment.", modifier = Modifier.padding(16.dp))

                    }

                }

            }

        }

    }

    if (assigning) {

        AssigneePicker(current = (state as? Load.Ready)?.value?.issue?.assignees.orEmpty(), me = me, onSave = vm::setAssignees, onDone = { assigning = false })

    }

    if (picking) {

        LabelPicker(vm, current = (state as? Load.Ready)?.value?.issue?.labels?.map { it.name }.orEmpty(), onDone = { picking = false })

    }

}

@Composable

private fun CommentCard(c: Comment) {

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

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

            Text("${c.author} · ${relativeTime(c.createdMs)}", style = MaterialTheme.typography.labelMedium)

            Markdown(c.body)

        }

    }

}

@Composable

private fun CommentBox(working: Boolean, isOpen: Boolean, onComment: (String, (Boolean) -> Unit) -> Unit, onClose: () -> Unit, onReopen: () -> Unit) {

    var text by rememberSaveable { mutableStateOf("") }

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

        OutlinedTextField(text, { text = it }, label = { Text("Comment (Markdown)") }, modifier = Modifier.fillMaxWidth(), minLines = 3)

        Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) {

            Button(enabled = !working && text.isNotBlank(), onClick = { onComment(text) { ok -> if (ok) text = "" } }) { Text("Comment") }

            if (isOpen) {

                OutlinedButton(enabled = !working, onClick = onClose) { Text("Close issue") }

            } else {

                OutlinedButton(enabled = !working, onClick = onReopen) { Text("Reopen") }

            }

        }

    }

}

/** The repository's labels, ticked where the issue has them; saved as the whole set. */

@Composable

private fun LabelPicker(vm: IssueViewModel, current: List<String>, onDone: () -> Unit) {

    val labels by vm.labels.collectAsStateWithLifecycle()

    val chosen = remember { mutableStateListOf<String>().apply { addAll(current) } }

    LaunchedEffect(Unit) { vm.loadLabels() }

    AlertDialog(

        onDismissRequest = onDone,

        title = { Text("Labels") },

        text = {

            when (val l = labels) {

                is Load.Ready -> LazyColumn {

                    items(l.value, key = { it.name }) { label ->

                        Row(verticalAlignment = Alignment.CenterVertically) {

                            Checkbox(label.name in chosen, onCheckedChange = { on -> if (on) chosen += label.name else chosen -= label.name })

                            LabelChip(label)

                        }

                    }

                }

                is Load.Failed -> Text(l.message)

                Load.Loading -> Text("Loading…")

            }

        },

        confirmButton = {

            TextButton(onClick = {

                vm.setLabels(chosen.toList())

                onDone()

            }) { Text("Save") }

        },

        dismissButton = { TextButton(onClick = onDone) { Text("Cancel") } },

    )

}

/**

 * Who the issue is assigned to (#4): each removable, you with one tap, and

 * anyone by their username; saved as the whole set (triage on the hub).

 */

@Composable

private fun AssigneePicker(current: List<String>, me: String, onSave: (List<String>) -> Unit, onDone: () -> Unit) {

    val chosen = remember { mutableStateListOf<String>().apply { addAll(current) } }

    var name by remember { mutableStateOf("") }

    AlertDialog(

        onDismissRequest = onDone,

        title = { Text("Assignees") },

        text = {

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

                if (chosen.isEmpty()) Text("No one yet.", color = MaterialTheme.colorScheme.onSurfaceVariant)

                chosen.forEach { who ->

                    Row(verticalAlignment = Alignment.CenterVertically) {

                        Text("@$who", modifier = Modifier.weight(1f))

                        IconButton(onClick = { chosen -= who }) { Icon(Icons.Outlined.Close, contentDescription = "Unassign $who") }

                    }

                }

                if (me.isNotEmpty() && me !in chosen) TextButton(onClick = { chosen += me }) { Text("Assign me") }

                OutlinedTextField(

                    value = name,

                    onValueChange = { name = it.trim() },

                    label = { Text("Username") },

                    singleLine = true,

                    trailingIcon = {

                        IconButton(enabled = name.isNotBlank(), onClick = {

                            val who = name.removePrefix("@")

                            if (who.isNotEmpty() && who !in chosen) chosen += who

                            name = ""

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

                    },

                )

            }

        },

        confirmButton = {

            TextButton(onClick = {

                onSave(chosen.toList())

                onDone()

            }) { Text("Save") }

        },

        dismissButton = { TextButton(onClick = onDone) { Text("Cancel") } },

    )

}

/** A new issue's title and description; opened, it shows on its own screen. */

@Composable

fun NewIssueScreen(vm: NewIssueViewModel, onBack: () -> Unit, onOpened: (Long) -> Unit) {

    val working by vm.working.collectAsStateWithLifecycle()

    val error by vm.error.collectAsStateWithLifecycle()

    var title by rememberSaveable { mutableStateOf("") }

    var body by rememberSaveable { mutableStateOf("") }

    AppScreen(title = "New issue", subtitle = "${vm.owner}/${vm.name}", onBack = onBack) {

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

            OutlinedTextField(title, { title = it }, label = { Text("Title") }, singleLine = true, modifier = Modifier.fillMaxWidth())

            OutlinedTextField(body, { body = it }, label = { Text("Description (Markdown)") }, minLines = 6, modifier = Modifier.fillMaxWidth())

            error?.let { Text(it, color = MaterialTheme.colorScheme.error) }

            Button(enabled = !working && title.isNotBlank(), onClick = { vm.open(title, body) { onOpened(it.number) } }) { Text("Open issue") }

        }

    }

}