ultrasonic-app-subsonic-android/ultrasonic/src/main/kotlin/org/moire/ultrasonic/util/FileUtil.kt

/*
 * FileUtil.kt
 * Copyright (C) 2009-2021 Ultrasonic developers
 *
 * Distributed under terms of the GNU GPLv3 license.
 */

package org.moire.ultrasonic.util

import android.content.Context
import android.os.Build
import android.os.Environment
import android.text.TextUtils
import android.util.Pair
import java.io.BufferedWriter
import java.io.FileInputStream
import java.io.FileOutputStream
import java.io.FileWriter
import java.io.IOException
import java.io.ObjectInputStream
import java.io.ObjectOutputStream
import java.io.Serializable
import java.util.Locale
import java.util.SortedSet
import java.util.TreeSet
import java.util.regex.Pattern
import org.moire.ultrasonic.app.UApp
import org.moire.ultrasonic.domain.MusicDirectory
import org.moire.ultrasonic.util.Util.safeClose
import timber.log.Timber
import java.io.File

@Suppress("TooManyFunctions")
object FileUtil {

    private val FILE_SYSTEM_UNSAFE = arrayOf("/", "\\", "..", ":", "\"", "?", "*", "<", ">", "|")
    private val FILE_SYSTEM_UNSAFE_DIR = arrayOf("\\", "..", ":", "\"", "?", "*", "<", ">", "|")
    private val MUSIC_FILE_EXTENSIONS =
        listOf("mp3", "ogg", "aac", "flac", "m4a", "wav", "wma", "opus")
    private val VIDEO_FILE_EXTENSIONS =
        listOf("flv", "mp4", "m4v", "wmv", "avi", "mov", "mpg", "mkv")
    private val PLAYLIST_FILE_EXTENSIONS = listOf("m3u")
    private val TITLE_WITH_TRACK = Pattern.compile("^\\d\\d-.*")
    const val SUFFIX_LARGE = ".jpeg"
    const val SUFFIX_SMALL = ".jpeg-small"
    private const val UNNAMED = "unnamed"

    fun getSongFile(song: MusicDirectory.Entry): String {
        val dir = getAlbumDirectory(song)

        // Do not generate new name for offline files. Offline files will have their Path as their Id.
        if (!TextUtils.isEmpty(song.id)) {
            if (song.id.startsWith(dir)) return song.id
        }

        // Generate a file name for the song
        val fileName = StringBuilder(256)
        val track = song.track

        // check if filename already had track number
        if (song.title != null && !TITLE_WITH_TRACK.matcher(song.title!!).matches()) {
            if (track != null) {
                if (track < 10) {
                    fileName.append('0')
                }
                fileName.append(track).append('-')
            }
        }
        fileName.append(fileSystemSafe(song.title)).append('.')
        if (!TextUtils.isEmpty(song.transcodedSuffix)) {
            fileName.append(song.transcodedSuffix)
        } else {
            fileName.append(song.suffix)
        }
        return "$dir/$fileName"
    }

    @JvmStatic
    fun getPlaylistFile(server: String?, name: String?): File {
        val playlistDir = getPlaylistDirectory(server)
        return File(playlistDir, String.format(Locale.ROOT, "%s.m3u", fileSystemSafe(name)))
    }

    @JvmStatic
    val playlistDirectory: File
        get() {
            val playlistDir = File(ultrasonicDirectory, "playlists")
            ensureDirectoryExistsAndIsReadWritable(playlistDir)
            return playlistDir
        }

    @JvmStatic
    fun getPlaylistDirectory(server: String? = null): File {
        val playlistDir: File
        if (server != null) {
            playlistDir = File(playlistDirectory, server)
        } else {
            playlistDir = playlistDirectory
        }
        ensureDirectoryExistsAndIsReadWritable(playlistDir)
        return playlistDir
    }

    /**
     * Get the album art file for a given album entry
     * @param entry The album entry
     * @return File object. Not guaranteed that it exists
     */
    fun getAlbumArtFile(entry: MusicDirectory.Entry): String? {
        val albumDir = getAlbumDirectory(entry)
        return getAlbumArtFileForAlbumDir(albumDir)
    }

