package io.oxygenhub.android.ui.proposals

import androidx.compose.foundation.clickable

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Box

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.FlowRow

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.Spacer

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.layout.size

import androidx.compose.foundation.layout.width

import androidx.compose.foundation.layout.widthIn

import androidx.compose.foundation.rememberScrollState

import androidx.compose.foundation.verticalScroll

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.automirrored.outlined.KeyboardArrowRight

import androidx.compose.material.icons.automirrored.outlined.OpenInNew

import androidx.compose.material.icons.outlined.Cancel

import androidx.compose.material.icons.outlined.CheckCircle

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

import androidx.compose.material.icons.outlined.RemoveCircleOutline

import androidx.compose.material.icons.outlined.Schedule

import androidx.compose.material.icons.outlined.WarningAmber

import androidx.compose.material3.AlertDialog

import androidx.compose.material3.Button

import androidx.compose.material3.CircularProgressIndicator

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.IconButton

import androidx.compose.material3.LinearProgressIndicator

import androidx.compose.material3.ListItem

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.OutlinedButton

import androidx.compose.material3.OutlinedTextField

import androidx.compose.material3.SnackbarHostState

import androidx.compose.material3.Switch

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.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.platform.LocalUriHandler

import androidx.compose.ui.text.font.FontFamily

import androidx.compose.ui.text.font.FontWeight

import androidx.compose.ui.unit.dp

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import io.oxygenhub.android.api.Check

import io.oxygenhub.android.api.Proposal

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

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

import io.oxygenhub.android.ui.common.Panel

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

import io.oxygenhub.android.ui.issues.LabelChip

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

/**

 * One proposal: whether it may land and what stands in the way, in the

 * hub's words; landing it, or having it land when its checks pass; then

 * its checks, approvals, changes and description.

 */

@Composable

fun ProposalScreen(vm: ProposalViewModel, canWrite: Boolean, onBack: () -> Unit, onSignInAgain: () -> Unit, onOpenFiles: () -> Unit = {}) {

    val state by vm.state.collectAsStateWithLifecycle()

    val action by vm.action.collectAsStateWithLifecycle()

    val snackbar = remember { SnackbarHostState() }

    val uri = LocalUriHandler.current

    val done = action as? LandAction.Done

    LaunchedEffect(done) {

        if (done != null) {

            snackbar.showSnackbar(done.message)

            vm.dismiss()

        }

    }

    AppScreen(

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

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

        onBack = onBack,

        snackbar = snackbar,

        actions = {

            val url = state.valueOrNull?.proposal?.url.orEmpty()

            if (url.isNotBlank()) {

                IconButton(onClick = { uri.openUri(url) }) {

                    Icon(Icons.AutoMirrored.Outlined.OpenInNew, contentDescription = "Open on the hub")

                }

            }

        },

    ) {

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

            Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.TopCenter) {

                Column(

                    Modifier.widthIn(max = 720.dp).verticalScroll(rememberScrollState()).padding(16.dp),

                    verticalArrangement = Arrangement.spacedBy(16.dp),

                ) {

                    Header(page.proposal)

                    Landing(page.proposal, action, canWrite, vm::land, vm::setAutoLand, onSignInAgain, vm::dismiss)

                    Checks(page.checks) { if (it.url.isNotBlank()) uri.openUri(it.url) }

                    Reviews(page.proposal, canReview = canWrite && page.proposal.state == "open", busy = action == LandAction.Working, onReview = vm::review)

                    Changes(page.proposal, onOpenFiles)

                    if (page.proposal.body.isNotBlank()) {

                        Section("Description") {

                            Text(page.proposal.body, modifier = Modifier.padding(16.dp), style = MaterialTheme.typography.bodyMedium)

                        }

                    }

                }

            }

        }

    }

}

@Composable

private fun Header(p: Proposal) {

    val (icon, tint) = stateLook(p)

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

        Row(verticalAlignment = Alignment.CenterVertically) {

            Icon(icon, contentDescription = null, tint = tint, modifier = Modifier.size(18.dp))

            Spacer(Modifier.width(6.dp))

            Text(p.state.replaceFirstChar { it.uppercase() }, color = tint, style = MaterialTheme.typography.labelLarge)

        }

        Text(p.title, style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold)

        val n = p.changes.size

        Text(

            "${p.author} wants to land $n change${if (n == 1) "" else "s"} into ${p.target} · updated ${relativeTime(p.updatedMs)}",

            style = MaterialTheme.typography.bodyMedium,

            color = MaterialTheme.colorScheme.onSurfaceVariant,

        )

        if (p.labels.isNotEmpty()) {

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

                p.labels.forEach { LabelChip(it) }

            }

        }

    }

}

