RustAssistant/app/src/main/java/com/coldmint/rust/pro/EditActivity.kt

package com.coldmint.rust.pro

import android.content.Intent
import android.graphics.Color
import android.graphics.Typeface
import android.graphics.drawable.Drawable
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.provider.MediaStore
import android.view.*
import android.widget.PopupMenu
import android.widget.Toast
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.view.GravityCompat
import androidx.core.view.isVisible
import androidx.drawerlayout.widget.DrawerLayout
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.bumptech.glide.request.RequestOptions
import com.bumptech.glide.request.target.CustomTarget
import com.bumptech.glide.request.transition.Transition
import com.coldmint.dialog.CoreDialog
import com.coldmint.dialog.InputDialog
import com.coldmint.rust.core.ModClass
import com.coldmint.rust.core.database.code.CodeDataBase
import com.coldmint.rust.core.database.file.FileDataBase
import com.coldmint.rust.core.tool.AppOperator
import com.coldmint.rust.core.tool.DebugHelper
import com.coldmint.rust.core.tool.FileOperator
import com.coldmint.rust.core.web.ServerConfiguration
import com.coldmint.rust.pro.adapters.FileAdapter
import com.coldmint.rust.pro.base.BaseActivity
import com.coldmint.rust.pro.databinding.ActivityEditBinding
import com.coldmint.rust.pro.databinding.EditStartBinding
import com.coldmint.rust.pro.edit.CodeToolAdapter
import com.coldmint.rust.pro.edit.RustCompletionAdapter
import com.coldmint.rust.pro.edit.RustLanguage
import com.coldmint.rust.pro.interfaces.BookmarkListener
import com.coldmint.rust.pro.tool.AppSettings
import com.coldmint.rust.pro.tool.CompletionItemConverter
import com.coldmint.rust.pro.tool.GlobalMethod
import com.coldmint.rust.pro.viewmodel.EditStartViewModel
import com.coldmint.rust.pro.viewmodel.EditViewModel
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.google.android.material.snackbar.Snackbar
import io.github.rosemoe.sora.lang.completion.CompletionPublisher
import io.github.rosemoe.sora.text.CharPosition
import io.github.rosemoe.sora.text.ContentReference
import io.github.rosemoe.sora.widget.EditorSearcher
import io.github.rosemoe.sora.widget.component.EditorAutoCompletion
import io.github.rosemoe.sora.widget.schemes.EditorColorScheme
import jp.wasabeef.glide.transformations.BlurTransformation
import java.io.File
import java.util.*
import kotlin.collections.ArrayList


class EditActivity : BaseActivity<ActivityEditBinding>() {
    private val viewModel by lazy {
        ViewModelProvider(this).get(EditViewModel::class.java)
    }

    private lateinit var turretCoordinateResults: ActivityResultLauncher<Intent>


    private lateinit var rustLanguage: RustLanguage

    private var fileAdapter: FileAdapter? = null

    //是第一次启动嘛
    var isFirst = true

    /**
     * 编辑器左侧视图
     */
    private val editStartBinding: EditStartBinding by lazy {
        EditStartBinding.bind(viewBinding.root)
    }

    /**
     * 编辑器左侧视图模型
     */
    private val editStartViewModel: EditStartViewModel by lazy {
        ViewModelProvider(this).get(EditStartViewModel::class.java)
    }

//    /**
//     * 编辑器右侧视图模型
//     */
//    private val editEndViewModel: EditEndViewModel by lazy {
//        ViewModelProvider(this).get(EditEndViewModel::class.java)
//    }

//    /**
//     * 编辑器右侧视图
//     */
//    private val editEndBinding: EditEndBinding by lazy {
//        EditEndBinding.bind(viewBinding.root)
//    }

    fun showRenewalTip() {
        val debugKey = "续费提示"
        val account = AppSettings.getValue(AppSettings.Setting.Account, "")
        val time = AppSettings.getValue(AppSettings.Setting.ExpirationTime, 0.toLong())
        if (time == 0.toLong() || account.isBlank()) {
            DebugHelper.printLog(debugKey, "没有账号或续费信息，关闭界面。")
            Toast.makeText(this, "请先登录", Toast.LENGTH_SHORT).show()
            finish()
        } else {
            val stringTime = ServerConfiguration.toStringTime(time)
            if (stringTime == ServerConfiguration.ForeverTime) {
                DebugHelper.printLog(debugKey, "永久用户无需处理续费提示。")
            } else {
                val difference = time - System.currentTimeMillis()
                if (difference < 0) {
                    //已经过期
                    DebugHelper.printLog(debugKey, "此用户的助手已经过期。")
                    MaterialAlertDialogBuilder(this).setTitle(R.string.activation_app)
                        .setMessage(
                            R.string.activation_app_tip
                        ).setPositiveButton(R.string.activate) { i, i2 ->
                            finish()
                            val intent = Intent(this, ActivateActivity::class.java)
                            startActivity(intent)
                        }.setNegativeButton(R.string.dialog_cancel) { i, i2 ->
                            finish()
                        }.setCancelable(false).show()
                } else if (difference < 604800000) {
                    //如果在7天内到期
                    val day = difference / 86400000 + 1
                    DebugHelper.printLog(
                        debugKey,
                        "显示续费提醒(" + difference + "/86400000)" + day + "天。"
                    )
                    MaterialAlertDialogBuilder(this).setTitle(R.string.renewal_tip_title)
                        .setMessage(
                            String.format(
                                getString(R.string.renewal_tip_msg),
                                account,
                                day
                            )
                        ).setPositiveButton(R.string.renewal) { i, i2 ->
                            val intent = Intent(this, ActivateActivity::class.java)
                            startActivity(intent)
                        }.setNegativeButton(R.string.dialog_cancel) { i, i2 ->
                        }.setCancelable(false).show()
                } else {
                    DebugHelper.printLog(debugKey, "还剩余7天以上，无需提示。")

                }
            }
        }
    }

