package io.oxygenhub.android.ui.code

import androidx.compose.foundation.background

import androidx.compose.foundation.clickable

import androidx.compose.foundation.horizontalScroll

import androidx.compose.foundation.isSystemInDarkTheme

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

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.layout.width

import androidx.compose.foundation.lazy.LazyColumn

import androidx.compose.foundation.lazy.itemsIndexed

import androidx.compose.foundation.lazy.items

import androidx.compose.foundation.rememberScrollState

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

import androidx.compose.material.icons.Icons

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

import androidx.compose.material.icons.outlined.ExpandLess

import androidx.compose.material.icons.outlined.ExpandMore

import androidx.compose.material.icons.outlined.History

import androidx.compose.material3.FilterChip

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.material3.TextButton

import androidx.compose.runtime.Composable

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

import androidx.compose.ui.graphics.Color

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

import androidx.compose.ui.text.style.TextAlign

import androidx.compose.ui.unit.dp

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import com.mikepenz.markdown.m3.Markdown

import io.oxygenhub.android.api.ChangeSummary

import io.oxygenhub.android.api.DiffLine

import io.oxygenhub.android.api.FileChange

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

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

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

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

/** A file at a reference: highlighted with line numbers, or rendered when it is Markdown. */

@Composable

fun FileScreen(vm: FileViewModel, onBack: () -> Unit, onOpenHistory: () -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    var rendered by rememberSaveable { mutableStateOf(vm.isMarkdown) }

    AppScreen(

        title = vm.path.substringAfterLast('/'),

        subtitle = "${vm.owner}/${vm.name} · ${vm.ref.take(24)} · ${vm.path}",

        onBack = onBack,

        actions = {

            IconButton(onClick = onOpenHistory) { Icon(Icons.Outlined.History, contentDescription = "This file's history") }

        },

    ) {

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

            Column {

                if (vm.isMarkdown) {

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

                        FilterChip(selected = rendered, onClick = { rendered = true }, label = { Text("Rendered") })

                        FilterChip(selected = !rendered, onClick = { rendered = false }, label = { Text("Source") })

                    }

                }

                if (vm.isMarkdown && rendered) {

                    LazyColumn { item { Box(Modifier.padding(16.dp)) { Markdown(text) } } }

                } else {

                    CodeView(text, vm.path)

                }

            }

        }

    }

}

/** Lines with their numbers, highlighted, scrolling sideways together. */

@Composable

fun CodeView(text: String, path: String) {

    val dark = isSystemInDarkTheme()

    val lines = remember(text, path, dark) { highlightLines(text.trimEnd('\n'), path, dark) }

    val numbers = lines.size.toString().length

    val sideways = rememberScrollState()

    SelectionContainer {

        LazyColumn(Modifier.fillMaxWidth().horizontalScroll(sideways)) {

            itemsIndexed(lines) { i, line ->

                Row {

                    Text(

                        (i + 1).toString(),

                        modifier = Modifier.width((numbers * 9 + 16).dp).padding(end = 8.dp),

                        textAlign = TextAlign.End,

                        fontFamily = FontFamily.Monospace,

                        style = MaterialTheme.typography.bodySmall,

                        color = MaterialTheme.colorScheme.outline,

                    )

                    Text(line, fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.bodySmall, softWrap = false)

                }

            }

        }

    }

}

/** A reference's history, or a file's, newest first. */

@Composable

fun HistoryScreen(vm: HistoryViewModel, onBack: () -> Unit, onOpenChange: (ChangeSummary) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    AppScreen(title = "History", subtitle = listOfNotNull("${vm.owner}/${vm.name}", vm.ref.take(24), vm.path).joinToString(" · "), onBack = onBack) {

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

            LazyColumn {

                items(page.changes, key = { it.hash }) { c -> ChangeRow(c) { onOpenChange(c) } }

                if (page.hasMore) {

                    item {

                        TextButton(onClick = vm::more, enabled = !page.loadingMore, modifier = Modifier.fillMaxWidth()) {

                            Text(if (page.loadingMore) "Loading…" else page.moreFailed ?: "Older changes (${page.total - page.changes.size} more)")

                        }

                    }

                }

            }

        }

    }

}

@Composable

private fun ChangeRow(c: ChangeSummary, onClick: () -> Unit) {

    ListItem(

        modifier = Modifier.clickable(onClick = onClick),

        headlineContent = { Text(c.subject.ifEmpty { "(no message)" }, maxLines = 2) },

        supportingContent = { Text("${c.author.account ?: c.author.name} · ${relativeTime(c.whenMs)}") },

        trailingContent = { Text(c.short.take(8), fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.labelSmall) },

    )

    HorizontalDivider()

}

/** Files a change touched whose diffs open by default: all of them for a small change. */

fun openByDefault(files: List<FileChange>): Set<String> =

    if (files.size <= 5 && files.sumOf { it.lines.size } <= 400) files.map { it.path }.toSet() else emptySet()

/** One change: its message, where it is, and the files it touched, each with its diff and a way to the file at the change. */

@Composable