    /**
     * Get the cache key for a given album entry
     * @param entry The album entry
     * @param large Whether to get the key for the large or the default image
     * @return String The hash key
     */
    fun getAlbumArtKey(entry: MusicDirectory.Entry?, large: Boolean): String? {
        if (entry == null) return null
        val albumDir = getAlbumDirectory(entry)
        return getAlbumArtKey(albumDir, large)
    }

    /**
     * Get the cache key for a given artist
     * @param name The artist name
     * @param large Whether to get the key for the large or the default image
     * @return String The hash key
     */
    fun getArtistArtKey(name: String?, large: Boolean): String {
        val artist = fileSystemSafe(name)
        val dir = String.format(Locale.ROOT, "%s/%s/%s", musicDirectory.getPath(), artist, UNNAMED)
        return getAlbumArtKey(dir, large)
    }

    /**
     * Get the cache key for a given album entry
     * @param albumDir The album directory
     * @param large Whether to get the key for the large or the default image
     * @return String The hash key
     */
    private fun getAlbumArtKey(albumDirPath: String, large: Boolean): String {
        val suffix = if (large) SUFFIX_LARGE else SUFFIX_SMALL
        return String.format(Locale.ROOT, "%s%s", Util.md5Hex(albumDirPath), suffix)
    }

    fun getAvatarFile(username: String?): File? {
        if (username == null) {
            return null
        }
        val albumArtDir = albumArtDirectory
        val md5Hex = Util.md5Hex(username)
        return File(albumArtDir, String.format(Locale.ROOT, "%s%s", md5Hex, SUFFIX_LARGE))
    }

    /**
     * Get the album art file for a given album directory
     * @param albumDir The album directory
     * @return File object. Not guaranteed that it exists
     */
    @JvmStatic
    fun getAlbumArtFileForAlbumDir(albumDir: String): String? {
        val key = getAlbumArtKey(albumDir, true)
        return getAlbumArtFile(key)
    }

    /**
     * Get the album art file for a given cache key
     * @param cacheKey The key (== the filename)
     * @return File object. Not guaranteed that it exists
     */
    @JvmStatic
    fun getAlbumArtFile(cacheKey: String?): String? {
        val albumArtDir = albumArtDirectory.absolutePath
        return if (cacheKey == null) {
            null
        } else "$albumArtDir/$cacheKey"
    }

    val albumArtDirectory: File
        get() {
            val albumArtDir = File(ultrasonicDirectory, "artwork")
            ensureDirectoryExistsAndIsReadWritable(albumArtDir)
            ensureDirectoryExistsAndIsReadWritable(File(albumArtDir, ".nomedia"))
            return albumArtDir
        }

    fun getAlbumDirectory(entry: MusicDirectory.Entry): String {
        val dir: String
        if (!TextUtils.isEmpty(entry.path) && getParentPath(entry.path!!) != null) {
            val f = fileSystemSafeDir(entry.path)
            dir = String.format(
                    Locale.ROOT,
                    "%s/%s",
                    musicDirectory.getPath(),
                    if (entry.isDirectory) f else getParentPath(f) ?: ""
                )
        } else {
            val artist = fileSystemSafe(entry.artist)
            var album = fileSystemSafe(entry.album)
            if (UNNAMED == album) {
                album = fileSystemSafe(entry.title)
            }
            dir = String.format(Locale.ROOT, "%s/%s/%s", musicDirectory.getPath(), artist, album)
        }
        return dir
    }

    fun createDirectoryForParent(path: String) {
        val dir = getParentPath(path) ?: return
        StorageFile.createDirsOnPath(dir)
    }

    @Suppress("SameParameterValue")
    private fun getOrCreateDirectory(name: String): File {
        val dir = File(ultrasonicDirectory, name)
        if (!dir.exists() && !dir.mkdirs()) {
            Timber.e("Failed to create %s", name)
        }
        return dir
    }