    /**
     * 加载主要的观察者
     */
    fun loadMainObserve() {
        viewModel.needSaveLiveData.observe(this) {
            if (it) {
                CoreDialog(this).setTitle(R.string.edit_function).setMessage(R.string.text_changed)
                    .setPositiveButton(R.string.edit_function) {
                        viewModel.saveAllFile(
                            viewBinding.tabLayout.selectedTabPosition,
                            viewBinding.codeEditor.text.toString()
                        ) {
                            viewModel.needCheckAutoSave = false
                            finish()
                        }
                    }.setNegativeButton(R.string.dialog_cancel) {

                    }.setNeutralButton(R.string.not_save_exit) {
                        CoreDialog(this@EditActivity).setTitle(R.string.not_save_exit)
                            .setMessage(R.string.not_save_exit_tip)
                            .setNegativeButton(R.string.dialog_cancel) {

                            }
                            .setPositiveButton(R.string.dialog_ok) {
                                viewModel.needCheckAutoSave = false
                                finish()
                            }.setCancelable(false).show()
                    }.setCancelable(false).show()
            }
        }

        viewModel.englishModeLiveData.observe(this)
        {
            rustLanguage.setEnglish(it)
        }

//        viewBinding.codeEditor.setItemListener { i, completionItem ->
//            viewModel.executorService.submit {
//                val extrasData = completionItem.extrasData
//                if (extrasData != null) {
//                    val listData = extrasData.getString("list")
//                    if (listData != null) {
//                        val lineParser = LineParser(listData)
//                        lineParser.symbol = ","
//                        val list = ArrayList<CompletionItem>()
//                        lineParser.analyse { lineNum, lineData, isEnd ->
//                            val temCodeInfo =
//                                CodeDataBase.getInstance(this).getCodeDao().findCodeByCode(lineData)
//                            if (temCodeInfo == null) {
//
//                            } else {
//                                val CompletionItemConverter = CompletionItemConverter.instance
//                                CompletionItemConverter.init(this)
//                                list.add(
//                                    CompletionItemConverter.codeInfoToCompletionItem(
//                                        temCodeInfo
//                                    )
//                                )
//                            }
//                            true
//                        }
//                        if (list.isNotEmpty()) {
//                            runOnUiThread {
//                                viewBinding.codeEditor.createEditorAutoCompleteList(list)
//                            }
//                        }
//                    }
//                }
//            }
//            true
//        }
        viewModel.openedSourceFileListLiveData.observe(this)
        {
            viewBinding.tabLayout.removeAllTabs()
            viewBinding.tabLayout.isVisible = true
            it.forEach {
                val openedSourceFile = it
                val tab = viewBinding.tabLayout.newTab()
                tab.text = if (openedSourceFile.isNeedSave()) {
                    String.format(
                        getString(R.string.need_save),
                        openedSourceFile.file.name
                    )
                } else {
                    openedSourceFile.file.name
                }
                tab.view.setOnClickListener { view ->
                    val path = it.file.absolutePath
                    if (viewModel.getNowOpenFilePath() != path) {
                        //更新Tab文本
                        val selectedTabPosition = viewBinding.tabLayout.selectedTabPosition
                        val oldTab = viewBinding.tabLayout.getTabAt(selectedTabPosition)
                        val oldOpenedSourceFile =
                            viewModel.openedSourceFileListLiveData.getOpenedSourceFile(
                                selectedTabPosition
                            )
                        val isChanged = oldOpenedSourceFile
                            .isChanged(viewBinding.codeEditor.text.toString())
                        if (isChanged) {
                            oldTab?.text = String.format(
                                getString(R.string.need_save),
                                oldOpenedSourceFile.file.name
                            )
                        }
                        viewModel.setNowOpenFilePath(path)
                        viewModel.codeLiveData.value = openedSourceFile.getEditText()
                    }
                }
                tab.view.setOnLongClickListener {
                    val popupMenu = GlobalMethod.createPopMenu(it)
                    popupMenu.menu.add(R.string.open_directory_of_file)
                    if (viewModel.openedSourceFileListLiveData.value.size > 1) {
                        popupMenu.menu.add(R.string.close)
                    }
                    popupMenu.setOnMenuItemClickListener {
                        when (it.title.toString()) {
                            getString(R.string.close) -> {
                                if (openedSourceFile.isNeedSave()) {
                                    CoreDialog(this).setTitle(R.string.edit_function)
                                        .setMessage(R.string.text_changed)
                                        .setPositiveButton(R.string.edit_function) {
                                            viewModel.saveOneFile(openedSourceFile)
                                            viewModel.closeFile(openedSourceFile)
                                        }.setNegativeButton(R.string.dialog_cancel) {
                                            viewModel.closeFile(openedSourceFile)
                                        }.show()
                                } else {
                                    viewModel.closeFile(openedSourceFile)
                                }
                            }
                            getString(R.string.open_directory_of_file) -> {
                                editStartViewModel.loadPathLiveData.value =
                                    FileOperator.getSuperDirectory(openedSourceFile.file)
                                viewBinding.editDrawerlayout.openDrawer(GravityCompat.START)
                            }
                        }
                        false
                    }
                    popupMenu.show()
                    true
                }
                viewBinding.tabLayout.addTab(tab)
                if (openedSourceFile.file.absolutePath == viewModel.getNowOpenFilePath()) {
                    viewBinding.tabLayout.selectTab(tab)
                    viewModel.codeLiveData.value = openedSourceFile.getEditText()
                }
            }
        }

        viewModel.codeLiveData.observe(this)
        {
//            rustLanguage.autoCompleteProvider.setSourceFolder(
//                FileOperator.getSuperDirectory(
//                    viewModel.getNowOpenFilePath()
//                )
//            )
            //初始化加载路径数据（仅在第一次有效）
            editStartViewModel.initLoadPathLiveData(viewModel.getNowOpenFilePath())
            viewBinding.myProgressBar.isVisible = false
            viewBinding.codeEditor.isVisible = true
            viewBinding.codeEditor.setText(it)
        }
        viewModel.loadingLiveData.observe(
            this
        )
        {
            if (it) {
                viewBinding.myProgressBar.isVisible = true
                viewBinding.codeEditor.isVisible = false
            } else {
                viewBinding.myProgressBar.isVisible = false
                viewBinding.codeEditor.isVisible = true
            }
        }
    }


    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (resultCode == RESULT_OK) {
            when (requestCode) {
                //在找不到资源选择文件
                1 -> {
                    val path = data?.getStringExtra("File") ?: return
                    val file = File(path)
                    val targetFile = viewModel.targetFile
                    if (targetFile != null) {
                        val targetType = FileOperator.getFileType(targetFile)
                        val nowType = FileOperator.getFileType(file)
                        if (targetType == nowType) {
                            val copyResult = FileOperator.copyFile(file, targetFile)
                            if (!copyResult) {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    getText(R.string.copy_file_error),
                                    Snackbar.LENGTH_SHORT
                                ).show()
                            } else {
                                viewModel.addFileInDataBase(targetFile)
                            }
                        } else {
                            Snackbar.make(
                                viewBinding.recyclerview,
                                getText(R.string.bad_file_type),
                                Snackbar.LENGTH_SHORT
                            ).show()
                        }
                    }
                }
                2 -> {
                    //新建源文件
                    val path = data?.getStringExtra("File") ?: return
                    val file = File(path)
                    viewModel.openFile(path)
                    viewModel.addFileInDataBase(file)
                    editStartViewModel.loadPathLiveData.value = FileOperator.getSuperDirectory(file)
                }
                3, 4 -> {
//左侧选择文件(4为相册选择)
                    val path = if (requestCode == 3) {
                        data?.getStringExtra("File")
                    } else {
                        FileOperator.parsePicturePath(this, data)
                    }
                    if (path == null) {
                        return
                    }
                    val file = File(path)
                    val copyFile = File(editStartViewModel.loadPathLiveData.value + "/" + file.name)
                    val copyResult =
                        FileOperator.copyFile(file, copyFile)
                    if (!copyResult) {
                        Snackbar.make(
                            viewBinding.recyclerview,
                            getText(R.string.copy_file_error),
                            Snackbar.LENGTH_SHORT
                        ).show()
                    } else {
                        viewModel.addFileInDataBase(copyFile)
                        editStartViewModel.reloadList()
                    }
                }
            }
        }
    }

    /**
     * 初始化侧滑视图
     */
    private fun initDrawerLayout() {
        viewBinding.editDrawerlayout.addDrawerListener(object : DrawerLayout.DrawerListener {
            override fun onDrawerSlide(drawerView: View, slideOffset: Float) {}
            override fun onDrawerOpened(drawerView: View) {
            }

            override fun onDrawerClosed(drawerView: View) {
                viewBinding.editDrawerlayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED)
            }

            override fun onDrawerStateChanged(newState: Int) {
            }
        })
    }