@Composable

private fun Landing(

    p: Proposal,

    action: LandAction,

    canWrite: Boolean,

    onLand: () -> Unit,

    onAutoLand: (Boolean) -> Unit,

    onSignInAgain: () -> Unit,

    onDismiss: () -> Unit,

) {

    val status = LocalStatusColors.current

    var confirming by rememberSaveable { mutableStateOf(false) }

    val working = action == LandAction.Working

    Panel(Modifier.fillMaxWidth()) {

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

            when {

                p.landed != null -> Text(

                    "Landed ${relativeTime(p.landed.whenMs)} by ${p.landed.by}${if (p.landed.via.isNotBlank()) " (${p.landed.via})" else ""}.",

                    style = MaterialTheme.typography.titleMedium,

                )

                !p.isOpen -> Text("Closed without landing.", style = MaterialTheme.typography.titleMedium)

                else -> {

                    if (p.landable) {

                        Text("Ready to land", style = MaterialTheme.typography.titleMedium, color = status.ok)

                    } else {

                        Text("Not ready to land", style = MaterialTheme.typography.titleMedium)

                        p.blockers.forEach { b ->

                            Row(verticalAlignment = Alignment.Top) {

                                Icon(Icons.Outlined.WarningAmber, contentDescription = null, tint = status.bad, modifier = Modifier.size(18.dp).padding(top = 2.dp))

                                Spacer(Modifier.width(8.dp))

                                Text(b, style = MaterialTheme.typography.bodyMedium)

                            }

                        }

                    }

                    if (!canWrite) {

                        Text(

                            "This phone was signed in to read only. Sign in again to allow landing.",

                            style = MaterialTheme.typography.bodyMedium,

                            color = MaterialTheme.colorScheme.onSurfaceVariant,

                        )

                        OutlinedButton(onClick = onSignInAgain) { Text("Sign in again") }

                    } else {

                        Button(onClick = { confirming = true }, enabled = p.landable && !working, modifier = Modifier.fillMaxWidth()) {

                            Text("Land into ${p.target}")

                        }

                        Row(verticalAlignment = Alignment.CenterVertically) {

                            Column(Modifier.weight(1f)) {

                                Text("Land when its checks pass", style = MaterialTheme.typography.bodyLarge)

                                Text(

                                    p.autoLand?.let { "Set by $it" } ?: "Lands by itself once nothing stands in the way.",

                                    style = MaterialTheme.typography.bodySmall,

                                    color = MaterialTheme.colorScheme.onSurfaceVariant,

                                )

                            }

                            Switch(checked = p.autoLand != null, onCheckedChange = onAutoLand, enabled = !working && !p.isDraft)

                        }

                    }

                }

            }

            if (working) LinearProgressIndicator(Modifier.fillMaxWidth())

            if (action is LandAction.Failed) {

                Text(action.message, color = status.bad, style = MaterialTheme.typography.bodyMedium)

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

                    if (action.needsWrite) OutlinedButton(onClick = onSignInAgain) { Text("Sign in again") }

                    TextButton(onClick = onDismiss) { Text("OK") }

                }

            }

        }

    }

    if (confirming) {

        AlertDialog(

            onDismissRequest = { confirming = false },

            title = { Text("Land #${p.number}?") },

            text = { Text("“${p.title}” lands into ${p.target} on the hub, as LAND on its page does.") },

            confirmButton = {

                TextButton(onClick = {

                    confirming = false

                    onLand()

                }) { Text("Land") }

            },

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

        )

    }

}

@Composable