fun ChangeScreen(vm: ChangeViewModel, onBack: () -> Unit, onOpenFile: (path: String) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    val status = LocalStatusColors.current

    AppScreen(title = vm.hash.take(12), subtitle = "${vm.owner}/${vm.name}", onBack = onBack) {

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

            var open by rememberSaveable(d.change.hash) { mutableStateOf(openByDefault(d.files).toList()) }

            LazyColumn {

                item {

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

                        Text(d.change.subject, style = MaterialTheme.typography.titleMedium)

                        Text(

                            "${d.change.author.account ?: d.change.author.name} · ${relativeTime(d.change.whenMs)}",

                            style = MaterialTheme.typography.bodySmall,

                            color = MaterialTheme.colorScheme.onSurfaceVariant,

                        )

                        val rest = d.change.message.lines().drop(1).joinToString("\n").trim()

                        if (rest.isNotEmpty()) Markdown(rest)

                        val where = d.inBookmarks.map { it } + d.inTags.map { "tag $it" }

                        if (where.isNotEmpty()) Text("In " + where.joinToString(", "), style = MaterialTheme.typography.bodySmall)

                    }

                    HorizontalDivider()

                }

                d.files.forEach { f ->

                    val expanded = f.path in open

                    item(key = f.path) {

                        FileRow(

                            f,

                            expanded,

                            status.ok,

                            status.bad,

                            onToggle = { open = if (expanded) open - f.path else open + f.path },

                            onOpen = if (f.kind != "removed") ({ onOpenFile(f.path) }) else null,

                        )

                    }

                    if (expanded) {

                        val numbers = f.lines.maxOfOrNull { maxOf(it.old ?: 0, it.new ?: 0) }?.toString()?.length ?: 1

                        itemsIndexed(f.lines, key = { i, _ -> "${f.path}\u0000$i" }) { _, l -> DiffRow(l, numbers, status.ok, status.bad) }

                        if (f.lines.isEmpty() || f.truncated) {

                            item(key = "${f.path}\u0000end") {

                                Text(

                                    if (f.truncated) "The diff goes on; open the file to see it whole." else "No lines changed (${f.kind}).",

                                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),

                                    style = MaterialTheme.typography.bodySmall,

                                    color = MaterialTheme.colorScheme.onSurfaceVariant,

                                )

                            }

                        }

                        item(key = "${f.path}\u0000rule") { HorizontalDivider() }

                    }

                }

            }

        }

    }

}

@Composable

private fun FileRow(

    f: FileChange,

    expanded: Boolean,

    added: Color,

    removed: Color,

    onToggle: () -> Unit,

    onOpen: (() -> Unit)?,

) {

    ListItem(

        modifier = Modifier.clickable(onClick = onToggle),

        leadingContent = {

            Icon(

                if (expanded) Icons.Outlined.ExpandLess else Icons.Outlined.ExpandMore,

                contentDescription = if (expanded) "Hide the diff" else "Show the diff",

            )

        },

        headlineContent = { Text(f.path) },

        supportingContent = {

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

                Text(if (f.kind == "renamed") "renamed from ${f.from}" else f.kind)

                Text("+${f.added}", color = added)

                Text("−${f.removed}", color = removed)

            }

        },

        trailingContent = onOpen?.let { open ->

            { IconButton(onClick = open) { Icon(Icons.AutoMirrored.Outlined.OpenInNew, contentDescription = "The file at this change") } }

        },

    )

}

/** A diff line: old and new numbers, then the text on a tint of its kind; long lines wrap. */

@Composable

private fun DiffRow(l: DiffLine, numbers: Int, added: Color, removed: Color) {

    val tint = when (l.kind) {

        "add" -> added.copy(alpha = 0.14f)

        "del" -> removed.copy(alpha = 0.14f)

        "gap" -> MaterialTheme.colorScheme.surfaceVariant

        else -> Color.Transparent

    }

    val gutter = Modifier.width((numbers * 8 + 8).dp).padding(end = 4.dp)

    val small = MaterialTheme.typography.bodySmall

    Row(Modifier.fillMaxWidth().background(tint).padding(horizontal = 8.dp)) {

        if (l.kind == "gap") {

            Text("⋯", modifier = Modifier.padding(vertical = 2.dp), style = small, color = MaterialTheme.colorScheme.onSurfaceVariant)

            return@Row

        }

        Text(l.old?.toString() ?: "", gutter, textAlign = TextAlign.End, fontFamily = FontFamily.Monospace, style = small, color = MaterialTheme.colorScheme.outline)

        Text(l.new?.toString() ?: "", gutter, textAlign = TextAlign.End, fontFamily = FontFamily.Monospace, style = small, color = MaterialTheme.colorScheme.outline)

        Text(

            when (l.kind) {

                "add" -> "+"

                "del" -> "−"

                else -> " "

            },

            Modifier.width(12.dp),

            fontFamily = FontFamily.Monospace,

            style = small,

            color = if (l.kind == "add") added else if (l.kind == "del") removed else MaterialTheme.colorScheme.outline,

        )

        Text(l.text, Modifier.weight(1f), fontFamily = FontFamily.Monospace, style = small)

    }

}