package ani.dantotsu.parsers.novel

import android.app.DownloadManager
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.database.Cursor
import android.net.Uri
import android.os.Build
import android.os.Environment
import android.provider.MediaStore
import androidx.core.content.ContextCompat
import androidx.core.content.getSystemService
import androidx.core.net.toUri
import ani.dantotsu.snackString
import ani.dantotsu.util.Logger
import com.jakewharton.rxrelay.PublishRelay
import eu.kanade.tachiyomi.extension.InstallStep
import eu.kanade.tachiyomi.util.storage.getUriCompat
import rx.Observable
import rx.android.schedulers.AndroidSchedulers
import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.nio.channels.FileChannel
import java.nio.file.Files
import java.util.concurrent.TimeUnit

/**
 * The installer which installs, updates and uninstalls the extensions.
 *
 * @param context The application context.
 */
internal class NovelExtensionInstaller(private val context: Context) {

    /**
     * The system's download manager
     */
    private val downloadManager = context.getSystemService<DownloadManager>()!!

    /**
     * The broadcast receiver which listens to download completion events.
     */
    private val downloadReceiver = DownloadCompletionReceiver()

    /**
     * The currently requested downloads, with the package name (unique id) as key, and the id
     * returned by the download manager.
     */
    private val activeDownloads = hashMapOf<String, Long>()

    /**
     * Relay used to notify the installation step of every download.
     */
    private val downloadsRelay = PublishRelay.create<Pair<Long, InstallStep>>()

    /**
     * Adds the given extension to the downloads queue and returns an observable containing its
     * step in the installation process.
     *
     * @param url The url of the apk.
     * @param extension The extension to install.
     */
    fun downloadAndInstall(url: String, extension: NovelExtension): Observable<InstallStep> = Observable.defer {
        val pkgName = extension.pkgName

        val oldDownload = activeDownloads[pkgName]
        if (oldDownload != null) {
            deleteDownload(pkgName)
        }

        val sourcePath = context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS)?.absolutePath
        //if the file is already downloaded, remove it
        val fileToDelete = File("$sourcePath/${url.toUri().lastPathSegment}")
        if (fileToDelete.exists()) {
            if (fileToDelete.delete()) {
                Logger.log("APK file deleted successfully.")
            } else {
                Logger.log("Failed to delete APK file.")
            }
        } else {
            Logger.log("APK file not found.")
        }

        // Register the receiver after removing (and unregistering) the previous download
        downloadReceiver.register()

        val downloadUri = url.toUri()
        val request = DownloadManager.Request(downloadUri)
            .setTitle(extension.name)
            .setMimeType(APK_MIME)
            .setDestinationInExternalFilesDir(
                context,
                Environment.DIRECTORY_DOWNLOADS,
                downloadUri.lastPathSegment
            )
            .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
        val id = downloadManager.enqueue(request)
        activeDownloads[pkgName] = id

