Coverage / app/src/main/java/io/oxygenhub/android/update/AppUpdate.kt 45.7%

package io.oxygenhub.android.update

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.outlined.SystemUpdate

import androidx.compose.material3.Card

import androidx.compose.material3.Icon

import androidx.compose.material3.ListItem

import androidx.compose.material3.Text

import androidx.compose.material3.TextButton

import androidx.compose.runtime.Composable

import androidx.compose.runtime.getValue

import androidx.compose.runtime.produceState

import androidx.compose.runtime.remember

import androidx.compose.ui.Modifier

import androidx.compose.ui.platform.LocalContext

import androidx.compose.ui.platform.LocalUriHandler

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.Release

/** Where the app's own releases are (#7), built and signed by OxygenFlow. */

const val APP_HUB = "https://oxygenhub.io"

const val APP_OWNER = "andymccall"

const val APP_REPO = "oxygenhub-android"

/** `v1.2.3` or `1.2.3` as numbers; null for anything else (a pre-release such as `1.2.3-rc1`). */

fun versionOf(text: String): List<Int>? {

    val parts = text.trim().removePrefix("v").split(".")

    if (parts.size != 3) return null

    return parts.map { p -> p.toIntOrNull()?.takeIf { it >= 0 } ?: return null }

}

/** Whether [candidate] is a later version than [installed]. */

fun isNewer(candidate: String, installed: String): Boolean {

    val a = versionOf(candidate) ?: return false

    val b = versionOf(installed) ?: return true

    return a.zip(b).firstOrNull { (x, y) -> x != y }?.let { (x, y) -> x > y } ?: false

}

/** An update: the newest full release later than [installed], with its APK's address. */

data class Update(val version: String, val apkUrl: String, val pageUrl: String)

/** The newest full release of [releases] later than [installed] that carries an APK, if any. */

fun updateFrom(releases: List<Release>, installed: String, hub: String = APP_HUB): Update? {

    val newest = releases

        .filter { !it.prerelease && versionOf(it.tag) != null }

        .maxWithOrNull { a, b -> if (isNewer(a.tag, b.tag)) 1 else if (isNewer(b.tag, a.tag)) -1 else 0 }

        ?: return null

    if (!isNewer(newest.tag, installed)) return null

    val apk = newest.assets.firstOrNull { it.name.endsWith(".apk") } ?: return null

    fun absolute(u: String) = if (u.startsWith("http")) u else hub.trimEnd('/') + "/" + u.trimStart('/')

    val page = newest.url.ifEmpty { "/$APP_OWNER/$APP_REPO/releases" }

    return Update(newest.tag.removePrefix("v"), absolute(apk.url), absolute(page))

}

/**

 * The app's version and, when the hub signed in to is [APP_HUB] and it has

 * a later release, a link to its APK: Android installs it from the

 * download, as the same key signs every release.

 */

@Composable

fun UpdateCard(api: HubApi, hub: String) {

    val context = LocalContext.current

    val installed = remember(context) { context.packageManager.getPackageInfo(context.packageName, 0).versionName ?: "" }

    val update by produceState<Update?>(null, hub) {

        if (hub.trimEnd('/') == APP_HUB) {

            value = runCatching { updateFrom(api.releases(APP_OWNER, APP_REPO), installed) }.getOrNull()

        }

    }

    val uri = LocalUriHandler.current

    Card(Modifier.fillMaxWidth()) {

        ListItem(

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

            headlineContent = { Text(update?.let { "Version ${it.version} is out" } ?: "OxygenHub $installed") },

            supportingContent = {

                Text(if (update != null) "You have $installed. Download it and open the file to update." else "Releases are at $APP_HUB/$APP_OWNER/$APP_REPO.")

            },

            trailingContent = update?.let { u -> { TextButton(onClick = { uri.openUri(u.apkUrl) }) { Text("Download") } } },

        )

    }

}