package sushi.hardcore.droidfs.explorers

import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.view.Menu
import android.view.MenuItem
import android.widget.Toast
import androidx.activity.addCallback
import androidx.activity.result.contract.ActivityResultContracts
import androidx.documentfile.provider.DocumentFile
import androidx.lifecycle.lifecycleScope
import com.google.android.material.floatingactionbutton.FloatingActionButton
import kotlinx.coroutines.launch
import sushi.hardcore.droidfs.CameraActivity
import sushi.hardcore.droidfs.LoadingTask
import sushi.hardcore.droidfs.MainActivity
import sushi.hardcore.droidfs.R
import sushi.hardcore.droidfs.adapters.IconTextDialogAdapter
import sushi.hardcore.droidfs.file_operations.OperationFile
import sushi.hardcore.droidfs.filesystems.Stat
import sushi.hardcore.droidfs.util.PathUtils
import sushi.hardcore.droidfs.widgets.CustomAlertDialogBuilder
import sushi.hardcore.droidfs.widgets.EditTextDialog

class ExplorerActivity : BaseExplorerActivity() {
    companion object {
        private enum class ItemsActions {NONE, COPY, MOVE}
    }

    private var usf_decrypt = false
    private var usf_share = false
    private var currentItemAction = ItemsActions.NONE
    private val itemsToProcess = ArrayList<OperationFile>()
    private val pickFromOtherVolumes = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
        if (result.resultCode == Activity.RESULT_OK) {
            result.data?.let { resultIntent ->
                val srcVolumeId = resultIntent.getIntExtra("volumeId", -1)
                val srcEncryptedVolume = app.volumeManager.getVolume(srcVolumeId)!!
                val path = resultIntent.getStringExtra("path")
                if (path == null){ //multiples elements
                    val paths = resultIntent.getStringArrayListExtra("paths")
                    val types = resultIntent.getIntegerArrayListExtra("types")
                    if (types != null && paths != null){
                        object : LoadingTask<List<OperationFile>>(this, theme, R.string.discovering_files) {
                            override suspend fun doTask(): List<OperationFile> {
                                val operationFiles = ArrayList<OperationFile>()
                                for (i in paths.indices) {
                                    operationFiles.add(OperationFile(paths[i], types[i]))
                                    if (types[i] == Stat.S_IFDIR) {
                                        srcEncryptedVolume.recursiveMapFiles(paths[i])?.forEach {
                                            operationFiles.add(OperationFile.fromExplorerElement(it))
                                        }
                                    }
                                }
                                return operationFiles
                            }
                        }.startTask(lifecycleScope) { operationFiles ->
                            importFilesFromVolume(srcVolumeId, operationFiles)
                        }
                    }
                } else {
                    importFilesFromVolume(srcVolumeId, arrayListOf(OperationFile(path, Stat.S_IFREG)))
                }
            }
        }
    }
    private val pickFiles = registerForActivityResult(ActivityResultContracts.OpenMultipleDocuments()) { uris ->
        if (uris != null) {
            for (uri in uris) {
                contentResolver.takePersistableUriPermission(uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
            }
            importFilesFromUris(uris) {
                onImportComplete(uris)
            }
        }
    }
    private val pickExportDirectory = registerForActivityResult(ActivityResultContracts.OpenDocumentTree()) { uri ->
        if (uri != null) {
            contentResolver.takePersistableUriPermission(uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
            val items = explorerAdapter.selectedItems.map { i -> explorerElements[i] }
            activityScope.launch {
                val result = fileOperationService.exportFiles(volumeId, items, uri)
                onTaskResult(result, R.string.export_failed, R.string.success_export)
            }
        }
        unselectAll()
    }
    private val pickImportDirectory = registerForActivityResult(ActivityResultContracts.OpenDocumentTree()) { rootUri ->
        rootUri?.let {
            contentResolver.takePersistableUriPermission(it, Intent.FLAG_GRANT_READ_URI_PERMISSION)
            val tree = DocumentFile.fromTreeUri(this, it)!! //non-null after Lollipop
            val operation = OperationFile(PathUtils.pathJoin(currentDirectoryPath, tree.name!!), Stat.S_IFDIR)
            checkPathOverwrite(arrayListOf(operation), currentDirectoryPath) { checkedOperation ->
                checkedOperation?.let {
                    activityScope.launch {
                        val result = fileOperationService.importDirectory(volumeId, checkedOperation[0].dstPath!!, tree)
                        onTaskResult(result.taskResult, R.string.import_failed) {
                            onImportComplete(result.uris, tree)
                        }
                        setCurrentPath(currentDirectoryPath)
                    }
                }
            }
        }
    }

    private fun importFilesFromVolume(srcVolumeId: Int, operationFiles: List<OperationFile>) {
        checkPathOverwrite(operationFiles, currentDirectoryPath) { items ->
            if (items != null) {
                // stop loading thumbnails while writing files
                explorerAdapter.loadThumbnails = false
                activityScope.launch {
                    onTaskResult(
                        fileOperationService.copyElements(
                            volumeId,
                            items,
                            srcVolumeId
                        ), R.string.import_failed, R.string.success_import
                    )
                    explorerAdapter.loadThumbnails = true
                    setCurrentPath(currentDirectoryPath)
                }
            }
        }

    }

    private fun onImportComplete(urisToWipe: List<Uri>, rootFile: DocumentFile? = null) {
        CustomAlertDialogBuilder(this, theme)
            .setTitle(R.string.success_import)
            .setMessage("""
                            ${getString(R.string.success_import_msg)}
                            ${getString(R.string.ask_for_wipe)}
                            """.trimIndent())
            .setPositiveButton(R.string.yes) { _, _ ->
                activityScope.launch {
                    onTaskResult(
                        fileOperationService.wipeUris(urisToWipe, rootFile),
                        R.string.wipe_failed,
                        R.string.wipe_successful,
                    )
                }
            }
            .setNegativeButton(R.string.no, null)
            .show()
    }

    override fun init() {
        super.init()
        onBackPressedDispatcher.addCallback(this) {
            if (currentItemAction != ItemsActions.NONE) {
                cancelItemAction()
                invalidateOptionsMenu()
            } else {
                isEnabled = false
                onBackPressedDispatcher.onBackPressed()
                isEnabled = true
            }
        }
        findViewById<FloatingActionButton>(R.id.fab).setOnClickListener {
            if (currentItemAction != ItemsActions.NONE){
                openDialogCreateFolder()
            } else {
                val adapter = IconTextDialogAdapter(this)
                adapter.items = listOf(
                    listOf("importFromOtherVolumes", R.string.import_from_other_volume, R.drawable.icon_transfer),
                    listOf("importFiles", R.string.import_files, R.drawable.icon_encrypt),
                    listOf("importFolder", R.string.import_folder, R.drawable.icon_import_folder),
                    listOf("createFile", R.string.new_file, R.drawable.icon_file_unknown),
                    listOf("createFolder", R.string.mkdir, R.drawable.icon_create_new_folder),
                    listOf("camera", R.string.camera, R.drawable.icon_photo)
                )
                CustomAlertDialogBuilder(this, theme)
                    .setSingleChoiceItems(adapter, -1){ thisDialog, which ->
                        when (adapter.getItem(which)){
                            "importFromOtherVolumes" -> {
                                val intent = Intent(this, MainActivity::class.java)
                                intent.action = "pick"
                                intent.putExtra("volume", encryptedVolume)
                                pickFromOtherVolumes.launch(intent)
                            }
                            "importFiles" -> {
                                app.isStartingExternalApp = true
                                pickFiles.launch(arrayOf("*/*"))
                            }
                            "importFolder" -> {
                                app.isStartingExternalApp = true
                                pickImportDirectory.launch(null)
                            }
                            "createFile" -> {
                                EditTextDialog(this, R.string.enter_file_name) {
                                    createNewFile(it)
                                }.show()
                            }
                            "createFolder" -> {
                                openDialogCreateFolder()
                            }
                            "camera" -> {
                                val intent = Intent(this, CameraActivity::class.java)
                                intent.putExtra("path", currentDirectoryPath)
                                intent.putExtra("volume", encryptedVolume)
                                startActivity(intent)
                            }
                        }
                        thisDialog.dismiss()
                    }
                    .setTitle(getString(R.string.add))
                    .setNegativeButton(R.string.cancel, null)
                    .show()
            }
        }
        usf_decrypt = sharedPrefs.getBoolean("usf_decrypt", false)
        usf_share = sharedPrefs.getBoolean("usf_share", false)
    }

    override fun onExplorerElementLongClick(position: Int) {
        super.onExplorerElementLongClick(position)
        cancelItemAction()
    }

    private fun createNewFile(fileName: String){
        if (fileName.isEmpty()) {
            Toast.makeText(this, R.string.error_filename_empty, Toast.LENGTH_SHORT).show()
        } else {
            val filePath = PathUtils.pathJoin(currentDirectoryPath, fileName)
            val handleID = encryptedVolume.openFileWriteMode(filePath)
            if (handleID == -1L) {
                CustomAlertDialogBuilder(this, theme)
                        .setTitle(R.string.error)
                        .setMessage(R.string.file_creation_failed)
                        .setPositiveButton(R.string.ok, null)
                        .show()
            } else {
                encryptedVolume.closeFile(handleID)
                setCurrentPath(currentDirectoryPath)
                invalidateOptionsMenu()
            }
        }
    }

    override fun onCreateOptionsMenu(menu: Menu): Boolean {
        menuInflater.inflate(R.menu.explorer, menu)
        val result = super.onCreateOptionsMenu(menu)
        if (currentItemAction != ItemsActions.NONE) {
            menu.findItem(R.id.validate).isVisible = true
            menu.findItem(R.id.lock).isVisible = false
            menu.findItem(R.id.close).isVisible = false
            supportActionBar?.setDisplayHomeAsUpEnabled(true)
        } else {
            if (usf_share){
                menu.findItem(R.id.share).isVisible = false
            }
            val anyItemSelected = explorerAdapter.selectedItems.isNotEmpty()
            menu.findItem(R.id.select_all).isVisible = anyItemSelected
            menu.findItem(R.id.delete).isVisible = anyItemSelected
            menu.findItem(R.id.copy).isVisible = anyItemSelected
            menu.findItem(R.id.cut).isVisible = anyItemSelected
            menu.findItem(R.id.decrypt).isVisible = anyItemSelected && usf_decrypt
            if (anyItemSelected && usf_share){
                var containsDir = false
                for (i in explorerAdapter.selectedItems) {
                    if (explorerElements[i].isDirectory) {
                        containsDir = true
                        break
                    }
                }
                if (!containsDir) {
                    menu.findItem(R.id.share).isVisible = true
                }
            }
        }
        return result
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        return when (item.itemId) {
            android.R.id.home -> {
                cancelItemAction()
                super.onOptionsItemSelected(item)
            }
            R.id.select_all -> {
                explorerAdapter.selectAll()
                invalidateOptionsMenu()
                true
            }
            R.id.cut -> {
                for (i in explorerAdapter.selectedItems){
                    itemsToProcess.add(OperationFile.fromExplorerElement(explorerElements[i]))
                }
                currentItemAction = ItemsActions.MOVE
                unselectAll()
                true
            }
            R.id.copy -> {
                for (i in explorerAdapter.selectedItems){
                    itemsToProcess.add(OperationFile.fromExplorerElement(explorerElements[i]))
                }
                currentItemAction = ItemsActions.COPY
                unselectAll()
                true
            }
            R.id.validate -> {
                if (currentItemAction == ItemsActions.COPY){
                    object : LoadingTask<List<OperationFile>>(this, theme, R.string.discovering_files) {
                        override suspend fun doTask(): List<OperationFile> {
                            val items = itemsToProcess.toMutableList()
                            itemsToProcess.filter { it.isDirectory }.forEach { dir ->
                                encryptedVolume.recursiveMapFiles(dir.srcPath)?.forEach {
                                    items.add(OperationFile.fromExplorerElement(it))
                                }
                            }
                            return items
                        }
                    }.startTask(lifecycleScope) { items ->
                        checkPathOverwrite(items, currentDirectoryPath) {
                            it?.let { checkedItems ->
                                activityScope.launch {
                                    onTaskResult(
                                        fileOperationService.copyElements(volumeId, checkedItems),
                                        R.string.copy_failed,
                                        R.string.copy_success,
                                    )
                                    setCurrentPath(currentDirectoryPath)
                                }
                            }
                            cancelItemAction()
                            invalidateOptionsMenu()
                        }
                    }
                } else if (currentItemAction == ItemsActions.MOVE){
                    itemsToProcess.forEach {
                        it.dstPath = PathUtils.pathJoin(currentDirectoryPath, it.name)
                        it.overwriteConfirmed = false // reset the field in case of a previous cancelled move
                    }
                    val toMove = ArrayList<OperationFile>(itemsToProcess.size)
                    val toClean = ArrayList<String>()
                    prepareFilesForMove(
                        itemsToProcess,
                        toMove,
                        toClean,
                    ) {
                        activityScope.launch {
                            onTaskResult(
                                fileOperationService.moveElements(volumeId, toMove, toClean),
                                R.string.move_success,
                                R.string.move_failed,
                            )
                            setCurrentPath(currentDirectoryPath)
                        }
                        cancelItemAction()
                        invalidateOptionsMenu()
                    }
                }
                true
            }
            R.id.delete -> {
                val size = explorerAdapter.selectedItems.size
                val dialog = CustomAlertDialogBuilder(this, theme)
                dialog.setTitle(R.string.warning)
                dialog.setPositiveButton(R.string.ok) { _, _ ->
                    val items = explorerAdapter.selectedItems.map { i -> explorerElements[i] }
                    activityScope.launch {
                        fileOperationService.removeElements(volumeId, items)?.let { failedItem ->
                            CustomAlertDialogBuilder(this@ExplorerActivity, theme)
                                .setTitle(R.string.error)
                                .setMessage(getString(R.string.remove_failed, failedItem))
                                .setPositiveButton(R.string.ok, null)
                                .show()
                        }
                        setCurrentPath(currentDirectoryPath) //refresh
                    }
                    unselectAll()
                }
                dialog.setNegativeButton(R.string.cancel, null)
                if (size > 1) {
                    dialog.setMessage(getString(R.string.multiple_delete_confirm, explorerAdapter.selectedItems.size.toString()))
                } else {
                    dialog.setMessage(getString(
                        R.string.single_delete_confirm,
                        explorerAdapter.explorerElements[explorerAdapter.selectedItems.first()].name
                    ))
                }
                dialog.show()
                true
            }
            R.id.share -> {
                val files = explorerAdapter.selectedItems.map { i ->
                    explorerElements[i].let {
                        Pair(it.fullPath, it.stat.size)
                    }
                }
                app.isExporting = true
                object : LoadingTask<Pair<Intent?, Int?>>(this, theme, R.string.loading_msg_export) {
                    override suspend fun doTask(): Pair<Intent?, Int?> {
                        return fileShare.share(files, volumeId)
                    }
                }.startTask(lifecycleScope) { (intent, error) ->
                    if (intent == null) {
                        onExportFailed(error!!)
                    } else {
                        app.isStartingExternalApp = true
                        startActivity(Intent.createChooser(intent, getString(R.string.share_chooser)))
                    }
                    app.isExporting = false
                }
                unselectAll()
                true
            }
            R.id.decrypt -> {
                app.isStartingExternalApp = true
                pickExportDirectory.launch(null)
                true
            }
            else -> super.onOptionsItemSelected(item)
        }
    }

    /**
     * Ask the user what to do if an item would overwrite another item in case of a move.
     *
     * All [OperationFile] must have a non-null [dstPath][OperationFile.dstPath].
     */
    private fun checkMoveOverwrite(items: List<OperationFile>, callback: (List<OperationFile>?) -> Unit) {
        for (item in items) {
            if (encryptedVolume.pathExists(item.dstPath!!) && !item.overwriteConfirmed) {
                CustomAlertDialogBuilder(this, theme)
                    .setTitle(R.string.warning)
                    .setMessage(
                        getString(
                            if (item.isDirectory) {
                                R.string.dir_overwrite_question
                            } else {
                                R.string.file_overwrite_question
                            },
                            item.dstPath!!
                        )
                    )
                    .setPositiveButton(R.string.yes) {_, _ ->
                        item.overwriteConfirmed = true
                        checkMoveOverwrite(items, callback)
                    }
                    .setNegativeButton(R.string.no) { _, _ ->
                        with(EditTextDialog(this, R.string.enter_new_name) {
                            item.dstPath = PathUtils.pathJoin(PathUtils.getParentPath(item.dstPath!!), it)
                            checkMoveOverwrite(items, callback)
                        }) {
                            setSelectedText(item.name)
                            show()
                        }
                    }
                    .show()
                return
            }
        }
        callback(items)
    }

    /**
     * Check for destination overwriting in case of a move operation.
     *
     * If the user decides to merge the content of a folder, the function recursively tests all
     * children of the source folder to see if they will overwrite.
     *
     * The items to be moved are stored in [toMove]. We also need to keep track of the merged
     * folders to delete them after the move. These folders are stored in [toClean].
     */
    private fun prepareFilesForMove(
        items: List<OperationFile>,
        toMove: ArrayList<OperationFile>,
        toClean: ArrayList<String>,
        onReady: () -> Unit
    ) {
        checkMoveOverwrite(items) { checkedItems ->
            checkedItems?.let {
                for (item in checkedItems) {
                    if (!item.overwriteConfirmed || !item.isDirectory) {
                        toMove.add(item)
                    }
                }
                val toCheck = mutableListOf<OperationFile>()
                for (item in checkedItems) {
                    if (item.overwriteConfirmed && item.isDirectory) {
                        val children = encryptedVolume.readDir(item.srcPath)
                        children?.map {
                            OperationFile(it.fullPath, it.stat.type, PathUtils.pathJoin(item.dstPath!!, it.name))
                        }?.let { toCheck.addAll(it) }
                        toClean.add(item.srcPath)
                    }
                }
                if (toCheck.isEmpty()) {
                    onReady()
                } else {
                    prepareFilesForMove(toCheck, toMove, toClean, onReady)
                }
            }
        }
    }

    private fun cancelItemAction() {
        if (currentItemAction != ItemsActions.NONE){
            currentItemAction = ItemsActions.NONE
            itemsToProcess.clear()
        }
    }
}