package sushi.hardcore.droidfs.file_operations

import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.Service
import android.content.Intent
import android.net.Uri
import android.os.Binder
import android.os.Build
import android.os.Bundle
import android.os.IBinder
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.documentfile.provider.DocumentFile
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.async
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.withContext
import kotlinx.coroutines.yield
import sushi.hardcore.droidfs.Constants
import sushi.hardcore.droidfs.R
import sushi.hardcore.droidfs.VolumeManager
import sushi.hardcore.droidfs.VolumeManagerApp
import sushi.hardcore.droidfs.explorers.ExplorerElement
import sushi.hardcore.droidfs.filesystems.EncryptedVolume
import sushi.hardcore.droidfs.util.ObjRef
import sushi.hardcore.droidfs.util.PathUtils
import sushi.hardcore.droidfs.util.Wiper
import java.io.File
import java.io.FileNotFoundException

class FileOperationService : Service() {
    companion object {
        const val NOTIFICATION_CHANNEL_ID = "FileOperations"
        const val ACTION_CANCEL = "file_operation_cancel"
    }

    private val binder = LocalBinder()
    private lateinit var volumeManger: VolumeManager
    private var serviceScope = MainScope()
    private lateinit var notificationManager: NotificationManagerCompat
    private val tasks = HashMap<Int, Job>()
    private var lastNotificationId = 0

    inner class LocalBinder : Binder() {
        fun getService(): FileOperationService = this@FileOperationService
    }

    override fun onBind(p0: Intent?): IBinder {
        volumeManger = (application as VolumeManagerApp).volumeManager
        return binder
    }

    private fun showNotification(message: Int, total: Int?): FileOperationNotification {
        ++lastNotificationId
        if (!::notificationManager.isInitialized){
            notificationManager = NotificationManagerCompat.from(this)
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            notificationManager.createNotificationChannel(
                NotificationChannel(
                    NOTIFICATION_CHANNEL_ID,
                    getString(R.string.file_operations),
                    NotificationManager.IMPORTANCE_LOW
                )
            )
        }
        val notificationBuilder = NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
        notificationBuilder
                .setContentTitle(getString(message))
                .setSmallIcon(R.drawable.ic_notification)
                .setOngoing(true)
                .addAction(NotificationCompat.Action(
                    R.drawable.icon_close,
                    getString(R.string.cancel),
                    PendingIntent.getBroadcast(
                        this,
                        0,
                        Intent(this, NotificationBroadcastReceiver::class.java).apply {
                            val bundle = Bundle()
                            bundle.putBinder("binder", LocalBinder())
                            bundle.putInt("notificationId", lastNotificationId)
                            putExtra("bundle", bundle)
                            action = ACTION_CANCEL
                        },
                        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
                    )
                ))
        if (total != null) {
            notificationBuilder
                .setContentText("0/$total")
                .setProgress(total, 0, false)
        } else {
            notificationBuilder
                .setContentText(getString(R.string.discovering_files))
                .setProgress(0, 0, true)
        }
        notificationManager.notify(lastNotificationId, notificationBuilder.build())
        return FileOperationNotification(notificationBuilder, lastNotificationId)
    }

    private fun updateNotificationProgress(notification: FileOperationNotification, progress: Int, total: Int){
        notification.notificationBuilder
                .setProgress(total, progress, false)
                .setContentText("$progress/$total")
        notificationManager.notify(notification.notificationId, notification.notificationBuilder.build())
    }

    private fun cancelNotification(notification: FileOperationNotification){
        notificationManager.cancel(notification.notificationId)
    }

    fun cancelOperation(notificationId: Int){
        tasks[notificationId]?.cancel()
    }

    private fun getEncryptedVolume(volumeId: Int): EncryptedVolume {
        return volumeManger.getVolume(volumeId) ?: throw IllegalArgumentException("Invalid volumeId: $volumeId")
    }

    private suspend fun <T> waitForTask(notification: FileOperationNotification, task: Deferred<T>): TaskResult<out T> {
        tasks[notification.notificationId] = task
        return coroutineScope {
            withContext(serviceScope.coroutineContext) {
                try {
                    TaskResult.completed(task.await())
                } catch (e: CancellationException) {
                    TaskResult.cancelled()
                } catch (e: Throwable) {
                    e.printStackTrace()
                    TaskResult.error(e.localizedMessage)
                } finally {
                    cancelNotification(notification)
                }
            }
        }
    }

