Pith - spline
package com.vgmlr.spline

import android.Manifest
import android.os.Build
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Download
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.drawBehind
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalUriHandler
import androidx.compose.ui.platform.UriHandler
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import kotlin.math.roundToInt
import kotlin.random.Random

private val LIST_PAD = 6.dp
private val TOP_PAD = 2.dp
private val CARD_GAP = 10.dp
private val CARD_PAD = 12.dp
private val TILE_GAP = 10.dp
private val GAP_M = 10.dp
private val ACT_ICON = 18.dp
private val ACT_ICON_GAP = 6.dp
private const val FILL_MS = 400
private const val FADE = 0.35f
private const val DESC_ALPHA = 0.65f
private const val ID_ALPHA = 0.45f
private const val TONE_S = 0.40f // tone saturation
private const val TONE_V = 0.45f // tone value
private val GET_W = 112.dp
private val VER_H = 18.75.dp // name row
private val ACT_H = 28.75.dp // id, desc rows
private val TILE = VER_H + ACT_H // text height
private val VER_GAP = 5.dp // version-button space
private val BTN_H = ACT_H + CARD_PAD - VER_GAP // button height
private val SPINE_X = BAR_INSET_H + CARD_PAD + TILE / 2 // icon center
private val SpineInk = CMuted.copy(alpha = 0.50f) // spine opacity

private val CardBg = Color(0xFF151617)
private val ListInk = Color(0xFFEFEFEF)

private val NAME_FS = 15.sp
private val ID_FS = 11.sp
private val DESC_FS = 12.sp
private val ACT_FS = 13.sp
private const val LH = 1.25f // line height

@Composable
internal fun SplineHomeScreen(vm: SplineViewModel, onSettings: () -> Unit) {
    val entries by vm.entries.collectAsState()
    val updates by vm.updates.collectAsState()
    val failed by vm.failed.collectAsState()
    val busy by vm.busy.collectAsState()
    val progress by vm.progress.collectAsState()
    val uriHandler = LocalUriHandler.current
    val ctx = LocalContext.current

    var showVersion by remember { mutableStateOf(false) }
    var confirm by remember { mutableStateOf<SplineApp?>(null) }
    var waiting by remember { mutableStateOf<SplineApp?>(null) }
    val tones = remember { mutableMapOf<String, Color>() }

    val sources = rememberLauncherForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) {
        val app = waiting
        waiting = null
        if (app != null && SplineInstall.canInstall(ctx)) vm.get(app)
    }

    val title = when {
        failed -> "Failed"
        updates == 1 -> "1 Update"
        updates > 1 -> "$updates Updates"
        else -> "spline"
    }

    val top = WindowInsets.statusBars.asPaddingValues().calculateTopPadding()
    val bottom = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding()

    Box(
        Modifier
            .fillMaxSize()
            .background(Ink)
            .drawBehind {
                val x = SPINE_X.toPx()
                drawLine(
                    SpineInk,
                    Offset(x, 0f),
                    Offset(x, size.height),
                    EDGE.width.toPx()
                )
            }
    ) {
        LazyColumn(
            modifier = Modifier.fillMaxSize(),
            contentPadding = PaddingValues(
                start = BAR_INSET_H,
                end = BAR_INSET_H,
                top = top + TOP_BAR_H + TOP_PAD,
                bottom = bottom + LIST_PAD
            ),
            verticalArrangement = Arrangement.spacedBy(CARD_GAP)
        ) {
            items(entries, key = { it.app.id }) { e ->
                AppCard(
                    e,
                    tone = tones.getOrPut(e.app.id) { tone() },
                    busy = e.app.id in busy,
                    progress = progress[e.app.id],
                    onInfo = { open(uriHandler, e.app.url) },
                    onGet = { confirm = e.app }
                )
            }
        }
        SplineTopBar(title, onSettings = onSettings, onVersion = { showVersion = true })
    }

    confirm?.let { app ->
        SplineAlert(
            text = "Download ${app.name} ${app.version}?",
            confirm = "Install",
            onConfirm = {
                confirm = null
                if (SplineInstall.canInstall(ctx)) vm.get(app)
                else {
                    waiting = app
                    sources.launch(SplineInstall.sources(ctx))
                }
            },
            dismiss = "Abort",
            onDismiss = { confirm = null }
        )
    }

    VersionDialog(showVersion, onDismiss = { showVersion = false }, uriHandler = uriHandler)
}