private fun Checks(checks: List<Check>?, onOpen: (Check) -> Unit) {

    val status = LocalStatusColors.current

    Section(

        when {

            checks == null -> "Checks"

            checks.isEmpty() -> "Checks"

            else -> "Checks · ${checks.count { it.status == "passed" }} of ${checks.size} passed"

        },

    ) {

        when {

            checks == null -> Text("The checks could not be read.", Modifier.padding(16.dp))

            checks.isEmpty() -> Text("No checks have run on what it would land.", Modifier.padding(16.dp))

            else -> checks.sortedBy { order(it.status) }.forEachIndexed { i, c ->

                if (i > 0) HorizontalDivider()

                ListItem(

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

                    leadingContent = {

                        when (c.status) {

                            "passed" -> Icon(Icons.Outlined.CheckCircle, "Passed", tint = status.ok)

                            "failed" -> Icon(Icons.Outlined.Cancel, "Failed", tint = status.bad)

                            "running" -> CircularProgressIndicator(Modifier.size(22.dp), strokeWidth = 2.dp)

                            "queued" -> Icon(Icons.Outlined.Schedule, "Queued", tint = MaterialTheme.colorScheme.onSurfaceVariant)

                            else -> Icon(Icons.Outlined.RemoveCircleOutline, c.status, tint = MaterialTheme.colorScheme.onSurfaceVariant)

                        }

                    },

                    headlineContent = { Text(c.name) },

                    supportingContent = if (c.summary.isNotBlank()) ({ Text(c.summary) }) else null,

                )

            }

        }

    }

}

/** Failures first, then what is still going, then the rest. */

private fun order(status: String): Int = when (status) {

    "failed" -> 0

    "running" -> 1

    "queued" -> 2

    else -> 3

}

@Composable

private fun Reviews(p: Proposal, canReview: Boolean, busy: Boolean, onReview: (verdict: String, body: String) -> Unit) {

    if (p.approvals.isEmpty() && p.requestedReviewers.isEmpty() && !canReview) return

    Section("Reviews") {

        Column(Modifier.padding(vertical = 4.dp)) {

            if (canReview) ReviewBox(busy, onReview)

            p.approvals.forEach { a ->

                ListItem(

                    leadingContent = { Icon(Icons.Outlined.CheckCircle, null, tint = LocalStatusColors.current.ok) },

                    headlineContent = { Text(a.account) },

                    supportingContent = { Text(if (a.sealed) "approved, sealed" else "approved, not sealed: it does not count yet") },

                    trailingContent = if (a.sealed) ({ Icon(Icons.Outlined.Lock, "Sealed") }) else null,

                )

            }

            p.requestedReviewers.forEach { r ->

                ListItem(

                    leadingContent = { Icon(Icons.Outlined.Schedule, null) },

                    headlineContent = { Text(r) },

                    supportingContent = { Text("asked to review") },

                )

            }

        }

    }

}

/**

 * Review it from the phone (#4): approve, ask for changes, or comment. An

 * approval from here is not sealed (the phone holds no key of yours), so

 * where the repository needs sealed approvals it does not count yet.

 */

@Composable

private fun ReviewBox(busy: Boolean, onReview: (verdict: String, body: String) -> Unit) {

    var text by rememberSaveable { mutableStateOf("") }

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

        OutlinedTextField(

            value = text,

            onValueChange = { text = it },

            label = { Text("Review") },

            placeholder = { Text("What you think; needed to ask for changes") },

            modifier = Modifier.fillMaxWidth(),

            minLines = 2,

            enabled = !busy,

        )

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

            Button(onClick = { onReview("approve", text); text = "" }, enabled = !busy) { Text("Approve") }

            OutlinedButton(onClick = { onReview("changes", text); text = "" }, enabled = !busy && text.isNotBlank()) { Text("Request changes") }

            TextButton(onClick = { onReview("comment", text); text = "" }, enabled = !busy && text.isNotBlank()) { Text("Comment") }

        }

    }

}

@Composable

private fun Changes(p: Proposal, onOpenFiles: () -> Unit) {

    if (p.changes.isEmpty()) return

    Section("Changes · ${p.changes.size}") {

        Column {

            // Its files and their diffs, as the proposal page shows them (#4).

            ListItem(

                modifier = Modifier.clickable(onClick = onOpenFiles),

                headlineContent = { Text("Files changed") },

                supportingContent = { Text("Each file with its diff") },

                trailingContent = { Icon(Icons.AutoMirrored.Outlined.KeyboardArrowRight, contentDescription = null) },

            )

            HorizontalDivider()

            p.changes.asReversed().forEachIndexed { i, c ->

                if (i > 0) HorizontalDivider()

                ListItem(

                    headlineContent = { Text(c.subject.ifBlank { "(no message)" }) },

                    supportingContent = { Text(c.hash.take(12), fontFamily = FontFamily.Monospace) },

                )

            }

        }

    }

}

@Composable

private fun Section(title: String, content: @Composable () -> Unit) {

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

        Text(title, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold)

        Panel(Modifier.fillMaxWidth()) { content() }

    }

}