    private suspend fun <T> volumeTask(
        volumeId: Int,
        notification: FileOperationNotification,
        task: suspend (encryptedVolume: EncryptedVolume) -> T
    ): TaskResult<out T> {
        return waitForTask(
            notification,
            volumeManger.getCoroutineScope(volumeId).async {
                task(getEncryptedVolume(volumeId))
            }
        )
    }

    private suspend fun copyFile(
        encryptedVolume: EncryptedVolume,
        srcPath: String,
        dstPath: String,
        srcEncryptedVolume: EncryptedVolume = encryptedVolume,
    ): Boolean {
        var success = true
        val srcFileHandle = srcEncryptedVolume.openFileReadMode(srcPath)
        if (srcFileHandle != -1L) {
            val dstFileHandle = encryptedVolume.openFileWriteMode(dstPath)
            if (dstFileHandle != -1L) {
                var offset: Long = 0
                val ioBuffer = ByteArray(Constants.IO_BUFF_SIZE)
                var length: Long
                while (srcEncryptedVolume.read(srcFileHandle, offset, ioBuffer, 0, ioBuffer.size.toLong()).also { length = it.toLong() } > 0) {
                    yield()
                    val written = encryptedVolume.write(dstFileHandle, offset, ioBuffer, 0, length).toLong()
                    if (written == length) {
                        offset += written
                    } else {
                        success = false
                        break
                    }
                }
                encryptedVolume.truncate(dstPath, offset)
                encryptedVolume.closeFile(dstFileHandle)
            } else {
                success = false
            }
            srcEncryptedVolume.closeFile(srcFileHandle)
        } else {
            success = false
        }
        return success
    }

    suspend fun copyElements(
        volumeId: Int,
        items: List<OperationFile>,
        srcVolumeId: Int = volumeId,
    ): TaskResult<out String?> {
        val notification = showNotification(R.string.file_op_copy_msg, items.size)
        val srcEncryptedVolume = getEncryptedVolume(srcVolumeId)
        return volumeTask(volumeId, notification) { encryptedVolume ->
            var failedItem: String? = null
            for (i in items.indices) {
                yield()
                if (items[i].isDirectory) {
                    if (!encryptedVolume.pathExists(items[i].dstPath!!)) {
                        if (!encryptedVolume.mkdir(items[i].dstPath!!)) {
                            failedItem = items[i].srcPath
                        }
                    }
                } else if (!copyFile(encryptedVolume, items[i].srcPath, items[i].dstPath!!, srcEncryptedVolume)) {
                    failedItem = items[i].srcPath
                }
                if (failedItem == null) {
                    updateNotificationProgress(notification, i+1, items.size)
                } else {
                    break
                }
            }
            failedItem
        }
    }

    suspend fun moveElements(volumeId: Int, toMove: List<OperationFile>, toClean: List<String>): TaskResult<out String?> {
        val notification = showNotification(R.string.file_op_move_msg, toMove.size)
        return volumeTask(volumeId, notification) { encryptedVolume ->
            val total = toMove.size+toClean.size
            var failedItem: String? = null
            for ((i, item) in toMove.withIndex()) {
                if (!encryptedVolume.rename(item.srcPath, item.dstPath!!)) {
                    failedItem = item.srcPath
                    break
                } else {
                    updateNotificationProgress(notification, i+1, total)
                }
            }
            if (failedItem == null) {
                for ((i, folderPath) in toClean.asReversed().withIndex()) {
                    if (!encryptedVolume.rmdir(folderPath)) {
                        failedItem = folderPath
                        break
                    } else {
                        updateNotificationProgress(notification, toMove.size+i+1, total)
                    }
                }
            }
            failedItem
        }
    }

    private suspend fun importFilesFromUris(
        encryptedVolume: EncryptedVolume,
        dstPaths: List<String>,
        uris: List<Uri>,
        notification: FileOperationNotification,
    ): String? {
        var failedIndex = -1
        for (i in dstPaths.indices) {
            yield()
            try {
                if (!encryptedVolume.importFile(this@FileOperationService, uris[i], dstPaths[i])) {
                    failedIndex = i
                }
            } catch (e: FileNotFoundException) {
                failedIndex = i
            }
            if (failedIndex == -1) {
                updateNotificationProgress(notification, i+1, dstPaths.size)
            } else {
                return uris[failedIndex].toString()
            }
        }
        return null
    }