@Composable
private fun AppCard(
    e: SplineEntry,
    tone: Color,
    busy: Boolean,
    progress: Float?,
    onInfo: () -> Unit,
    onGet: () -> Unit
) {
    val shape = RoundedCornerShape(ROUND_END)
    Row(
        Modifier
            .fillMaxWidth()
            .height(IntrinsicSize.Min),
        verticalAlignment = Alignment.CenterVertically
    ) {
        Box(
            Modifier
                .clip(shape)
                .background(CardBg)
                .border(EDGE.width, SpineInk, shape)
                .padding(CARD_PAD)
        ) {
            SplineIcon(e.app.icon, Modifier.size(TILE))
        }
        Spacer(Modifier.width(TILE_GAP))
        Column(
            Modifier
                .weight(1f)
                .fillMaxHeight()
                .padding(vertical = CARD_PAD),
            verticalArrangement = Arrangement.SpaceBetween
        ) {
            Text(
                e.app.name,
                Modifier.clickable(enabled = e.app.url.isNotBlank(), onClick = onInfo),
                color = ListInk,
                fontSize = NAME_FS,
                lineHeight = NAME_FS * LH,
                fontWeight = FontWeight.Medium,
                maxLines = 1,
                overflow = TextOverflow.Ellipsis
            )
            Text(
                e.app.id,
                color = ListInk.copy(alpha = ID_ALPHA),
                fontSize = ID_FS,
                lineHeight = ID_FS * LH,
                maxLines = 1,
                overflow = TextOverflow.Ellipsis
            )
            Text(
                e.app.desc,
                color = ListInk.copy(alpha = DESC_ALPHA),
                fontSize = DESC_FS,
                lineHeight = DESC_FS * LH,
                maxLines = 1,
                overflow = TextOverflow.Ellipsis
            )
        }
        Spacer(Modifier.width(GAP_M))
        GetButton(Modifier.width(GET_W).height(BTN_H), e, tone, busy, progress, onGet)
    }
}

@Composable
private fun GetButton(
    modifier: Modifier,
    e: SplineEntry,
    tone: Color,
    busy: Boolean,
    progress: Float?,
    onClick: () -> Unit
) {
    val shape = RoundedCornerShape(ROUND_END)
    val get = e.local == null || e.newer
    val loading = busy || progress != null
    val p = (progress ?: 0f).coerceIn(0f, 1f)
    val fill by animateFloatAsState(p, tween(FILL_MS), label = "fill")
    Box(
        modifier
            .clip(shape)
            .background(
                when {
                    loading -> CChip
                    get -> tone
                    else -> Color.Transparent
                }
            )
            .border(EDGE.width, SpineInk, shape)
            .clickable(enabled = get && !loading, onClick = onClick),
        contentAlignment = Alignment.Center
    ) {
        if (loading) {
            Box(
                Modifier
                    .align(Alignment.CenterStart)
                    .fillMaxHeight()
                    .fillMaxWidth(fill)
                    .background(tone)
            )
            ActLabel(if (p >= 1f) "Installing" else "${(p * 100).roundToInt()}%", TopBarFg, mono = true)
        } else {
            val ink = if (get) TopBarFg else ListInk.copy(alpha = FADE)
            val ver = if (get) e.app.version else e.local
            Row(verticalAlignment = Alignment.CenterVertically) {
                Icon(
                    if (get) Icons.Filled.Download else Icons.Filled.Check,
                    null,
                    Modifier.size(ACT_ICON),
                    tint = ink
                )
                Spacer(Modifier.width(ACT_ICON_GAP))
                ActLabel(ver, ink, mono = true)
            }
        }
    }
}

@Composable
private fun ActLabel(text: String, ink: Color, mono: Boolean = false) {
    Text(
        text,
        color = ink,
        fontSize = ACT_FS,
        fontFamily = if (mono) FontFamily.Monospace else FontFamily.Default,
        fontWeight = FontWeight.Medium,
        maxLines = 1,
        overflow = TextOverflow.Ellipsis
    )
}

private fun tone(): Color = Color.hsv(Random.nextFloat() * 360f, TONE_S, TONE_V)

private fun open(uriHandler: UriHandler, url: String) {
    if (url.isBlank()) return
    runCatching { uriHandler.openUri(url) }
}

@Composable
internal fun SplineAlert(
    text: String,
    confirm: String,
    onConfirm: () -> Unit,
    dismiss: String? = null,
    onDismiss: () -> Unit
) {
    AlertDialog(
        onDismissRequest = onDismiss,
        modifier = Modifier.border(EDGE, RoundedCornerShape(ROUND_END)),
        shape = RoundedCornerShape(ROUND_END),
        containerColor = AlertCard,
        confirmButton = { AlertButton(confirm, onConfirm) },
        dismissButton = dismiss?.let { label -> { AlertButton(label, onDismiss) } },
        text = { Text(text, fontSize = 17.sp) }
    )
}

@Composable
private fun AlertButton(label: String, onClick: () -> Unit) {
    Button(
        onClick = onClick,
        modifier = Modifier.height(44.dp),
        colors = ButtonDefaults.buttonColors(containerColor = CChip, contentColor = CText),
        shape = RoundedCornerShape(ROUND_END)
    ) { Text(label, color = CText, fontSize = 15.sp) }
}

@Composable
internal fun SplinePermit(onDone: () -> Unit) {
    val ctx = LocalContext.current
    var asking by remember { mutableStateOf(true) }

    val sources = rememberLauncherForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { onDone() }

    fun next() {
        if (SplineInstall.canInstall(ctx)) onDone()
        else sources.launch(SplineInstall.sources(ctx))
    }

    val notify = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { next() }

    if (asking) SplineAlert(
        text = "Spline requires permission for notifications and app installation.",
        confirm = "Submit",
        onConfirm = {
            asking = false
            SplinePrefs.setPermitAsked(ctx) // survive kill
            if (Build.VERSION.SDK_INT >= 33) notify.launch(Manifest.permission.POST_NOTIFICATIONS)
            else next()
        },
        dismiss = "Never",
        onDismiss = {
            asking = false
            onDone()
        }
    )
}