package dev.stave.upnp
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.File
import java.io.IOException
import java.net.Inet4Address
import java.net.InetAddress
import java.net.URI
import java.util.concurrent.TimeUnit
/**
* Locate prose notes for an album. Port of Android's `AlbumInfoLoader`
* (README: "Album notes. AlbumInfoLoader reads ID3 / Vorbis comments and
* sibling .txt notes").
*
* Source priority:
* 1. **ID3 COMMENT / Vorbis DESCRIPTION** embedded in the track's audio file.
* [AudioMetadataReader] surfaces these under the display key "Comment".
* Most ripped-from-CD libraries store album reviews and liner notes here.
* 2. **Sibling `.txt` file** alongside the audio: `<track>.txt`, then
* `review.txt`, `info.txt`, `notes.txt` in the same folder. A few UPnP
* servers (notably MinimServer) expose adjacent filesystem entries; many do
* not, in which case the fetch quietly 404s and we return null.
*
* Best-effort: any failure (network, parse, missing tag) collapses to null and
* the UI shows its "no album notes" state.
*
* Desktop differences from Android:
* - `file:` tracks (dropped files, local M3U entries) read their sibling notes
* straight from disk; OkHttp can't fetch `file:`.
* - Bodies are capped at [MAX_NOTE_BYTES] (as the tag reader caps tags), and
* only `text/plain` (or untyped) responses count, so a server's HTML 404 page
* is never shown as notes.
* - Redirects are not followed: the notes come from the same host that serves
* the music, never from somewhere it points to.
* - With "Allow external service calls" off, nothing is fetched from a host
* outside the local network (same rule as lyrics; see [isLanUrl]).
*/
class AlbumInfoLoader(
private val reader: AudioMetadataReader,
private val allowExternalCalls: () -> Boolean = { true },
) {
private val http: OkHttpClient = OkHttpClient.Builder()
.connectTimeout(5, TimeUnit.SECONDS)
.readTimeout(15, TimeUnit.SECONDS)
.writeTimeout(5, TimeUnit.SECONDS)
.followRedirects(false)
.followSslRedirects(false)
.build()
/**
* Returns the album-info text, or null when nothing is available.
*
* @param resourceUrl the streaming URL of any track in the album. Tags are
* read from this URL directly; the sibling `.txt` lookup replaces the
* file name with each candidate in turn.
*/
suspend fun load(resourceUrl: String): String? = withContext(Dispatchers.IO) {
val url = resourceUrl.trim()
val isFile = url.startsWith("file:", ignoreCase = true)
val isHttp = url.startsWith("http://", ignoreCase = true) ||
url.startsWith("https://", ignoreCase = true)
if (!isFile && !isHttp) return@withContext null
if (isHttp && !allowExternalCalls() && !isLanUrl(url)) return@withContext null
// 1. ID3 COMMENT / Vorbis DESCRIPTION via the existing reader.
val tags = try {
reader.readTags(url)
} catch (c: CancellationException) {
throw c
} catch (e: Exception) {
emptyMap()
}
tags["Comment"]?.trim()?.takeIf { it.isNotEmpty() }?.let { return@withContext it }
// 2. Sibling .txt file.
if (isFile) {
val track = try { File(URI(url)) } catch (e: IllegalArgumentException) { null }
?: return@withContext null
for (candidate in siblingNames(track.name)) {
val body = readLocalText(File(track.parentFile ?: return@withContext null, candidate))
if (!body.isNullOrEmpty()) return@withContext body
}
} else {
for (candidate in siblingTxtUrls(url)) {
val body = fetchText(candidate)
if (!body.isNullOrEmpty()) return@withContext body
}
}
null
}
/** Candidate file names, most specific first, so a generic `review.txt` never
* wins over the notes written for this exact file. */
private fun siblingNames(fileName: String): List<String> {
val basename = fileName.substringBeforeLast('.', fileName)
return listOf("$basename.txt", "review.txt", "info.txt", "notes.txt")
}
/** `http://server:port/path/to/track.flac?x` → `http://server:port/path/to/<candidate>`. */
private fun siblingTxtUrls(resourceUrl: String): List<String> {
val noQuery = resourceUrl.substringBefore('#').substringBefore('?')
val slash = noQuery.lastIndexOf('/')
// Need at least "scheme://host/" before the file name.
if (slash <= noQuery.indexOf("//") + 1) return emptyList()
val dir = noQuery.substring(0, slash + 1)
val filename = noQuery.substring(slash + 1)
if (filename.isEmpty()) return emptyList()
return siblingNames(filename).map { dir + it }
}
private fun fetchText(url: String): String? {
val req = try {
Request.Builder().url(url).build()
} catch (e: IllegalArgumentException) {
return null
}
return try {
http.newCall(req).execute().use { r ->
if (!r.isSuccessful) return null
val body = r.body ?: return null
val type = body.contentType()
if (type != null && !(type.type == "text" && type.subtype == "plain")) return null
val source = body.source()
source.request(MAX_NOTE_BYTES)
val n = minOf(source.buffer.size, MAX_NOTE_BYTES)
val charset = type?.charset(Charsets.UTF_8) ?: Charsets.UTF_8
String(source.buffer.readByteArray(n), charset).trim()
}
} catch (e: IOException) {
null
}
}
private fun readLocalText(f: File): String? {
if (!f.isFile) return null
return try {
f.inputStream().use { input ->
val bytes = input.readNBytes(MAX_NOTE_BYTES.toInt())
String(bytes, Charsets.UTF_8).trim()
}
} catch (e: IOException) {
null
} catch (e: SecurityException) {
null
}
}
companion object {
/** Notes are prose; 64 KB is several thousand words. */
const val MAX_NOTE_BYTES: Long = 64L * 1024
/** Same LAN rule as lyrics: delegates to the shared [dev.stave.net.UrlPolicy]
* (pure string checks, never DNS). */
internal fun isLanUrl(url: String): Boolean = dev.stave.net.UrlPolicy.isLanUrl(url)
}
}
