package io.oxygenhub.android.ui.flow

import androidx.compose.animation.core.LinearOutSlowInEasing

import androidx.compose.animation.core.animateFloat

import androidx.compose.animation.core.infiniteRepeatable

import androidx.compose.animation.core.rememberInfiniteTransition

import androidx.compose.animation.core.tween

import androidx.compose.foundation.Canvas

import androidx.compose.foundation.clickable

import androidx.compose.foundation.horizontalScroll

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Box

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.Row

import androidx.compose.foundation.layout.fillMaxSize

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.lazy.LazyColumn

import androidx.compose.foundation.lazy.items

import androidx.compose.foundation.lazy.rememberLazyListState

import androidx.compose.foundation.rememberScrollState

import androidx.compose.foundation.text.selection.SelectionContainer

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.outlined.Block

import androidx.compose.material.icons.outlined.Bolt

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

import androidx.compose.material.icons.outlined.Error

import androidx.compose.material.icons.outlined.HourglassEmpty

import androidx.compose.material.icons.outlined.PlayCircle

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

import androidx.compose.material.icons.outlined.Replay

import androidx.compose.material.icons.outlined.RocketLaunch

import androidx.compose.material3.AlertDialog

import androidx.compose.material3.Button

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.IconButton

import androidx.compose.material3.ListItem

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

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.graphics.Color

import androidx.compose.ui.graphics.drawscope.Stroke

import androidx.compose.ui.graphics.vector.ImageVector

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

import androidx.compose.ui.unit.dp

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import io.oxygenhub.android.api.FlowJob

import io.oxygenhub.android.api.FlowRun

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

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

import io.oxygenhub.android.ui.common.ErrorState

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

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

import io.oxygenhub.android.ui.common.LoadingState

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

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

/** A status's icon and colour, as the hub's run pages show them. */

@Composable

fun statusLook(status: String): Pair<ImageVector, Color> {

    val c = LocalStatusColors.current

    return when (status) {

        "passed" -> Icons.Outlined.CheckCircle to c.ok

        "failed", "error" -> Icons.Outlined.Error to c.bad

        "running" -> Icons.Outlined.PlayCircle to c.warn

        "cancelled" -> Icons.Outlined.Block to MaterialTheme.colorScheme.onSurfaceVariant

        "skipped" -> Icons.Outlined.RemoveCircleOutline to MaterialTheme.colorScheme.onSurfaceVariant

        else -> Icons.Outlined.HourglassEmpty to MaterialTheme.colorScheme.onSurfaceVariant

    }

}

/**

 * A status's icon; a live one pulses, a ring breathing out from it in its

 * colour (#23), as live things pulse on the hub's pages.

 */

@Composable

fun StatusIcon(status: String, icon: ImageVector, colour: Color) {

    Box(contentAlignment = Alignment.Center) {

        if (status == "running") {

            val t by rememberInfiniteTransition(label = "live").animateFloat(

                0f,

                1f,

                infiniteRepeatable(tween(1400, easing = LinearOutSlowInEasing)),

                label = "pulse",

            )

            Canvas(Modifier.size(24.dp)) {

                drawCircle(colour.copy(alpha = 0.45f * (1 - t)), radius = size.minDimension / 2 * (0.8f + 0.9f * t), style = Stroke(2.dp.toPx()))

            }

        }

        Icon(icon, contentDescription = status, tint = colour)

    }

}

/** A repository's runs, for its tab. */

@Composable

fun RunList(vm: RunsViewModel, onOpen: (FlowRun) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

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

        if (runs.isEmpty()) {

            EmptyState(Icons.Outlined.RocketLaunch, "No runs yet", "A push to ${vm.owner}/${vm.name} with a .flow/pipeline.kdl starts one.")

        } else {

            LazyColumn(Modifier.fillMaxSize()) {

                items(runs, key = { it.number }) { r ->

                    val (icon, colour) = statusLook(r.status)

                    ListItem(

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

                        leadingContent = { StatusIcon(r.status, icon, colour) },

                        headlineContent = { Text("#${r.number} ${r.bookmark}") },

                        supportingContent = {

                            Text(

                                listOfNotNull(

                                    r.status,

                                    "${r.trigger} by ${r.actor}",

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

                                    r.queuePosition?.let { "#$it in the queue" },

                                ).joinToString(" · "),

                            )

                        },

                    )

                    HorizontalDivider()

                }

            }

        }

    }

}

/** A run: its jobs, refreshed while it is live; rerun or cancel it. */

@Composable