//    /**
//     * 加载右侧观察者
//     */
//    fun loadEndObserve() {
//        editEndViewModel.loadStateLiveData.observe(this) {
//            editEndBinding.imageview.isVisible = it
//            editEndBinding.textview.isVisible = it
//            editEndBinding.logView.isVisible = !it
//        }
//
//        editEndViewModel.analysisResultLiveData.observe(this) {
//            val adapter = CompileLogAdapter(this, it.toMutableList())
//            editEndBinding.logView.adapter = adapter
//        }
//    }
//
//    /**
//     * 初始化右侧视图
//     */
//    fun initEndView() {
//        editEndBinding.logView.layoutManager = LinearLayoutManager(this)
//    }

    //当用户切换到其他应用界面时
    override fun onPause() {
        if (viewModel.needCheckAutoSave) {
            val need = AppSettings.getValue(AppSettings.Setting.AutoSave, true)
            if (need) {
                viewModel.saveAllFile(
                    viewBinding.tabLayout.selectedTabPosition,
                    viewBinding.codeEditor.text.toString()
                ) {
                    Toast.makeText(this, R.string.auto_save_toast, Toast.LENGTH_SHORT).show()
                }
            }
        }
        super.onPause()
    }

    override fun onResume() {
        super.onResume()
        if (isFirst) {
            isFirst = false
        } else {
            viewModel.needCheckAutoSave = true
        }
    }

    override fun whenCreateActivity(savedInstanceState: Bundle?, canUseView: Boolean) {
        if (canUseView) {
            setReturnButton()
            loadStartObserve()
//            loadEndObserve()
            initDrawerLayout()
            initCodeToolbar()
            initCodeEditor()
            initStartView()
//            initEndView()
            showRenewalTip()
            loadCustomStyle()
            loadSearchLayout()
            turretCoordinateResults =
                registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
                    viewModel.reloadCode()
                }
        } else {
            title = getString(R.string.mod_action1)
            val thisIntent = intent
            val bundle = thisIntent.getBundleExtra("data")
            if (bundle == null) {
                showError("请传入bundle")
                return
            }
            val path = bundle.getString("path")
            if (path == null) {
                showError("请传入路径")
                return
            }
            val modPath = bundle.getString("modPath")
            if (modPath == null) {
                showError("请传入模组路径")
                return
            }
            viewModel.modClass = ModClass(File(modPath))
            loadMainObserve()
            viewModel.loadData()
            viewModel.openFile(path)
        }
    }


    private fun initStartView() {
        editStartBinding.fileList.layoutManager = LinearLayoutManager(this)
        editStartBinding.fab.setOnClickListener {
            val popupMenu = GlobalMethod.createPopMenu(editStartBinding.fab)
            if (fileAdapter != null) {
                val selectPath = fileAdapter!!.selectPath
                if (selectPath != null) {
                    if (fileAdapter!!.isCopyFile && !viewModel.processFiles) {
                        popupMenu.menu.add(R.string.copy_to_this)
                    } else {
                        popupMenu.menu.add(R.string.cut_to_this)
                    }
                }
            }
            popupMenu.menu.add(R.string.create_unit)
            popupMenu.menu.add(R.string.create_folder)
            popupMenu.menu.add(R.string.select_file)
            popupMenu.menu.add(R.string.select_the_image_in_the_album)
            popupMenu.setOnMenuItemClickListener { item ->
                val title = item.title
                val handler = Handler(Looper.getMainLooper())
                when (title) {
                    getText(R.string.create_unit) -> {
                        viewModel.needCheckAutoSave = false
                        val intent = Intent(this@EditActivity, CreateUnitActivity::class.java)
                        val bundle = Bundle()
                        bundle.putString("modPath", viewModel.modClass?.modFile?.absolutePath)
                        bundle.putString("createPath", editStartViewModel.loadPathLiveData.value)
                        intent.putExtra("data", bundle)
                        startActivityForResult(intent, 2)
                    }
                    getString(R.string.select_the_image_in_the_album) -> {
                        this.startActivityForResult(
                            Intent(
                                Intent.ACTION_PICK,
                                MediaStore.Images.Media.EXTERNAL_CONTENT_URI
                            ), 4
                        )
                    }
                    getText(R.string.select_file) -> {
                        viewModel.needCheckAutoSave = false
                        val bundle = Bundle()
                        val intent = Intent(this@EditActivity, FileManagerActivity::class.java)
                        bundle.putString("type", "selectFile")
                        //bundle.putString("path", modClass.getModFile().getAbsolutePath());
                        intent.putExtra("data", bundle)
                        startActivityForResult(intent, 3)
                    }
                    getText(R.string.create_folder) -> {
                        InputDialog(this).setTitle(R.string.create_folder)
                            .setHint(R.string.file_name)
                            .setCancelable(false).setInputCanBeEmpty(false).setMaxNumber(255)
                            .setErrorTip { s, textInputLayout ->
                                val newFolder =
                                    File(editStartViewModel.loadPathLiveData.value + "/" + s)
                                if (newFolder.exists()) {
                                    textInputLayout.error = getString(R.string.folder_error)
                                } else {
                                    textInputLayout.isErrorEnabled = false
                                }
                            }.setPositiveButton(R.string.dialog_ok) { i ->
                                val newFolder =
                                    File(editStartViewModel.loadPathLiveData.value + "/" + i)
                                val res = newFolder.mkdirs()
                                editStartViewModel.reloadList()
                                res
                            }.setNegativeButton(R.string.dialog_cancel) {

                            }.show()
                    }
                    getText(R.string.copy_to_this) -> {
                        viewModel.executorService.submit {
                            viewModel.processFiles = true
                            val selectPath = fileAdapter?.selectPath ?: return@submit
                            val nowPath = editStartViewModel.loadPathLiveData.value
                            val oldFile = File(selectPath)
                            val newFile = File(nowPath + "/" + oldFile.name)
                            if (FileOperator.copyFiles(oldFile, newFile)) {
                                handler.post {
                                    fileAdapter?.cleanSelectPath()
                                    viewModel.processFiles = false
                                    editStartViewModel.reloadList()
                                }
                            } else {
                                handler.post {
                                    Toast.makeText(
                                        this@EditActivity,
                                        getText(R.string.copy_failed),
                                        Toast.LENGTH_SHORT
                                    ).show()
                                    viewModel.processFiles = false
                                }
                            }
                        }
                    }
                    getText(R.string.cut_to_this) -> {
                        viewModel.executorService.submit {
                            viewModel.processFiles = true
                            val selectPath = fileAdapter?.selectPath ?: return@submit
                            val nowPath = editStartViewModel.loadPathLiveData.value
                            val oldFile = File(selectPath)
                            val newFile = File(nowPath + "/" + oldFile.name)
                            if (FileOperator.removeFiles(oldFile, newFile)) {
                                handler.post {
                                    fileAdapter?.cleanSelectPath()
                                    editStartViewModel.reloadList()
                                    viewModel.processFiles = false
                                }
                            } else {
                                handler.post {
                                    Toast.makeText(
                                        this@EditActivity,
                                        getText(R.string.cut_failed),
                                        Toast.LENGTH_SHORT
                                    ).show()
                                    viewModel.processFiles = false
                                }
                            }
                        }
                    }
                }
                false
            }
            popupMenu.show()
        }
    }


    /**
     * 加载左侧观察者
     */
    private fun loadStartObserve() {
        //加载状态改变
        editStartViewModel.loadStatusLiveData.observe(this) {
            editStartBinding.fab.isVisible = it
            editStartBinding.unableOpenView.isVisible = !it
            editStartBinding.fileList.isVisible = it
        }


        //文件列表加载的路径改变
        editStartViewModel.loadPathLiveData.observe(this) {
            editStartViewModel.loadList(it)
        }

        //文件列表的数据改变
        editStartViewModel.fileListLiveData.observe(this) {
            val finalFileAdapter: FileAdapter =
                if (fileAdapter == null) {
                    fileAdapter = FileAdapter(this, it)
                    fileAdapter!!
                } else {
                    fileAdapter?.setNewDataList(it)
                    fileAdapter!!
                }
            finalFileAdapter.setItemEvent { i, fileItemBinding, viewHolder, file ->
                fileItemBinding.contentView.setOnClickListener {
                    if (file == null) {
                        editStartViewModel.loadPathLiveData.value = FileOperator.getSuperDirectory(
                            editStartViewModel.loadPathLiveData.value ?: ""
                        )
                    } else {
                        if (file.isDirectory) {
                            editStartViewModel.loadPathLiveData.value = file.absolutePath
                        } else {
                            viewModel.openFile(file.absolutePath)
                            viewBinding.editDrawerlayout.closeDrawer(GravityCompat.START)
                        }
                    }
                }

                fileItemBinding.more.setOnClickListener {
                    if (file == null) {
                        return@setOnClickListener
                    }
                    val popupMenu = GlobalMethod.createPopMenu(it)
                    val cutBoardMenu = popupMenu.menu.addSubMenu(R.string.cut_board_operation)
                    val fileMenu = popupMenu.menu.addSubMenu(R.string.file_operation)
                    val bookmarksMenu = popupMenu.menu.addSubMenu(R.string.mine_bookmarks)
                    cutBoardMenu.add(R.string.copy_file_name)
                    cutBoardMenu.add(R.string.copy_file_path)
                    cutBoardMenu.add(R.string.copy_file_absolutely_path)
                    fileMenu.add(R.string.copy)
                    fileMenu.add(R.string.cut_off)
                    fileMenu.add(R.string.rename)
                    fileMenu.add(R.string.del_mod)
                    val bookmarkManager = editStartViewModel.bookmarkManager
                    if (bookmarkManager.contains(file)) {
                        bookmarksMenu.add(R.string.remove_bookmark)
                    } else {
                        bookmarksMenu.add(R.string.add_bookmark)
                    }
                    bookmarksMenu.add(R.string.bookmark_manager)
                    val bookmarkContent: SubMenu? =
                        if (bookmarkManager.size > 0) {
                            bookmarksMenu.addSubMenu(R.string.jump_a_bookmark)
                        } else {
                            null
                        }
                    //哈希表映射(名称，路径)
                    val bookmarkMap = HashMap<String, String?>()
                    bookmarkManager.fromList(object : BookmarkListener {
                        override fun find(path: String, name: String) {
                            bookmarkMap[name] = path
                            bookmarkContent!!.add(name)
                        }

                    })
                    popupMenu.setOnMenuItemClickListener(PopupMenu.OnMenuItemClickListener { item ->
                        val title = item.title
                        if (title == getText(R.string.copy_file_name)) {
                            viewBinding.editDrawerlayout.closeDrawer(GravityCompat.START)
                            val name = file.name
                            GlobalMethod.copyText(
                                this@EditActivity,
                                name,
                                viewBinding.recyclerview
                            )
                        } else if (title == getText(R.string.copy_file_path)) {
                            viewBinding.editDrawerlayout.closeDrawer(GravityCompat.START)
                            val path = file.absolutePath
                            GlobalMethod.copyText(
                                this@EditActivity,
                                path,
                                viewBinding.recyclerview
                            )
                        } else if (title == getText(R.string.copy_file_absolutely_path)) {
                            viewBinding.editDrawerlayout.closeDrawer(GravityCompat.START)
                            if (viewModel.modClass == null) {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    getText(R.string.copy_file_absolutely_path_error),
                                    Snackbar.LENGTH_SHORT
                                ).show()
                                return@OnMenuItemClickListener true
                            }
                            var relative =
                                FileOperator.getRelativePath(
                                    file,
                                    viewModel.modClass!!.modFile
                                )
                            if (relative == null || relative.isEmpty()) {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    getText(R.string.copy_file_absolutely_path_error),
                                    Snackbar.LENGTH_SHORT
                                ).show()
                            } else {
                                relative = "ROOT:" + relative.substring(1)
                                GlobalMethod.copyText(
                                    this@EditActivity,
                                    relative,
                                    viewBinding.recyclerview
                                )
                            }
                        } else if (title == getText(R.string.del_mod)) {
                            val absolutePath = file.absolutePath
                            var canDel = true
                            if (viewModel.openedSourceFileListLiveData.value.isNotEmpty()) {
                                for (openedFile in viewModel.openedSourceFileListLiveData.value) {
                                    val path = openedFile.file.absolutePath
                                    if (path.startsWith(absolutePath)) {
                                        canDel = false
                                    }
                                }
                            }
                            if (!canDel) {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    R.string.unable_del,
                                    Snackbar.LENGTH_SHORT
                                ).show()
                                return@OnMenuItemClickListener false
                            }
                            if (FileOperator.delete_files(file)) {
                                viewModel.removeFileInDataBase(file)
                                editStartViewModel.reloadList()
                            }
                        } else if (title == getText(R.string.copy)) {
                            fileAdapter?.setSelectPath(file.absolutePath, true)
                        } else if (title == getText(R.string.cut_off)) {
                            val absolutePath = file.absolutePath
                            var canCut = true
                            if (viewModel.openedSourceFileListLiveData.value.isNotEmpty()) {
                                for (openedFile in viewModel.openedSourceFileListLiveData.value) {
                                    val path = openedFile.file.absolutePath
                                    if (path.startsWith(absolutePath)) {
                                        canCut = false
                                    }
                                }
                            }
                            if (!canCut) {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    R.string.unable_cut,
                                    Snackbar.LENGTH_SHORT
                                ).show()
                                return@OnMenuItemClickListener false
                            }
                            fileAdapter?.setSelectPath(file.absolutePath, false)
                        } else if (title == getText(R.string.rename)) {
                            val absolutePath = file.absolutePath
                            var canRename = true
                            if (viewModel.openedSourceFileListLiveData.value.isNotEmpty()) {
                                for (openedFile in viewModel.openedSourceFileListLiveData.value) {
                                    val path = openedFile.file.absolutePath
                                    if (path.startsWith(absolutePath)) {
                                        canRename = false
                                    }
                                }
                            }
                            if (!canRename) {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    R.string.unable_rename,
                                    Snackbar.LENGTH_SHORT
                                ).show()
                                return@OnMenuItemClickListener false
                            }
                            val oldName = file.name
                            InputDialog(this).setTitle(R.string.rename).setMaxNumber(255)
                                .setText(oldName).setPositiveButton(R.string.dialog_ok) { it ->
                                    val newName = it
                                    if (newName != oldName) {
                                        val reNameFile =
                                            File(editStartViewModel.loadPathLiveData.value + "/" + newName)
                                        file.renameTo(reNameFile)
                                        editStartViewModel.reloadList()
                                    }
                                    true
                                }.setNegativeButton(R.string.dialog_close) {

                                }.show()
                        } else if (title == getString(R.string.remove_bookmark)) {
                            viewBinding.editDrawerlayout.closeDrawer(GravityCompat.START)
                            val removeBookmark =
                                bookmarkManager.removeBookmark(file.absolutePath)
                            if (removeBookmark) {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    R.string.remove_bookmark_success,
                                    Snackbar.LENGTH_SHORT
                                ).setAction(R.string.symbol10) {
                                    bookmarkManager.addBookmark(
                                        file.absolutePath,
                                        FileOperator.getPrefixName(file)
                                    )
                                    viewBinding.editDrawerlayout.openDrawer(GravityCompat.START)
                                }.show()
                            } else {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    R.string.remove_bookmark_fail,
                                    Snackbar.LENGTH_SHORT
                                ).show()
                            }
                        } else if (title == getString(R.string.add_bookmark)) {
                            viewBinding.editDrawerlayout.closeDrawer(GravityCompat.START)
                            val addBookmark = bookmarkManager.addBookmark(
                                file.absolutePath,
                                FileOperator.getPrefixName(file)
                            )
                            if (addBookmark) {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    R.string.add_bookmark_success,
                                    Snackbar.LENGTH_SHORT
                                ).show()
                            } else {
                                Snackbar.make(
                                    viewBinding.recyclerview,
                                    R.string.add_bookmark_fail,
                                    Snackbar.LENGTH_SHORT
                                ).show()
                            }
                        } else if (title == getString(R.string.bookmark_manager)) {
                            bookmarkManager.save()
                            viewModel.needCheckAutoSave = false
                            startActivity(
                                Intent(
                                    this@EditActivity,
                                    BookmarkManagerActivity::class.java
                                )
                            )
                        } else {
                            if (bookmarkMap.containsKey(title)) {
                                val newFile = File(bookmarkMap[title])
                                if (newFile.exists()) {
                                    if (newFile.isDirectory) {
                                        editStartViewModel.loadList(newFile.absolutePath)
                                    } else {
                                        viewModel.openFile(newFile.absolutePath)
                                    }
                                } else {
                                    viewBinding.editDrawerlayout.closeDrawer(GravityCompat.START)
                                    Snackbar.make(
                                        viewBinding.recyclerview,
                                        R.string.bookmark_jump_failed,
                                        Snackbar.LENGTH_SHORT
                                    ).show()
                                }
                            }
                        }
                        false
                    })
                    popupMenu.show()
                }

            }
            editStartBinding.fileList.adapter = fileAdapter
        }
    }

    /**
     * 初始化代码工具栏
     */
    fun initCodeToolbar() {
        val items = ArrayList<String>()
        items.add(getString(R.string.symbol1))
        items.add(getString(R.string.symbol9))
        items.add(getString(R.string.code_tip))
        items.add(getString(R.string.code_table))
//        items.add(getString(R.string.code_language_on))
        items.add(getString(R.string.symbol11))
        val customSymbol = AppSettings.getValue(
            AppSettings.Setting.CustomSymbol,
            "[],:='*_$%@#{}()"
        )
        val chars = customSymbol.toCharArray()
        if (chars.isNotEmpty()) {
            for (c in chars) {
                items.add(c.toString())
            }
        }
        val codeToolAdapter = CodeToolAdapter(this, items)
        codeToolAdapter.setItemEvent { i, codeToolItemBinding, viewHolder, item ->
            codeToolItemBinding.codeTextItemView.setOnClickListener {
                if (item == getString(R.string.symbol11)) {
                    GlobalMethod.showColorPickerDialog(this) {
                        viewBinding.codeEditor.insertText(it, it.length)
                    }
                } else if (item == getString(R.string.code_table)) {
                    viewModel.needCheckAutoSave = false
                    startActivity(Intent(this@EditActivity, CodeTableActivity::class.java))
                } else if (item == getString(R.string.symbol1)) {
                    //关闭手势滑动
                    viewBinding.editDrawerlayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
                    openDrawer(GravityCompat.START)
                } else if (item == getString(R.string.symbol9)) {
                    if (!viewBinding.codeEditor.formatCodeAsync()) {
                        Snackbar.make(
                            viewBinding.codeEditor,
                            R.string.format_failed,
                            Snackbar.LENGTH_SHORT
                        ).show()
                    }
                } else if (item == getString(R.string.code_tip)) {
                    viewBinding.codeEditor.getComponent(EditorAutoCompletion::class.java)
                        .requireCompletion()
                    //                    viewModel.executorService.submit {
//                        try {
//                            val list = ArrayList<CompletionItem>()
//                            //如果不包含:搜索键
//                            val lineNumber = viewBinding.codeEditor.selectedLineNumber
//                            val navigationList =
//                                viewBinding.codeEditor.textAnalyzeResult.navigation
//                            var section: String? = null
//                            if (navigationList != null && navigationList.isNotEmpty()) {
//                                for (navigation in navigationList) {
//                                    if (navigation.line > lineNumber) {
//                                        break
//                                    } else {
//                                        section = navigation.label
//                                    }
//                                }
//                            }
//                            //如果不在任何节内
//                            if (section == null) {
//                                runOnUiThread {
//                                    runOnUiThread {
//                                        Snackbar.make(
//                                            viewBinding.recyclerview,
//                                            this.getString(R.string.code_tip_error1),
//                                            Snackbar.LENGTH_SHORT
//                                        ).show()
//                                    }
//                                }
//                                return@submit
//                            }
//                            val trueSection =
//                                rustLanguage.autoCompleteProvider.getSectionType(section)
//                            val codeDataBase = CodeDataBase.getInstance(this)
//                            val lineData =
//                                viewBinding.codeEditor.text.getLine(lineNumber).toString()
//                            if (lineData.startsWith('[') && lineData.endsWith(']')) {
//                                runOnUiThread {
//                                    Snackbar.make(
//                                        viewBinding.recyclerview,
//                                        R.string.code_tip_error2,
//                                        Snackbar.LENGTH_SHORT
//                                    ).show()
//                                }
//                                return@submit
//                            }
//                            val offset = lineData.indexOf(':')
//                            if (offset > -1) {
//                                //如果包含:
//                                runOnUiThread {
//                                    Snackbar.make(
//                                        viewBinding.recyclerview,
//                                        this.getString(R.string.can_not_tip_value),
//                                        Snackbar.LENGTH_SHORT
//                                    ).show()
//                                }
//                                return@submit
//                            } else {
//                                val codeInfoList = if (lineData.isBlank()) {
//                                    codeDataBase.getCodeDao().findCodeBySection(trueSection)
//                                } else {
//                                    val number = AppSettings.getValue(
//                                        AppSettings.Setting.IdentifiersPromptNumber,
//                                        40
//                                    )
//                                    codeDataBase.getCodeDao()
//                                        .findCodeByKeyFromSection(lineData, trueSection, number)
//                                }
//                                if (codeInfoList != null && codeInfoList.isNotEmpty()) {
//                                    val CompletionItemConverter =
//                                        CompletionItemConverter.instance.init(this)
//                                    codeInfoList.forEach {
//                                        list.add(
//                                            CompletionItemConverter.codeInfoToCompletionItem(
//                                                it
//                                            )
//                                        )
//                                    }
//                                } else {
//                                    runOnUiThread {
//                                        Snackbar.make(
//                                            viewBinding.recyclerview,
//                                            String.format(
//                                                this.getString(R.string.code_tip_error3),
//                                                SourceFile.getSectionType(section)
//                                            ),
//                                            Snackbar.LENGTH_SHORT
//                                        ).show()
//                                    }
//                                }
//                            }
//                            runOnUiThread {
//                                viewBinding.codeEditor.createEditorAutoCompleteList(list)
//                            }
//                        } catch (e: Exception) {
//                            e.printStackTrace()
//                        }
//
//                    }
                } else {
                    try {
                        viewBinding.codeEditor.insertText(item, item.length)
                    } catch (e: Exception) {
                        e.printStackTrace()
                    }
                }
            }
        }
        val linearLayoutManager = LinearLayoutManager(this)
        linearLayoutManager.orientation = RecyclerView.HORIZONTAL
        viewBinding.recyclerview.isVisible = true
        viewBinding.recyclerview.layoutManager = linearLayoutManager
        viewBinding.recyclerview.adapter = codeToolAdapter
    }

    //初始化编辑器
    fun initCodeEditor() {
        //CodEditor初始化
        viewBinding.codeEditor.isWordwrap = true
        val useFont = AppSettings.getValue(AppSettings.Setting.UseJetBrainsMonoFont, true)
        if (useFont) {
            viewBinding.codeEditor.typefaceText = Typeface.createFromAsset(
                assets,
                "JetBrainsMono-Regular.ttf"
            )
        }
        rustLanguage = RustLanguage()
        rustLanguage.setCodeDataBase(CodeDataBase.getInstance(this))
        rustLanguage.setFileDataBase(
            FileDataBase.getInstance(
                this,
                viewModel.modClass!!.modName
            )
        )
        rustLanguage.setCodeEditor(viewBinding.codeEditor)

        val codeEditBackGroundEnable =
            AppSettings.getValue(AppSettings.Setting.CodeEditBackGroundEnable, false)
        val rustCompletionAdapter = RustCompletionAdapter()
        rustCompletionAdapter.setEditBackground(codeEditBackGroundEnable)
        viewBinding.codeEditor.setAutoCompletionItemAdapter(rustCompletionAdapter)
        viewBinding.codeEditor.isVerticalScrollBarEnabled = false
        val path = viewModel.modClass?.modFile?.absolutePath ?: ""
        CompletionItemConverter.configurationFileConversion(
            path,
            "ROOT",
            path
        )
        viewBinding.codeEditor.setEditorLanguage(rustLanguage)
    }


    /**
     * 加载自动
     */
    fun loadCustomStyle() {
        val key = "加载自定义编辑框样式"
        val editorColorScheme = EditorColorScheme()
        val codeEditBackGroundEnable =
            AppSettings.getValue(AppSettings.Setting.CodeEditBackGroundEnable, false)
        val backgroundColor =
            if (codeEditBackGroundEnable) {
                DebugHelper.printLog(key, "启用背景图像，设置背景为透明。")
                Color.TRANSPARENT
            } else {
                DebugHelper.printLog(key, "未启用背景图像，设置背景为窗口颜色。")
                GlobalMethod.getThemeColor(this, android.R.attr.windowBackground)
            }
        val darkMode = AppSettings.getValue(AppSettings.Setting.NightMode, false)
        if (darkMode) {
            //代码（可识别的关键字）
            editorColorScheme.setColor(
                EditorColorScheme.KEYWORD,
                Color.parseColor(AppSettings.getValue(AppSettings.Setting.KeywordColorDark, ""))
            )
            //默认文本
            editorColorScheme.setColor(
                EditorColorScheme.TEXT_NORMAL,
                Color.parseColor(AppSettings.getValue(AppSettings.Setting.TextColorDark, ""))
            )
            //注释
            editorColorScheme.setColor(
                EditorColorScheme.COMMENT,
                Color.parseColor(AppSettings.getValue(AppSettings.Setting.AnnotationColorDark, ""))
            )
            //节
            editorColorScheme.setColor(
                EditorColorScheme.FUNCTION_NAME,
                Color.parseColor(AppSettings.getValue(AppSettings.Setting.SectionColorDark, ""))
            )
        } else {
            //代码（可识别的关键字）
            editorColorScheme.setColor(
                EditorColorScheme.KEYWORD,
                Color.parseColor(AppSettings.getValue(AppSettings.Setting.KeywordColor, ""))
            )
            //默认文本
            editorColorScheme.setColor(
                EditorColorScheme.TEXT_NORMAL,
                Color.parseColor(AppSettings.getValue(AppSettings.Setting.TextColor, ""))
            )
            //注释
            editorColorScheme.setColor(
                EditorColorScheme.COMMENT,
                Color.parseColor(AppSettings.getValue(AppSettings.Setting.AnnotationColor, ""))
            )
            //节
            editorColorScheme.setColor(
                EditorColorScheme.FUNCTION_NAME,
                Color.parseColor(AppSettings.getValue(AppSettings.Setting.SectionColor, ""))
            )
        }
        editorColorScheme.setColor(
            EditorColorScheme.WHOLE_BACKGROUND,
            backgroundColor
        )
        editorColorScheme.setColor(
            EditorColorScheme.LINE_NUMBER_BACKGROUND,
            backgroundColor
        )
        editorColorScheme.setColor(EditorColorScheme.COMPLETION_WND_BACKGROUND, backgroundColor)
        if (codeEditBackGroundEnable) {
            //设置自定义背景图
            Glide.with(this)
                .load(AppSettings.getValue(AppSettings.Setting.CodeEditBackGroundPath, "")).apply(
                    RequestOptions.bitmapTransform(
                        BlurTransformation(
                            AppSettings.getValue(
                                AppSettings.Setting.BlurTransformationValue,
                                1
                            )
                        )
                    )
                ).into(object : CustomTarget<Drawable>() {
                    override fun onResourceReady(
                        resource: Drawable,
                        transition: Transition<in Drawable>?
                    ) {
                        window.setBackgroundDrawable(resource)
                    }

                    override fun onLoadCleared(placeholder: Drawable?) {

                    }

                })

        }
        viewBinding.codeEditor.colorScheme = editorColorScheme
    }

    override fun onCreateOptionsMenu(menu: Menu): Boolean {
        val inflater = menuInflater
        inflater.inflate(R.menu.menu_editer, menu)
        return true
    }


    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
        if (keyCode == KeyEvent.KEYCODE_BACK && event.action == KeyEvent.ACTION_DOWN) {
            if (viewModel.checkFilesIfNeedSave(
                    viewBinding.tabLayout.selectedTabPosition,
                    viewBinding.codeEditor.text.toString()
                )
            ) {
                return true
            }
        }
        return super.onKeyDown(keyCode, event)
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        when (item.itemId) {
            android.R.id.home -> {
                editStartViewModel.bookmarkManager.save()
                if (viewModel.checkFilesIfNeedSave(
                        viewBinding.tabLayout.selectedTabPosition,
                        viewBinding.codeEditor.text.toString()
                    )
                ) {
                    return true
                }
            }
            R.id.turret_design -> {
                val needSave = viewModel.checkOneFileIfNeedSave(
                    viewBinding.tabLayout.selectedTabPosition,
                    viewBinding.codeEditor.text.toString()
                )
                if (needSave) {
                    Snackbar.make(viewBinding.codeEditor, R.string.save_tip, Snackbar.LENGTH_SHORT)
                        .show()
                } else {
                    val goIntent = Intent(this, TurretDesignActivity::class.java)
                    val modPath = viewModel.modClass!!.modFile.absolutePath
                    val filePath = viewModel.getNowOpenFilePath()
                    goIntent.putExtra("modPath", modPath)
                    goIntent.putExtra("filePath", filePath)
                    turretCoordinateResults.launch(goIntent)
                }
            }
            R.id.display_source_code -> {
                val file = File(viewModel.getNowOpenFilePath())
                val code = FileOperator.readFile(file)
                MaterialAlertDialogBuilder(this).setTitle(file.name).setMessage(code)
                    .setNegativeButton(R.string.dialog_ok) { i, i2 ->
                    }.setCancelable(false).show()
            }
            R.id.clear_code_cache -> {
                Snackbar.make(
                    viewBinding.recyclerview,
                    getString(R.string.clean_up_code_cache_complete),
                    Snackbar.LENGTH_SHORT
                ).show()
            }
            R.id.open_game_test -> {
                val packName = AppSettings.getValue(
                    AppSettings.Setting.GamePackage,
                    GlobalMethod.DEFAULT_GAME_PACKAGE
                )
                if (AppOperator.isAppInstalled(this@EditActivity, packName)) {
                    AppOperator.openApp(this@EditActivity, packName)
                } else {
                    Snackbar.make(
                        viewBinding.recyclerview,
                        R.string.no_game_installed,
                        Snackbar.LENGTH_SHORT
                    ).show()
                }
            }
//            R.id.code_navigation -> {
//                viewModel.executorService.submit {
//                    val labels = viewBinding.codeEditor..navigation
//                    if (labels == null || labels.size == 0) {
//                        runOnUiThread {
//                            Snackbar.make(
//                                viewBinding.recyclerview,
//                                R.string.not_find_code_navigation,
//                                Snackbar.LENGTH_SHORT
//                            ).show()
//                        }
//                    } else {
//                        val items = ArrayList<CharSequence>()
//                        var i = 0
//                        while (i < labels.size) {
//                            items.add(labels[i].label)
//                            i++
//                        }
//                        val tip = String.format(getString(R.string.navigation_tip), items.size)
//                        runOnUiThread {
//                            MaterialDialog(this).show {
//                                title(R.string.code_navigation).positiveButton(R.string.dialog_cancel)
//                                    .message(text = tip)
//                                    .listItems(
//                                        items = items,
//                                        waitForPositiveButton = false,
//                                        selection = object : ItemListener {
//                                            override fun invoke(
//                                                dialog: MaterialDialog,
//                                                offset: Int,
//                                                text: CharSequence
//                                            ) {
//                                                viewBinding.codeEditor.jumpToLine(
//                                                    labels[offset].line
//                                                )
//                                                viewBinding.codeEditor.moveSelectionEnd()
//                                                dialog.dismiss()
//                                            }
//
//                                        })
//                            }
//                        }
//                    }
//                }
//            }
            R.id.save_text -> {
                val openedSourceFile =
                    viewModel.openedSourceFileListLiveData.getOpenedSourceFile(viewBinding.tabLayout.selectedTabPosition)
                val needSave =
                    openedSourceFile.isChanged(viewBinding.codeEditor.text.toString())
                if (needSave) {
                    viewModel.compilerFile(openedSourceFile) {
                        viewModel.openedSourceFileListLiveData.getOpenedSourceFile(
                            viewBinding.tabLayout.selectedTabPosition
                        ).save(it)
                    }
                }
                Snackbar.make(
                    viewBinding.recyclerview,
                    R.string.save_complete2,
                    Snackbar.LENGTH_SHORT
                ).show()
            }
            R.id.show_line_number -> {
                viewBinding.codeEditor.isLineNumberEnabled =
                    !viewBinding.codeEditor.isLineNumberEnabled
                item.isChecked = viewBinding.codeEditor.isLineNumberEnabled
            }
            R.id.word_wrap -> {
                viewBinding.codeEditor.isWordwrap = !viewBinding.codeEditor.isWordwrap
                item.isChecked = viewBinding.codeEditor.isWordwrap
            }
            R.id.convertToTemplate -> {
                viewModel.needCheckAutoSave = false
                val intent = Intent(this@EditActivity, TemplateMakerActivity::class.java)

                val file = File(viewModel.getNowOpenFilePath())
                intent.putExtra(
                    "path",
                    viewModel.getNowOpenFilePath()
                )
                intent.putExtra(
                    "name",
                    FileOperator.getPrefixName(file)
                )
                startActivity(intent)
            }
            R.id.text_undo -> {
                viewBinding.codeEditor.undo()
            }
            R.id.text_redo -> {
                viewBinding.codeEditor.redo()
            }
            R.id.search_view -> {
                viewBinding.searchLayout.isVisible = true
                viewBinding.allButton.isVisible = false
                viewBinding.replaceEditText.setText("")
                viewBinding.replaceLayout.isVisible = false
                viewBinding.findEditText.setText("")
            }
        }
        return super.onOptionsItemSelected(item)
    }


    /**
     * 加载搜索布局
     */
    fun loadSearchLayout() {
        viewBinding.closeButton.setOnClickListener {
            viewBinding.searchLayout.isVisible = false
            viewBinding.codeEditor.searcher.stopSearch()
        }
        viewBinding.nextButton.setOnClickListener {
            val find = viewBinding.findEditText.text.toString()
            if (find.isNotBlank()) {
                viewBinding.codeEditor.searcher.search(
                    find,
                    EditorSearcher.SearchOptions(false, false)
                )
                viewBinding.codeEditor.searcher.gotoNext()
            }
        }
        viewBinding.lastButton.setOnClickListener {
            val find = viewBinding.findEditText.text.toString()
            if (find.isNotBlank()) {
                viewBinding.codeEditor.searcher.search(
                    find,
                    EditorSearcher.SearchOptions(false, false)
                )
                viewBinding.codeEditor.searcher.gotoPrevious()
            }
        }
        viewBinding.allButton.setOnClickListener {
            val find = viewBinding.findEditText.text.toString()
            val re = viewBinding.replaceEditText.text.toString()
            if (find.isNotBlank() && re.isNotBlank()) {
                viewBinding.codeEditor.searcher.search(
                    find,
                    EditorSearcher.SearchOptions(false, false)
                )
                viewBinding.codeEditor.searcher.replaceAll(re)
            }
        }
        viewBinding.replaceButton.setOnClickListener {
            val isVisible = viewBinding.replaceLayout.isVisible
            if (isVisible) {
                val find = viewBinding.findEditText.text.toString()
                val re = viewBinding.replaceEditText.text.toString()
                if (find.isNotBlank() && re.isNotBlank()) {
                    viewBinding.codeEditor.searcher.search(
                        find,
                        EditorSearcher.SearchOptions(false, false)
                    )
                    viewBinding.codeEditor.searcher.replaceThis(re)
                    viewBinding.codeEditor.searcher.gotoNext()
                }
            } else {
                viewBinding.replaceLayout.isVisible = true
                viewBinding.allButton.isVisible = true
            }
        }
    }

    /**
     * 打开侧滑
     */
    fun openDrawer(gravity: Int) {
        viewBinding.editDrawerlayout.openDrawer(gravity)
        viewBinding.codeEditor.hideAutoCompleteWindow()
        viewBinding.codeEditor.hideSoftInput()
    }


    override fun getViewBindingObject(layoutInflater: LayoutInflater): ActivityEditBinding {
        return ActivityEditBinding.inflate(layoutInflater)
    }
}