        downloadsRelay.filter { it.first == id }
            .map { it.second }
            // Poll download status
            .mergeWith(pollStatus(id))
            // Stop when the application is installed or errors
            .takeUntil { it.isCompleted() }
            // Always notify on main thread
            .observeOn(AndroidSchedulers.mainThread())
            // Always remove the download when unsubscribed
            .doOnUnsubscribe { deleteDownload(pkgName) }
    }

    /**
     * Returns an observable that polls the given download id for its status every second, as the
     * manager doesn't have any notification system. It'll stop once the download finishes.
     *
     * @param id The id of the download to poll.
     */
    private fun pollStatus(id: Long): Observable<InstallStep> {
        val query = DownloadManager.Query().setFilterById(id)

        return Observable.interval(0, 1, TimeUnit.SECONDS)
            // Get the current download status
            .map {
                downloadManager.query(query).use { cursor ->
                    if (cursor.moveToFirst()) {
                        cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS))
                    } else {
                        DownloadManager.STATUS_FAILED
                    }
                }
            }
            // Ignore duplicate results
            .distinctUntilChanged()
            // Stop polling when the download fails or finishes
            .takeUntil { it == DownloadManager.STATUS_SUCCESSFUL || it == DownloadManager.STATUS_FAILED }
            // Map to our model
            .flatMap { status ->
                when (status) {
                    DownloadManager.STATUS_PENDING -> Observable.just(InstallStep.Pending)
                    DownloadManager.STATUS_RUNNING -> Observable.just(InstallStep.Downloading)
                    DownloadManager.STATUS_SUCCESSFUL -> Observable.just(InstallStep.Installing)
                    else -> Observable.empty()
                }
            }
    }

    fun installApk(downloadId: Long, uri: Uri, context: Context, pkgName: String): InstallStep {
        val sourcePath =
            context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS)?.absolutePath + "/" + uri.lastPathSegment
        val destinationPath =
            context.getExternalFilesDir(null)?.absolutePath + "/extensions/novel/$pkgName.apk"

        val destinationPathDirectory =
            context.getExternalFilesDir(null)?.absolutePath + "/extensions/novel/"
        val destinationPathDirectoryFile = File(destinationPathDirectory)


        // Check if source path is obtained correctly
        if (sourcePath == null) {
            Logger.log("Source APK path not found.")
            downloadsRelay.call(downloadId to InstallStep.Error)
            return InstallStep.Error
        }

        // Create the destination directory if it doesn't exist
        val destinationDir = File(destinationPath).parentFile
        if (destinationDir?.exists() == false) {
            destinationDir.mkdirs()
        }
        if (destinationDir?.setWritable(true) == false) {
            Logger.log("Failed to set destinationDir to writable.")
            downloadsRelay.call(downloadId to InstallStep.Error)
            return InstallStep.Error
        }

        // Copy the file to the new location
        copyFileToInternalStorage(sourcePath, destinationPath)
        Logger.log("APK moved to $destinationPath")
        downloadsRelay.call(downloadId to InstallStep.Installed)
        return InstallStep.Installed
    }

    /**
     * Cancels extension install and remove from download manager and installer.
     */
    fun cancelInstall(pkgName: String) {
        val downloadId = activeDownloads.remove(pkgName) ?: return
        downloadManager.remove(downloadId)
    }

    fun uninstallApk(pkgName: String, context: Context) {
        val apkPath =
            context.getExternalFilesDir(null)?.absolutePath + "/extensions/novel/$pkgName.apk"
        val fileToDelete = File(apkPath)
        //give write permission to the file
        if (fileToDelete.exists() && !fileToDelete.canWrite()) {
            Logger.log("File is not writable. Giving write permission.")
            val a = fileToDelete.setWritable(true)
            Logger.log("Success: $a")
        }
        //set the directory to writable
        val destinationDir = File(apkPath).parentFile
        if (destinationDir?.exists() == false) {
            destinationDir.mkdirs()
        }
        val s = destinationDir?.setWritable(true)
        Logger.log("Success destinationDir: $s")

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            try {
                Files.delete(fileToDelete.toPath())
            } catch (e: Exception) {
                Logger.log("Failed to delete APK file.")
                Logger.log(e)
                snackString("Failed to delete APK file.")
            }
        } else {
            if (fileToDelete.exists()) {
                if (fileToDelete.delete()) {
                    Logger.log("APK file deleted successfully.")
                    snackString("APK file deleted successfully.")
                } else {
                    Logger.log("Failed to delete APK file.")
                    snackString("Failed to delete APK file.")
                }
            } else {
                Logger.log("APK file not found.")
                snackString("APK file not found.")
            }
        }
    }

    private fun copyFileToInternalStorage(sourcePath: String, destinationPath: String) {
        val source = File(sourcePath)
        val destination = File(destinationPath)
        destination.setWritable(true)

        //delete the file if it already exists
        if (destination.exists()) {
            if (destination.delete()) {
                Logger.log("File deleted successfully.")
            } else {
                Logger.log("Failed to delete file.")
            }
        }

        var inputChannel: FileChannel? = null
        var outputChannel: FileChannel? = null
        try {
            inputChannel = FileInputStream(source).channel
            outputChannel = FileOutputStream(destination).channel
            inputChannel.transferTo(0, inputChannel.size(), outputChannel)
            destination.setWritable(false)
        } catch (e: Exception) {
            e.printStackTrace()
        } finally {
            inputChannel?.close()
            outputChannel?.close()
        }

        Logger.log("File copied to internal storage.")
    }

    private fun getRealPathFromURI(context: Context, contentUri: Uri): String? {
        var cursor: Cursor? = null
        try {
            val proj = arrayOf(MediaStore.Images.Media.DATA)
            cursor = context.contentResolver.query(contentUri, proj, null, null, null)
            val columnIndex = cursor?.getColumnIndexOrThrow(MediaStore.Images.Media.DATA)
            if (cursor != null && cursor.moveToFirst() && columnIndex != null) {
                return cursor.getString(columnIndex)
            }
        } finally {
            cursor?.close()
        }
        return null
    }

    /**
     * Sets the step of the installation of an extension.
     *
     * @param downloadId The id of the download.
     * @param step New install step.
     */
    fun updateInstallStep(downloadId: Long, step: InstallStep) {
        downloadsRelay.call(downloadId to step)
    }

    /**
     * Deletes the download for the given package name.
     *
     * @param pkgName The package name of the download to delete.
     */
    private fun deleteDownload(pkgName: String) {
        val downloadId = activeDownloads.remove(pkgName)
        if (downloadId != null) {
            downloadManager.remove(downloadId)
        }
        if (activeDownloads.isEmpty()) {
            downloadReceiver.unregister()
        }
    }

    /**
     * Receiver that listens to download status events.
     */
    private inner class DownloadCompletionReceiver : BroadcastReceiver() {

        /**
         * Whether this receiver is currently registered.
         */
        private var isRegistered = false

        /**
         * Registers this receiver if it's not already.
         */
        fun register() {
            if (isRegistered) return
            isRegistered = true

            val filter = IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE)
            ContextCompat.registerReceiver(context, this, filter, ContextCompat.RECEIVER_EXPORTED)
        }

        /**
         * Unregisters this receiver if it's not already.
         */
        fun unregister() {
            if (!isRegistered) return
            isRegistered = false

            context.unregisterReceiver(this)
        }

        /**
         * Called when a download event is received. It looks for the download in the current active
         * downloads and notifies its installation step.
         */
        override fun onReceive(context: Context, intent: Intent?) {
            val id = intent?.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, 0) ?: return

            // Avoid events for downloads we didn't request
            if (id !in activeDownloads.values) return

            val uri = downloadManager.getUriForDownloadedFile(id)

            // Set next installation step
            if (uri == null) {
                Logger.log("Couldn't locate downloaded APK")
                downloadsRelay.call(id to InstallStep.Error)
                return
            }

            val query = DownloadManager.Query().setFilterById(id)
            downloadManager.query(query).use { cursor ->
                if (cursor.moveToFirst()) {
                    val localUri = cursor.getString(
                        cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_LOCAL_URI),
                    ).removePrefix(FILE_SCHEME)
                    val pkgName = extractPkgNameFromUri(localUri)
                    installApk(id, File(localUri).getUriCompat(context), context, pkgName)
                }
            }
        }

        private fun extractPkgNameFromUri(localUri: String): String {
            val uri = Uri.parse(localUri)
            val path = uri.path
            val pkgName = path?.substring(path.lastIndexOf('/') + 1)?.removeSuffix(".apk")
            Logger.log("Package name: $pkgName")
            return pkgName ?: ""
        }
    }

    companion object {
        const val APK_MIME = "application/vnd.android.package-archive"
        const val EXTRA_DOWNLOAD_ID = "NovelExtensionInstaller.extra.DOWNLOAD_ID"
        const val FILE_SCHEME = "file://"
    }
}