fun RunScreen(vm: RunViewModel, canWrite: Boolean, onBack: () -> Unit, onOpenJob: (FlowJob) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    val error by vm.error.collectAsStateWithLifecycle()

    val run = (state as? Load.Ready)?.value

    var expediting by rememberSaveable { mutableStateOf(false) }

    AppScreen(

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

        subtitle = listOfNotNull("${vm.owner}/${vm.name}", run?.bookmark, run?.status).joinToString(" · "),

        onBack = onBack,

        actions = {

            if (canWrite && run != null) {

                if (run.live) {

                    IconButton(onClick = { expediting = true }) { Icon(Icons.Outlined.Bolt, contentDescription = "Expedite the run") }

                    IconButton(onClick = vm::cancel) { Icon(Icons.Outlined.Block, contentDescription = "Cancel the run") }

                } else {

                    IconButton(onClick = vm::rerun) { Icon(Icons.Outlined.Replay, contentDescription = "Run it again") }

                }

            }

        },

    ) {

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

            LazyColumn(Modifier.fillMaxSize()) {

                if (r.error.isNotEmpty()) item { Text(r.error, color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(16.dp)) }

                error?.let { item { Text(it, color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(16.dp)) } }

                items(r.jobs, key = { it.name }) { j ->

                    val (icon, colour) = statusLook(j.status)

                    ListItem(

                        modifier = Modifier.clickable { onOpenJob(j) },

                        leadingContent = { StatusIcon(j.status, icon, colour) },

                        headlineContent = { Text(j.name) },

                        supportingContent = {

                            Column {

                                Text(

                                    listOfNotNull(

                                        j.status,

                                        j.seconds()?.let { "$it s" },

                                        j.runner.takeIf { it.isNotEmpty() }?.let { "on $it" },

                                        j.exitCode?.let { "exit $it" },

                                    ).joinToString(" · "),

                                )

                                if (j.waiting.isNotEmpty()) Text(j.waiting, style = MaterialTheme.typography.bodySmall)

                                // A job that waits for a person (#5): the hub's rules decide who may.

                                if (canWrite && j.waitsForPerson) {

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

                                        Button(onClick = { vm.decide(j.name, approve = true) }) { Text("Approve") }

                                        OutlinedButton(onClick = { vm.decide(j.name, approve = false) }) { Text("Reject") }

                                    }

                                }

                                if (j.error.isNotEmpty()) Text(j.error, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.error)

                            }

                        },

                        trailingContent = if (canWrite && !j.live && !r.live) {

                            { IconButton(onClick = { vm.rerunJob(j.name) }) { Icon(Icons.Outlined.Replay, contentDescription = "Run ${j.name} again") } }

                        } else {

                            null

                        },

                    )

                    HorizontalDivider()

                }

            }

        }

    }

    if (expediting) {

        ExpediteDialog(onDismiss = { expediting = false }, onExpedite = { reason -> expediting = false; vm.expedite(reason) })

    }

}

/** Make a run urgent, saying why (#5): a maintainer's, within the owner's cap of urgent runs. */

@Composable

private fun ExpediteDialog(onDismiss: () -> Unit, onExpedite: (String) -> Unit) {

    var reason by rememberSaveable { mutableStateOf("") }

    AlertDialog(

        onDismissRequest = onDismiss,

        title = { Text("Expedite") },

        text = {

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

                Text("It goes ahead of everyday work until it ends. Say why: it is shown on the run and audited.", style = MaterialTheme.typography.bodySmall)

                OutlinedTextField(value = reason, onValueChange = { reason = it.take(200) }, label = { Text("Why it is urgent") }, singleLine = true)

            }

        },

        confirmButton = { TextButton(onClick = { onExpedite(reason) }, enabled = reason.isNotBlank()) { Text("Expedite") } },

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

    )

}

/** A job's log, following new lines while it runs. */

@Composable

fun JobLogScreen(vm: JobLogViewModel, onBack: () -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    val list = rememberLazyListState()

    val status = LocalStatusColors.current

    val log = (state as? Load.Ready)?.value

    // Follow the end while the job runs.

    LaunchedEffect(log?.lines?.size) {

        if (log != null && log.live && log.lines.isNotEmpty()) list.scrollToItem(log.lines.size - 1)

    }

    AppScreen(title = vm.job, subtitle = listOfNotNull("${vm.owner}/${vm.name} #${vm.number}", log?.status).joinToString(" · "), onBack = onBack) {

        when (val s = state) {

            Load.Loading -> LoadingState()

            is Load.Failed -> ErrorState(s.message, onRetry = vm::retry)

            is Load.Ready -> SelectionContainer {

                LazyColumn(Modifier.fillMaxSize().horizontalScroll(rememberScrollState()), state = list) {

                    items(s.value.lines, key = { it.seq }) { l ->

                        Row(Modifier.padding(horizontal = 8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                            Text(

                                "%.1fs".format(l.t / 1000.0),

                                modifier = Modifier.width(56.dp),

                                fontFamily = FontFamily.Monospace,

                                style = MaterialTheme.typography.bodySmall,

                                color = MaterialTheme.colorScheme.outline,

                            )

                            Text(

                                l.text,

                                fontFamily = FontFamily.Monospace,

                                style = MaterialTheme.typography.bodySmall,

                                softWrap = false,

                                color = when (l.stream) {

                                    "stderr" -> status.bad

                                    "flow" -> MaterialTheme.colorScheme.primary

                                    else -> MaterialTheme.colorScheme.onSurface

                                },

                            )

                        }

                    }

                    if (s.value.live) item { Text("…", modifier = Modifier.fillMaxWidth().padding(8.dp)) }

                }

            }

        }

    }

}