    suspend fun importFilesFromUris(volumeId: Int, dstPaths: List<String>, uris: List<Uri>): TaskResult<out String?> {
        val notification = showNotification(R.string.file_op_import_msg, dstPaths.size)
        return volumeTask(volumeId, notification) { encryptedVolume ->
            importFilesFromUris(encryptedVolume, dstPaths, uris, notification)
        }
    }

    /**
     * Map the content of an unencrypted directory to prepare its import
     *
     * Contents of dstFiles and srcUris, at the same index, will match each other
     *
     * @return false if cancelled early, true otherwise.
     */
    private suspend fun recursiveMapDirectoryForImport(
        rootSrcDir: DocumentFile,
        rootDstPath: String,
        dstFiles: ArrayList<String>,
        srcUris: ArrayList<Uri>,
        dstDirs: ArrayList<String>,
    ) {
        dstDirs.add(rootDstPath)
        for (child in rootSrcDir.listFiles()) {
            yield()
            child.name?.let { name ->
                val subPath = PathUtils.pathJoin(rootDstPath, name)
                if (child.isDirectory) {
                    recursiveMapDirectoryForImport(child, subPath, dstFiles, srcUris, dstDirs)
                } else if (child.isFile) {
                    srcUris.add(child.uri)
                    dstFiles.add(subPath)
                }
            }
        }
    }

    class ImportDirectoryResult(val taskResult: TaskResult<out String?>, val uris: List<Uri>)

    suspend fun importDirectory(
        volumeId: Int,
        rootDstPath: String,
        rootSrcDir: DocumentFile,
    ): ImportDirectoryResult {
        val notification = showNotification(R.string.file_op_import_msg, null)
        val srcUris = arrayListOf<Uri>()
        return ImportDirectoryResult(volumeTask(volumeId, notification) { encryptedVolume ->
            var failedItem: String? = null
            val dstFiles = arrayListOf<String>()
            val dstDirs = arrayListOf<String>()
            recursiveMapDirectoryForImport(rootSrcDir, rootDstPath, dstFiles, srcUris, dstDirs)
            // create destination folders so the new files can use them
            for (dir in dstDirs) {
                if (!encryptedVolume.mkdir(dir)) {
                    failedItem = dir
                    break
                }
            }
            if (failedItem == null) {
                failedItem = importFilesFromUris(encryptedVolume, dstFiles, srcUris, notification)
            }
            failedItem
        }, srcUris)
    }

    suspend fun wipeUris(uris: List<Uri>, rootFile: DocumentFile? = null): TaskResult<out String?> {
        val notification = showNotification(R.string.file_op_wiping_msg, uris.size)
        val task = serviceScope.async(Dispatchers.IO) {
            var errorMsg: String? = null
            for (i in uris.indices) {
                yield()
                errorMsg = Wiper.wipe(this@FileOperationService, uris[i])
                if (errorMsg == null) {
                    updateNotificationProgress(notification, i+1, uris.size)
                } else {
                    break
                }
            }
            if (errorMsg == null) {
                rootFile?.delete()
            }
            errorMsg
        }
        return waitForTask(notification, task)
    }

    private fun exportFileInto(encryptedVolume: EncryptedVolume, srcPath: String, treeDocumentFile: DocumentFile): Boolean {
        val outputStream = treeDocumentFile.createFile("*/*", File(srcPath).name)?.uri?.let {
            contentResolver.openOutputStream(it)
        }
        return if (outputStream == null) {
            false
        } else {
            encryptedVolume.exportFile(srcPath, outputStream)
        }
    }

    private suspend fun recursiveExportDirectory(
        encryptedVolume: EncryptedVolume,
        plain_directory_path: String,
        treeDocumentFile: DocumentFile,
    ): String? {
        treeDocumentFile.createDirectory(File(plain_directory_path).name)?.let { childTree ->
            val explorerElements = encryptedVolume.readDir(plain_directory_path) ?: return null
            for (e in explorerElements) {
                yield()
                val fullPath = PathUtils.pathJoin(plain_directory_path, e.name)
                if (e.isDirectory) {
                    recursiveExportDirectory(encryptedVolume, fullPath, childTree)?.let { return it }
                } else if (!exportFileInto(encryptedVolume, fullPath, childTree)) {
                    return fullPath
                }
            }
            return null
        }
        return treeDocumentFile.name
    }

