Utils.kt

package com.github.gotify

import android.app.Activity
import android.app.ActivityManager
import android.content.Context
import android.graphics.drawable.Drawable
import android.text.format.DateUtils
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import coil.target.Target
import com.github.gotify.client.JSON
import com.google.android.material.snackbar.Snackbar
import com.google.gson.Gson
import java.io.BufferedReader
import java.io.IOException
import java.io.InputStream
import java.io.InputStreamReader
import java.net.MalformedURLException
import java.net.URI
import java.net.URISyntaxException
import java.net.URL
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import okio.Buffer
import org.threeten.bp.OffsetDateTime
import org.tinylog.kotlin.Logger

internal object Utils {
    val JSON: Gson = JSON().gson

    fun showSnackBar(activity: Activity, message: String?) {
        val rootView = activity.window.decorView.findViewById<View>(android.R.id.content)
        Snackbar.make(rootView, message!!, Snackbar.LENGTH_SHORT).show()
    }

    fun longToInt(value: Long): Int {
        return (value % Int.MAX_VALUE).toInt()
    }

    fun dateToRelative(data: OffsetDateTime): String {
        val time = data.toInstant().toEpochMilli()
        val now = System.currentTimeMillis()
        return DateUtils.getRelativeTimeSpanString(time, now, DateUtils.MINUTE_IN_MILLIS)
            .toString()
    }

    fun resolveAbsoluteUrl(baseURL: String, target: String?): String? {
        return if (target == null) {
            null
        } else {
            try {
                val targetUri = URI(target)
                if (targetUri.isAbsolute) {
                    target
                } else {
                    URL(URL(baseURL), target).toString()
                }
            } catch (e: MalformedURLException) {
                Logger.error(e, "Could not resolve absolute url")
                target
            } catch (e: URISyntaxException) {
                Logger.error(e, "Could not resolve absolute url")
                target
            }
        }
    }

    fun toDrawable(drawableReceiver: DrawableReceiver): Target {
        return object : Target {
            override fun onSuccess(result: Drawable) {
                drawableReceiver.loaded(result)
            }

            override fun onError(error: Drawable?) {
                Logger.error("Bitmap failed")
            }
        }
    }

    fun readFileFromStream(inputStream: InputStream): String {
        val sb = StringBuilder()
        var currentLine: String?
        try {
            BufferedReader(InputStreamReader(inputStream)).use { reader ->
                while (reader.readLine().also { currentLine = it } != null) {
                    sb.append(currentLine).append("\n")
                }
            }
        } catch (e: IOException) {
            throw IllegalArgumentException("failed to read input")
        }
        return sb.toString()
    }

    fun stringToInputStream(str: String?): InputStream? {
        return if (str == null) null else Buffer().writeUtf8(str).inputStream()
    }

    fun AppCompatActivity.launchCoroutine(
        dispatcher: CoroutineDispatcher = Dispatchers.IO,
        action: suspend (coroutineScope: CoroutineScope) -> Unit
    ) {
        this.lifecycleScope.launch(dispatcher) {
            action(this)
        }
    }

    fun interface DrawableReceiver {
        fun loaded(drawable: Drawable?)
    }

    fun setExcludeFromRecent(context: Context, excludeFromRecent: Boolean) {
        context.getSystemService(ActivityManager::class.java).appTasks?.getOrNull(0)
            ?.setExcludeFromRecents(excludeFromRecent)
    }
}