    // After Android M, the location of the files must be queried differently.
    // GetExternalFilesDir will always return a directory which Ultrasonic
    // can access without any extra privileges.
    @JvmStatic
    val ultrasonicDirectory: File
        get() {
            @Suppress("DEPRECATION")
            return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) File(
                Environment.getExternalStorageDirectory(),
                "Android/data/org.moire.ultrasonic"
            ) else UApp.applicationContext().getExternalFilesDir(null)!!
        }

    @JvmStatic
    val defaultMusicDirectory: File
        get() = getOrCreateDirectory("music")

    @JvmStatic
    val musicDirectory: StorageFile
        get() = StorageFile.getMediaRoot()

    @JvmStatic
    @Suppress("ReturnCount")
    fun ensureDirectoryExistsAndIsReadWritable(dir: File?): Pair<Boolean, Boolean> {
        val noAccess = Pair(false, false)

        if (dir == null) {
            return noAccess
        }
        if (dir.exists()) {
            if (!dir.isDirectory) {
                Timber.w("%s exists but is not a directory.", dir)
                return noAccess
            }
        } else {
            if (dir.mkdirs()) {
                Timber.i("Created directory %s", dir)
            } else {
                Timber.w("Failed to create directory %s", dir)
                return noAccess
            }
        }
        if (!dir.canRead()) {
            Timber.w("No read permission for directory %s", dir)
            return noAccess
        }
        if (!dir.canWrite()) {
            Timber.w("No write permission for directory %s", dir)
            return Pair(true, false)
        }
        return Pair(true, true)
    }

    /**
     * Makes a given filename safe by replacing special characters like slashes ("/" and "\")
     * with dashes ("-").
     *
     * @param name The filename in question.
     * @return The filename with special characters replaced by hyphens.
     */
    private fun fileSystemSafe(name: String?): String {
        if (name == null || name.trim { it <= ' ' }.isEmpty()) {
            return UNNAMED
        }
        var filename: String = name

        for (s in FILE_SYSTEM_UNSAFE) {
            filename = filename.replace(s, "-")
        }
        return filename
    }

    /**
     * Makes a given filename safe by replacing special characters like colons (":")
     * with dashes ("-").
     *
     * @param path The path of the directory in question.
     * @return The the directory name with special characters replaced by hyphens.
     */
    private fun fileSystemSafeDir(path: String?): String {
        var filepath = path
        if (filepath == null || filepath.trim { it <= ' ' }.isEmpty()) {
            return ""
        }
        for (s in FILE_SYSTEM_UNSAFE_DIR) {
            filepath = filepath!!.replace(s, "-")
        }
        return filepath!!
    }

    /**
     * Similar to [File.listFiles], but returns a sorted set.
     * Never returns `null`, instead a warning is logged, and an empty set is returned.
     */
    @JvmStatic
    fun listFiles(dir: StorageFile): SortedSet<StorageFile> {
        val files = dir.listFiles()
        if (files == null) {
            Timber.w("Failed to list children for %s", dir.getPath())
            return TreeSet()
        }
        return TreeSet(files.asList())
    }

    @JvmStatic
    fun listFiles(dir: File): SortedSet<File> {
        val files = dir.listFiles()
        if (files == null) {
            Timber.w("Failed to list children for %s", dir.path)
            return TreeSet()
        }
        return TreeSet(files.asList())
    }

    fun listMediaFiles(dir: StorageFile): SortedSet<StorageFile> {
        val files = listFiles(dir)
        val iterator = files.iterator()
        while (iterator.hasNext()) {
            val file = iterator.next()
            if (!file.isDirectory && !isMediaFile(file)) {
                iterator.remove()
            }
        }
        return files
    }

    private fun isMediaFile(file: StorageFile): Boolean {
        val extension = getExtension(file.name)
        return MUSIC_FILE_EXTENSIONS.contains(extension) ||
            VIDEO_FILE_EXTENSIONS.contains(extension)
    }

    fun isPlaylistFile(file: File): Boolean {
        val extension = getExtension(file.name)
        return PLAYLIST_FILE_EXTENSIONS.contains(extension)
    }

    /**
     * Returns the extension (the substring after the last dot) of the given file. The dot
     * is not included in the returned extension.
     *
     * @param name The filename in question.
     * @return The extension, or an empty string if no extension is found.
     */
    fun getExtension(name: String): String {
        val index = name.lastIndexOf('.')
        return if (index == -1) "" else name.substring(index + 1).lowercase(Locale.ROOT)
    }

    /**
     * Returns the base name (the substring before the last dot) of the given file. The dot
     * is not included in the returned basename.
     *
     * @param name The filename in question.
     * @return The base name, or an empty string if no basename is found.
     */
    fun getBaseName(name: String): String {
        val index = name.lastIndexOf('.')
        return if (index == -1) name else name.substring(0, index)
    }

    /**
     * Returns the file name of a .partial file of the given file.
     *
     * @param name The filename in question.
     * @return The .partial file name
     */
    fun getPartialFile(name: String): String {
        return String.format(Locale.ROOT, "%s.partial.%s", getBaseName(name), getExtension(name))
    }

    fun getNameFromPath(path: String): String {
        return path.substringAfterLast('/')
    }

    fun getParentPath(path: String): String? {
        if (!path.contains('/')) return null
        return path.substringBeforeLast('/')
    }

    /**
     * Returns the file name of a .complete file of the given file.
     *
     * @param name The filename in question.
     * @return The .complete file name
     */
    fun getCompleteFile(name: String): String {
        return String.format(Locale.ROOT, "%s.complete.%s", getBaseName(name), getExtension(name))
    }

    @JvmStatic
    fun <T : Serializable?> serialize(context: Context, obj: T, fileName: String): Boolean {
        val file = File(context.cacheDir, fileName)
        var out: ObjectOutputStream? = null
        return try {
            out = ObjectOutputStream(FileOutputStream(file))
            out.writeObject(obj)
            Timber.i("Serialized object to %s", file)
            true
        } catch (ignored: Exception) {
            Timber.w("Failed to serialize object to %s", file)
            false
        } finally {
            out.safeClose()
        }
    }

    @Suppress("UNCHECKED_CAST")
    @JvmStatic
    fun <T : Serializable?> deserialize(context: Context, fileName: String): T? {
        val file = File(context.cacheDir, fileName)
        if (!file.exists() || !file.isFile) {
            return null
        }
        var inStream: ObjectInputStream? = null
        return try {
            inStream = ObjectInputStream(FileInputStream(file))
            val readObject = inStream.readObject()
            val result = readObject as T
            Timber.i("Deserialized object from %s", file)
            result
        } catch (all: Throwable) {
            Timber.w(all, "Failed to deserialize object from %s", file)
            null
        } finally {
            inStream.safeClose()
        }
    }

    fun savePlaylist(
        playlistFile: File?,
        playlist: MusicDirectory,
        name: String
    ) {
        val fw = FileWriter(playlistFile)
        val bw = BufferedWriter(fw)

        try {
            fw.write("#EXTM3U\n")
            for (e in playlist.getChildren()) {
                var filePath = getSongFile(e)

                if (!StorageFile.isPathExists(filePath)) {
                    val ext = getExtension(filePath)
                    val base = getBaseName(filePath)
                    filePath = "$base.complete.$ext"
                }
                fw.write(filePath + "\n")
            }
        } catch (e: IOException) {
            Timber.w("Failed to save playlist: %s", name)
            throw e
        } finally {
            bw.safeClose()
            fw.safeClose()
        }
    }

    @JvmStatic
    @Throws(IOException::class)
    fun renameFile(from: String, to: String) {
        StorageFile.rename(from, to)
    }

    @JvmStatic
    fun delete(file: File?): Boolean {
        if (file != null && file.exists()) {
            if (!file.delete()) {
                Timber.w("Failed to delete file %s", file)
                return false
            }
            Timber.i("Deleted file %s", file)
        }
        return true
    }

    @JvmStatic
    fun delete(file: String?): Boolean {
        if (file != null && StorageFile.isPathExists(file)) {
            if (!StorageFile.getFromPath(file).delete()) {
                Timber.w("Failed to delete file %s", file)
                return false
            }
            Timber.i("Deleted file %s", file)
        }
        return true
    }

}