    suspend fun exportFiles(volumeId: Int, items: List<ExplorerElement>, uri: Uri): TaskResult<out String?> {
        val notification = showNotification(R.string.file_op_export_msg, items.size)
        return volumeTask(volumeId, notification) { encryptedVolume ->
            val treeDocumentFile = DocumentFile.fromTreeUri(this@FileOperationService, uri)!!
            var failedItem: String? = null
            for (i in items.indices) {
                yield()
                failedItem = if (items[i].isDirectory) {
                    recursiveExportDirectory(encryptedVolume, items[i].fullPath, treeDocumentFile)
                } else {
                    if (exportFileInto(encryptedVolume, items[i].fullPath, treeDocumentFile)) {
                        null
                    } else {
                        items[i].fullPath
                    }
                }
                if (failedItem == null) {
                    updateNotificationProgress(notification, i+1, items.size)
                } else {
                    break
                }
            }
            failedItem
        }
    }

    private suspend fun recursiveRemoveDirectory(encryptedVolume: EncryptedVolume, path: String): String? {
        encryptedVolume.readDir(path)?.let { elements ->
            for (e in elements) {
                yield()
                val fullPath = PathUtils.pathJoin(path, e.name)
                if (e.isDirectory) {
                    recursiveRemoveDirectory(encryptedVolume, fullPath)?.let { return it }
                } else if (!encryptedVolume.deleteFile(fullPath)) {
                    return fullPath
                }
            }
        }
        return if (!encryptedVolume.rmdir(path)) {
            path
        } else {
            null
        }
    }

    suspend fun removeElements(volumeId: Int, items: List<ExplorerElement>): String? {
        val notification = showNotification(R.string.file_op_delete_msg, items.size)
        return volumeTask(volumeId, notification) { encryptedVolume ->
            var failedItem: String? = null
            for ((i, element) in items.withIndex()) {
                yield()
                if (element.isDirectory) {
                    recursiveRemoveDirectory(encryptedVolume, element.fullPath)?.let { failedItem = it }
                } else if (!encryptedVolume.deleteFile(element.fullPath)) {
                    failedItem = element.fullPath
                }
                if (failedItem == null) {
                    updateNotificationProgress(notification, i + 1, items.size)
                } else {
                    break
                }
            }
            failedItem
        }.failedItem // treat cancellation as success
    }

    private suspend fun recursiveCountChildElements(rootDirectory: DocumentFile, scope: CoroutineScope): Int {
        yield()
        val children = rootDirectory.listFiles()
        var count = children.size
        for (child in children) {
            if (child.isDirectory) {
                count += recursiveCountChildElements(child, scope)
            }
        }
        return count
    }

    private suspend fun recursiveCopyVolume(
        src: DocumentFile,
        dst: DocumentFile,
        dstRootDirectory: ObjRef<DocumentFile?>?,
        notification: FileOperationNotification,
        total: Int,
        scope: CoroutineScope,
        progress: ObjRef<Int> = ObjRef(0)
    ): DocumentFile? {
        val dstDir = dst.createDirectory(src.name ?: return src) ?: return src
        dstRootDirectory?.let { it.value = dstDir }
        for (child in src.listFiles()) {
            yield()
            if (child.isFile) {
                val dstFile = dstDir.createFile("", child.name ?: return child) ?: return child
                val outputStream = contentResolver.openOutputStream(dstFile.uri)
                val inputStream = contentResolver.openInputStream(child.uri)
                if (outputStream == null || inputStream == null) return child
                val written = inputStream.copyTo(outputStream)
                outputStream.close()
                inputStream.close()
                if (written != child.length()) return child
            } else {
                recursiveCopyVolume(child, dstDir, null, notification, total, scope, progress)?.let { return it }
            }
            progress.value++
            updateNotificationProgress(notification, progress.value, total)
        }
        return null
    }

    class CopyVolumeResult(val taskResult: TaskResult<out DocumentFile?>, val dstRootDirectory: DocumentFile?)

    suspend fun copyVolume(src: DocumentFile, dst: DocumentFile): CopyVolumeResult {
        val notification = showNotification(R.string.copy_volume_notification, null)
        val dstRootDirectory = ObjRef<DocumentFile?>(null)
        val task = serviceScope.async(Dispatchers.IO) {
            val total = recursiveCountChildElements(src, this)
            updateNotificationProgress(notification, 0, total)
            recursiveCopyVolume(src, dst, dstRootDirectory, notification, total, this)
        }
        return CopyVolumeResult(waitForTask(notification, task), dstRootDirectory.value)
    }
}