package io.oxygenhub.android.ui.flow

import androidx.compose.foundation.clickable

import androidx.compose.foundation.horizontalScroll

import androidx.compose.foundation.layout.Arrangement

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

import androidx.compose.runtime.Composable

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.graphics.Color

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 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 = { Icon(icon, contentDescription = r.status, tint = 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

    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 = 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 = { Icon(icon, contentDescription = j.status, tint = 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)

                                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()

                }

            }

        }

    }

}

/** 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)) }

                }

            }

        }

    }

}