Pith - spline
package com.vgmlr.spline

import android.content.Context
import android.graphics.BitmapFactory
import android.util.LruCache
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.produceState
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.platform.LocalContext
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.File
import java.io.IOException
import java.net.HttpURLConnection
import java.net.URL
import java.security.MessageDigest
import kotlin.math.min

internal object SplineIcons {
    private const val DIR = "icons"
    private const val TARGET = 256
    private const val TIMEOUT = 15_000
    private val mem = LruCache<String, ImageBitmap>(64)

    fun peek(url: String): ImageBitmap? = if (url.isBlank()) null else mem.get(url)

    suspend fun load(ctx: Context, url: String): ImageBitmap? {
        if (url.isBlank()) return null
        mem.get(url)?.let { return it }
        return withContext(Dispatchers.IO) {
            val dir = File(ctx.cacheDir, DIR).apply { mkdirs() }
            val f = File(dir, key(url))
            val disk = if (f.isFile) runCatching { f.readBytes() }.getOrNull() else null
            val bytes = disk ?: fetch(url) ?: return@withContext null
            val img = decode(bytes)
            when {
                img == null -> f.delete()
                disk == null -> store(dir, f, bytes)
            }
            img?.also { mem.put(url, it) }
        }
    }

    private fun key(url: String): String =
        MessageDigest.getInstance("SHA-1").digest(url.toByteArray())
            .joinToString("") { "%02x".format(it) }

    private fun store(dir: File, f: File, bytes: ByteArray) {
        try {
            val tmp = File.createTempFile("icon", ".tmp", dir)
            tmp.writeBytes(bytes)
            if (!tmp.renameTo(f)) tmp.delete()
        } catch (e: IOException) {
            // skip cache
        }
    }

    private fun decode(b: ByteArray): ImageBitmap? {
        val o = BitmapFactory.Options().apply { inJustDecodeBounds = true }
        BitmapFactory.decodeByteArray(b, 0, b.size, o)
        if (o.outWidth <= 0 || o.outHeight <= 0) return null
        var s = 1
        while (min(o.outWidth, o.outHeight) / (s * 2) >= TARGET) s *= 2
        val opts = BitmapFactory.Options().apply { inSampleSize = s }
        return BitmapFactory.decodeByteArray(b, 0, b.size, opts)?.asImageBitmap()
    }

    private fun fetch(url: String): ByteArray? =
        try {
            val c = URL(url).openConnection() as HttpURLConnection
            try {
                c.connectTimeout = TIMEOUT
                c.readTimeout = TIMEOUT
                if (c.responseCode == HttpURLConnection.HTTP_OK) {
                    c.inputStream.use { it.readBytes() }
                } else null
            } finally {
                c.disconnect()
            }
        } catch (e: IOException) {
            null
        }
}

@Composable
internal fun SplineIcon(url: String, modifier: Modifier = Modifier) {
    val ctx = LocalContext.current.applicationContext
    val img by produceState(SplineIcons.peek(url), url) {
        if (value == null) value = SplineIcons.load(ctx, url)
    }
    Box(modifier) {
        img?.let { Image(it, null, Modifier.fillMaxSize()) }
    }
}