PDFReaderReaderModule/src/main/java/com/kdanmobile/reader/ReaderActivity.kt

package com.kdanmobile.reader

import android.annotation.SuppressLint
import android.app.Activity
import android.app.Dialog
import android.content.Context
import androidx.lifecycle.Observer
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.os.Bundle
import androidx.constraintlayout.widget.ConstraintLayout
import androidx.constraintlayout.widget.ConstraintSet
import com.google.android.material.snackbar.Snackbar
import androidx.core.content.ContextCompat
import androidx.appcompat.app.AlertDialog
import android.util.DisplayMetrics
import android.view.*
import android.view.animation.AnimationUtils
import android.widget.*
import com.kdanmobile.base.KdanBaseActivity
import com.kdanmobile.kmpdfkit.pdfcommon.PDFInfo
import com.kdanmobile.kmpdfkit.manager.KMPDFFactory
import com.kdanmobile.kmpdfkit.pdfcommon.*
import com.kdanmobile.reader.Utils.applyConstraintSet
import com.kdanmobile.reader.additionalpage.*
import com.kdanmobile.reader.annotationattribute.AnnotationAttribute
import com.kdanmobile.reader.annotationattribute.AnnotationColor
import com.kdanmobile.reader.annotationattribute.InkAttribute
import com.kdanmobile.reader.koin.ReadModuleKoinComponent
import com.kdanmobile.reader.password.DialogPasswordActivity
import com.kdanmobile.reader.screen.contextmenu.TextBoxContextMenuActionListener
import com.kdanmobile.reader.screen.model.SharePrefsModel
import com.kdanmobile.reader.screen.reader.mediabox.MediaBoxView
import com.kdanmobile.reader.screen.reader.mediabox.shape.ShapeTabView
import com.kdanmobile.reader.screen.reader.mediabox.signature.SignatureTabView
import com.kdanmobile.reader.screen.reader.mediabox.stamp.StampTabView
import com.kdanmobile.reader.screen.reader.mediabox.textbox.TextBoxTabView
import com.kdanmobile.reader.screen.view.*
import com.kdanmobile.reader.screen.view.SearchView
import com.kdanmobile.reader.setting.ReaderSettingDialogFragment
import com.kdanmobile.reader.setting.ReaderSettingListener
import com.kdanmobile.reader.thumb.PdfThumbDialogFragment
import com.kdanmobile.reader.thumb.PdfThumbFragmentListener
import com.kdanmobile.reader.utils.AnimationUtil
import com.kdanmobile.reader.utils.DensityUtil
import com.kdanmobile.reader.view.AnnotationAttributeView
import com.kdanmobile.reader.view.AnnotationAttributeWindow
import kotlinx.android.synthetic.main.activity_reader.*
import org.koin.android.viewmodel.ext.android.viewModel
import org.koin.core.parameter.parametersOf
import java.io.File
import java.util.*
import kotlin.properties.Delegates

abstract class ReaderActivity :
        KdanBaseActivity(),
        ReaderSettingListener,
        PdfThumbFragmentListener,
        ReadModuleKoinComponent {

    /**
     * If return true, ReaderActivity.onBackPressed will not run
     */
    abstract fun onBackPressedWhenNothingCanClose(): Boolean
    abstract fun onClickShare()
    abstract fun onClickKdanCloud()
    abstract fun onClickTextReflow()
    abstract fun onClickFileInfo()
    abstract fun onClickIBonPrint()
    abstract fun onClickPrint()
    abstract fun onClickUserGuide()
    abstract fun provideReaderSettingDialogFragment(): ReaderSettingDialogFragment
    abstract fun providePdfThumbDialogFragment(): PdfThumbDialogFragment
    abstract fun isIBonPrintEnabled(): Boolean

    /**
     * return true = intercept, false = not intercept (same as touch event)
     */
    open fun onClickCloseButton(): Boolean { return false }
    open fun isBottomBarKdanCloudBtnVisible(): Boolean { return true }
    open fun insertToRecentDocumentList(filename: String) {}
    open fun saveCurrentPageIndex(filename: String, currentPage: Int) {}
    open fun loadCurrentPageIndex(filename: String, defaultValue: Int): Int = 0
    open fun onOpenedFile() { /* do nothing */ }
    open fun onFilePathOrUriError(filePath: String?) { println("onFilePathOrUriError: $filePath") }
    //  子類別可複寫此方法以客製化KMPDFPageAdapter
    abstract fun providePdfPageAdapter(context: Context, filePickerSupport: FilePicker.FilePickerSupport, kmpdfFactory: KMPDFFactory): KMPDFPageAdapter
    open fun provideAdditionalPageManager(): AdditionalPageManager = AdditionalPageManager()
    protected open fun onEvent(hookEvent: HookEvent) { /* do nothing */ }

    companion object {
        const val KEY_FILE_ABSOLUTE = "file_absolutepath"
        const val KEY_IS_PASSWORD_ACTIVITY_SHOWING = "isShowPasswordActivity"
        const val REQUEST_PASSWORD = 222
    }

    protected val file: File?
        get() {
            return viewModel.file
        }
    protected var filePath: String? = null
        private set
    protected val pdfInfo: PDFInfo?
        get() {
            return viewModel.pdfInfo
        }
    protected val isPasswordProtected: Boolean
        get() {
            return viewModel.isPasswordProtected
        }
    protected val currentPageIndex: Int
        get() {
            return viewModel.pdfInfoHandler.getCurrentPage()
        }
    protected val pageCount: Int
        get() {
            return viewModel.pdfInfoHandler.getPdfPageCount()
        }
    protected val password: String
        get() {
            return viewModel.password
        }
    protected val readerModel: ReaderModel
        get() {
            return viewModel.readerModel
        }
    protected val additionalPageManager: AdditionalPageManager
        get() {
            return viewModel.additionalPageManager
        }

    private val viewModel: ReaderViewModel by viewModel {
        val additionalPageManager = provideAdditionalPageManager()
        val filePath = intent.getStringExtra(KEY_FILE_ABSOLUTE)
        if (!filePath.isNullOrEmpty()) {
            insertToRecentDocumentList(filePath as String)
        }
        val uri = if (!filePath.isNullOrEmpty()) Uri.parse(Uri.encode(filePath)) else null
        // The URI may be null in some special case.
        // Just use Uri.EMPTY and show an alert dialog in onCreate() when the uri is null.
        parametersOf(additionalPageManager, uri ?: Uri.EMPTY)
    }
    private var isShowPasswordActivity = false

    // For hide/show toolbars
    private var isHideToolbar = false
    private lateinit var originConstraintSet: ConstraintSet

    private var menuItemBookmark: MenuItem? = null

    private val UI_ANIMATION_DURATION = 300L
    private val FRAGMENT_READER_SETTING_TAG = "ReaderSetting"
    private val FRAGMENT_PDF_THUMB_TAG = "PdfThumb"

    private var w_318: Int = 0
    private var w_240: Int = 0
    private var w_left: Int = 0

    private var oldLeftToolbarType = ReaderViewModel.LeftToolbarType.NONE

    private var snackbarMediaBox: Snackbar? = null

    private var fileCannotOpenDialog: AlertDialog? = null

    private var isHidePdfPage: Boolean by Delegates.observable(false) { property, oldValue, newValue ->
        if (newValue == oldValue) return@observable
//        println("${property.name} changed from $oldValue to $newValue")
        tv_readerActivity_pdfPage.clearAnimation()
        when (newValue) {
            true -> tv_readerActivity_pdfPage.startAnimation(AnimationUtils.loadAnimation(this, R.anim.fade_out))
            false -> tv_readerActivity_pdfPage.startAnimation(AnimationUtils.loadAnimation(this, R.anim.fade_in))
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
        setContentView(R.layout.activity_reader)
        setSupportActionBar(toolbar_readerActivity)
        isShowPasswordActivity = savedInstanceState?.getBoolean(KEY_IS_PASSWORD_ACTIVITY_SHOWING) ?: false
        // Get file path to determine the opening file is pdf or not
        filePath = intent.getStringExtra(KEY_FILE_ABSOLUTE)

        val displayMetrics = DisplayMetrics()
        windowManager.defaultDisplay.getMetrics(displayMetrics)
        val width = Math.min(DensityUtil.getScreenWidthPx(baseContext), DensityUtil.getScreenHeightPx(baseContext))
        w_318 = 318 * width / 800
        w_240 = 240 * width / 800
        w_left = resources.getDimension(R.dimen.reader_left_right_toolbar_icon_width).toInt()

        cloneOriginConstraintSet()
        setupToolbar()
        setupRightSideToolbar()
        setupMediaBoxView()

        viewModel.isOpenedFileLiveData.observe(this, Observer(this::onIsOpenedFileUpdate))
        viewModel.fileNameLiveData.observe(this, Observer { supportActionBar?.title = it })
        viewModel.annotationModeLiveData.observe(this, Observer(this::onAnnotationModeUpdate))
        viewModel.annotationEitModeLiveData.observe(this, Observer(this::onAnnotationEditModeUpdate))
        viewModel.isCopyModeLiveData.observe(this, Observer (this::onIsCopyModeUpdate))
        viewModel.highLightAttributeLiveData.observe(this, Observer(this::onHighlightAttributeUpdate))
        viewModel.strikeAttributeLiveData.observe(this, Observer(this::onStrikeAttributeUpdate))
        viewModel.underLineAttributeLiveData.observe(this, Observer(this::onUnderlineAttributeUpdate))
        viewModel.inkAttributeLiveData.observe(this, Observer(this::onInkAttributeUpdate))
        viewModel.isOpenedFileLiveData.value?.also { isOpened ->
            if (isShowPasswordActivity) return@also
            if (isOpened) return@also

            if (Uri.EMPTY == viewModel.uri) {
                showFileCannotOpenDialog(getString(R.string.cannot_open_buffer))
                onFilePathOrUriError(filePath)
            } else {
                val result = viewModel.openPdfFile(
                        this@ReaderActivity,
                        password,
                        Runnable { requestPassword() },
                        intent.type
                )
                if (result == ReaderViewModel.OpenFileResult.FAILED) {
                    showFileCannotOpenDialog(getString(R.string.cannot_open_file_Path, filePath))
                }
            }
        }
        setupLeftToolbar()
        setupRightToolbar()
        setupBottomToolbar()
        viewModel.pageIndexLiveData.observe(this, Observer(this::onPageIndexChanged))
        viewModel.isPageInBookmarksLiveData.observe(this, Observer(this::onIsPageInBookmarksChanged))
        viewModel.isLeftToolbarOpenLiveData.observe(this, Observer(this::onLeftToolbarOpenStateChanged))
        viewModel.leftToolbarTypeLiveData.observe(this, Observer(this::onLeftToolbarTypeChanged))
        viewModel.eventLiveData.observe(this , Observer(this::onEvent))
        isHidePdfPage = true
        applySetting()

        setupPdfChangedListener()
        setupInkMenu()
    }

    fun setOnClickLinkListener(onClickLinkListener: ReaderViewModel.OnClickLinkListener?) {
        viewModel.setOnClickLinkListener(onClickLinkListener)
    }

    private fun showFileCannotOpenDialog(title: String) {
        fileCannotOpenDialog = AlertDialog.Builder(this)
                .setTitle(title)
                .setCancelable(false)
                .setPositiveButton(getString(android.R.string.ok)) { dialog, which ->
                    finish()
                }
                .create()
        fileCannotOpenDialog?.show()
    }

    override fun onDestroy() {
        fileCannotOpenDialog?.dismiss()
        setOnClickLinkListener(null)
        super.onDestroy()
    }

    override fun onSaveInstanceState(outState: Bundle?) {
        super.onSaveInstanceState(outState)
        outState?.putBoolean(KEY_IS_PASSWORD_ACTIVITY_SHOWING, isShowPasswordActivity)
    }

    private fun requestPassword(isIncorrectPassword: Boolean = false) {
        isShowPasswordActivity = true
        val intent = Intent(baseContext, DialogPasswordActivity::class.java)
        val bundle = Bundle()
        bundle.putBoolean(DialogPasswordActivity.KEY_IS_INCORRECT_PASSWORD, isIncorrectPassword)
        intent.putExtras(bundle)
        startActivityForResult(intent, REQUEST_PASSWORD)
    }

    fun isPdf(): Boolean {
        var isPdf = filePath?.toLowerCase(Locale.US)?.endsWith(".pdf") ?: false
        //  TODO this workaround should be removed in the future
        //  workaround: password-protected pdf is not editable
        isPdf = isPdf && !isPasswordProtected
        return isPdf
    }

    final override fun onBackPressed() {
        when {
            mediaBoxView.isShown -> mediaBoxView.dismiss()
            onBackPressedWhenNothingCanClose() -> { /** do nothing **/ }
            else -> super.onBackPressed()
        }
    }

    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
        menuInflater.inflate(R.menu.reader_more, menu)
        menuItemBookmark = menu?.findItem(R.id.item_reader_bookmark)
        onIsPageInBookmarksChanged(viewModel.isPageInBookmarksLiveData.value)
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
            menu?.findItem(R.id.item_reader_more_print)?.isVisible = false
        }
        if (!isPdf()) {
            menu?.apply {
                findItem(R.id.item_reader_more_text_reflow)?.isVisible = false
                findItem(R.id.item_reader_more_clear_signature)?.isVisible = false
                findItem(R.id.item_reader_more_file_info)?.isVisible = false
                findItem(R.id.item_reader_more_print)?.isVisible = false
                findItem(R.id.item_ibon_print)?.isVisible = false
            }
            menuItemBookmark?.isVisible = false
        }
        if (!isIBonPrintEnabled()) {
            menu?.findItem(R.id.item_ibon_print)?.isVisible = false
        }
        return true
    }

    @SuppressLint("RestrictedApi")
    override fun onPrepareOptionsPanel(view: View?, menu: Menu?): Boolean {
        /** Force show action menu item icon **/
        menu?.also {
            if ("MenuBuilder" != it::javaClass.get().simpleName) return@also
            try {
                val method = it.javaClass.getDeclaredMethod("setOptionalIconsVisible", java.lang.Boolean.TYPE)
                method.isAccessible = true
                method.invoke(it, true)
            } catch (e: Exception) {
                // Do nothing
            }
        }
        return super.onPrepareOptionsPanel(view, menu)
    }

    protected fun getPageText(pageIndex: Int) = viewModel.getPageText(pageIndex)

    private fun cloneOriginConstraintSet() {
        if (!isBelowKitkat()) {
            originConstraintSet = ConstraintSet().apply {
                clone(constrainLayout_readerActivity_root)
            }
        }
    }

    private fun onIsCopyModeUpdate(isCopyMode: Boolean?) {
        if (isCopyMode == null) return
        when (isCopyMode) {
            true -> hideTopLeftBottomToolbars()
            false -> showAllToolbars()
        }
    }

    private fun onHighlightAttributeUpdate(annotationAttribute: AnnotationAttribute?) {
        if (annotationAttribute == null) return
        view_readerActivity_highLightStroke.setBackgroundColor(annotationAttribute.color)
    }

    private fun onStrikeAttributeUpdate(annotationAttribute: AnnotationAttribute?) {
        if (annotationAttribute == null) return
        view_readerActivity_strikeStroke.setBackgroundColor(annotationAttribute.color)
    }

    private fun onUnderlineAttributeUpdate(annotationAttribute: AnnotationAttribute?) {
        if (annotationAttribute == null) return
        view_readerActivity_underlineStroke.setBackgroundColor(annotationAttribute.color)
    }

    private fun onInkAttributeUpdate(inkAttribute: InkAttribute?) {
        if (inkAttribute == null) return
        val color = inkAttribute.color
        AnnotationColor.values().forEach {
            if (ContextCompat.getColor(this, it.colorResId) == color) {
                val drawableResId = when (it) {
                    AnnotationColor.Color1 -> R.drawable.ic_reader_right_toolbar_ink_color1
                    AnnotationColor.Color2 -> R.drawable.ic_reader_right_toolbar_ink_color2
                    AnnotationColor.Color3 -> R.drawable.ic_reader_right_toolbar_ink_color3
                    AnnotationColor.Color4 -> R.drawable.ic_reader_right_toolbar_ink_color4
                    AnnotationColor.Color5 -> R.drawable.ic_reader_right_toolbar_ink_color5
                    AnnotationColor.Color6 -> R.drawable.ic_reader_right_toolbar_ink_color6
                    AnnotationColor.Color7 -> R.drawable.ic_reader_right_toolbar_ink_color7
                    AnnotationColor.Color8 -> R.drawable.ic_reader_right_toolbar_ink_color8
                    AnnotationColor.Color9 -> R.drawable.ic_reader_right_toolbar_ink_color9
                    AnnotationColor.Color10 -> R.drawable.ic_reader_right_toolbar_ink_color10
                }
                iv_readerActivity_ink.setImageResource(drawableResId)
                return
            }
        }
    }

    private fun onAnnotationModeUpdate(annotationMode: ReaderViewModel.AnnotationMode?) {
        if (annotationMode == null) return
        if (viewModel.isCrop) return
        val map = HashMap<ReaderViewModel.AnnotationMode, View>().apply {
            put(ReaderViewModel.AnnotationMode.HIGHLIGHT, iv_readerActivity_highLight)
            put(ReaderViewModel.AnnotationMode.STRIKE, iv_readerActivity_strike)
            put(ReaderViewModel.AnnotationMode.UNDERLINE, iv_readerActivity_underline)
            put(ReaderViewModel.AnnotationMode.INK, iv_readerActivity_ink)
        }
        map.forEach {
            if (it.key == annotationMode) {
                val color = ContextCompat.getColor(this, R.color.reader_right_toolbar_selected_bg)
                it.value.setBackgroundColor(color)
            } else {
                it.value.setBackgroundDrawable(null)
            }
        }
        when (annotationMode == ReaderViewModel.AnnotationMode.NONE) {
            true -> showAllToolbars()
            false -> hideTopLeftBottomToolbars()
        }
        readerModel.onPdfChangedListener?.onPageUpdated(arrayListOf(currentPageIndex))

        if (viewModel.annotationModeLiveData.value != ReaderViewModel.AnnotationMode.INK) {
            AnimationUtil.hideViewAlpha(view_ink_menu)
        }
    }

    private fun setupInkMenu() {
        val btnInkUndo = findViewById<ImageButton>(R.id.btn_ink_undo)
        val btnInkRedo = findViewById<ImageButton>(R.id.btn_ink_redo)
        val btnInkClean = findViewById<ImageButton>(R.id.btn_ink_clean)
        val btnInkDone = findViewById<ImageButton>(R.id.btn_ink_done)

        btnInkUndo.setOnClickListener {
            viewModel.undoInk()
        }

        btnInkRedo.setOnClickListener {
            viewModel.redoInk()
        }

        btnInkClean.setOnClickListener {
            viewModel.cleanInk()
        }

        btnInkDone.setOnClickListener {
            viewModel.finishInk()
        }
    }

    private fun onAnnotationEditModeUpdate(mode: ReaderViewModel.AnnotationEitMode?) {
        when (mode) {
            ReaderViewModel.AnnotationEitMode.NULL -> {
                showAllToolbars()
                isHideToolbar = false
                snackbarMediaBox?.dismiss()
                snackbarMediaBox = null
            }
            ReaderViewModel.AnnotationEitMode.FORMTEXT_MODIFY, ReaderViewModel.AnnotationEitMode.SIGN_MODIFY -> {
                hideAllToolbars()
                isHideToolbar = true
            }
            ReaderViewModel.AnnotationEitMode.FREETEXT_MODIFY, ReaderViewModel.AnnotationEitMode.STAMP_MODIFY, ReaderViewModel.AnnotationEitMode.SHAPE_MODIFY -> {
                hideAllToolbars()
                isHideToolbar = true
                snackbarMediaBox?.dismiss()
                snackbarMediaBox = null
            }
            else -> {}
        }
        isHidePdfPage = true
        readerModel.onPdfChangedListener?.onPageUpdated(arrayListOf(currentPageIndex))
    }

    private fun onIsOpenedFileUpdate(isOpened: Boolean?) {
        if (isOpened == null) return
        val container = viewGroup_readerActivity_container
        container.removeAllViews()
        if (!isOpened) return
        val context = this
        //  採用客製化的KMPDFReaderView以覆寫畫面點擊判斷和當前頁面計算方法
        val readerView = object : AdditionalPageReaderView(context, additionalPageManager.pageConverter) {
            @SuppressLint("ClickableViewAccessibility")
            override fun onTouchEvent(motionEvent: MotionEvent): Boolean {
                if (motionEvent.action == MotionEvent.ACTION_UP) {
                    if (viewModel.isCopyModeLiveData.value == true) {
                        if (viewModel.copySelection()) {
                            Toast.makeText(context, R.string.reader_copy_text_success, Toast.LENGTH_SHORT).show()
                        }
                    }
                }
                return super.onTouchEvent(motionEvent)
            }

            override fun onMoveToChild(pageIndex: Int) {
                viewModel.setPageIndex(pageIndex)
                //  畫面更新時應通知additionalPageManager
                additionalPageManager.onPageChanged(pageIndex)
            }

            override fun onScrolling() {
                val isEditMode = viewModel.annotationModeLiveData.value != ReaderViewModel.AnnotationMode.NONE
                val isCopyMode = viewModel.isCopyModeLiveData.value != false

                if (!isEditMode && !isCopyMode && !isHideToolbar) {
                    hideAllToolbars()
                    isHideToolbar = true
                }
                isHidePdfPage = isEditMode || isCopyMode
            }

            override fun onTapMainDocArea() {
                if (viewModel.annotationEitModeLiveData.value == ReaderViewModel.AnnotationEitMode.FORMTEXT_MODIFY) {
                    return
                }
                when (isHideToolbar) {
                    true -> {
                        showAllToolbars()
                        viewModel.clearSelection()
                    }
                    false -> hideAllToolbars()
                }
                isHideToolbar = !isHideToolbar
            }
        }
        viewModel.setReaderView(readerView)

        /**
         * 使用客製化KMPDFPageAdapter取代內建的Adapter
         * 注意，需要在KMPDFFactory::setReaderView之後調用才不會被複寫
         */
        viewModel.getReaderView()?.apply {
            adapter = providePdfPageAdapter(
                    context,
                    FilePicker.FilePickerSupport {},
                    viewModel.readerModel.kmpdfFactory!!
            )
            refresh(true)
        }

        if (!filePath.isNullOrEmpty()) {
            val defaultValue = viewModel.pageIndexLiveData.value ?: 0
            val pageIndex = loadCurrentPageIndex(filePath as String, defaultValue)
            viewModel.pdfInfoHandler.goToCurrentPage(pageIndex)
            viewModel.fileNameLiveData.postValue(File(filePath as String).name)
        }
        initTextBoxContextMenuActions()
        container.addView(readerView)
        val model = SharePrefsModel(this)
        onReadModeChanged(model.readMode.value ?: 0)
        if (model.isCropModeEnable.value == true) {
            readerView.post {
                onCropModeEnableChanged(true)
            }
        }
        onOpenedFile()
    }

    fun removeAdditionalPages() {
        if (additionalPageManager.displayStrategyType == AdditionalPageDisplayStrategyType.HIDE) return
        val handler = viewModel.pdfInfoHandler
        val pageIndex = additionalPageManager.pageConverter.convertToRawPageIndex(currentPageIndex, true)
                .coerceAtMost(pageCount - 1)
        additionalPageManager.displayStrategyType = AdditionalPageDisplayStrategyType.HIDE
        viewModel.getReaderView()?.refresh(true)
        handler.goToCurrentPage(pageIndex)
    }

    private fun initTextBoxContextMenuActions() {
        viewModel.setTextBoxContextMenuActions(object : TextBoxContextMenuActionListener {
            override fun onDelete(): Boolean {
                viewModel.deleteSelectedTextBox()
                return true
            }

            override fun onEditStyle(): Boolean {
                mediaBoxView.showTextBoxStyleView()
                viewModel.editSelectedTextBoxStyle()
                return true
            }

            override fun onEditText(): Boolean {
                hideAllToolbars()
                isHideToolbar = true
                viewModel.editSelectedTextBoxText()
                return true
            }

            override fun onCopy(): Boolean {
                viewModel.copySelectedTextBox()
                return true
            }
        })
    }

    override fun onStop() {
        //  Cancel form editing state to prevent soft keyboard bouncing
        if (viewModel.annotationEitModeLiveData.value == ReaderViewModel.AnnotationEitMode.FORMTEXT_MODIFY) {
            //  ugly method to call package function readerView?.displayedView?.releaseFormText()
            val event = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, -1000f, -1000f, 0)
            viewModel.getReaderView()?.onSingleTapUp(event)
        }
        if (viewModel.annotationModeLiveData.value == ReaderViewModel.AnnotationMode.INK) {
            viewModel.stopAnnotationMode()
            viewModel.annotationModeLiveData.value = ReaderViewModel.AnnotationMode.NONE
        }
        viewModel.saveModifyingAnnotation()
        viewModel.temporarySave()
        if (!filePath.isNullOrEmpty()) {
            saveCurrentPageIndex(filePath as String, currentPageIndex)
        }
        super.onStop()
    }

    override fun onResume() {
        super.onResume()
        viewModel.restoreAnnotationEditMode()
    }

    private fun onPageIndexChanged(pageIndex: Int?) {
        pageIndex?.also {
            viewModel.setBookmarkDisplay(pageIndex)
            readerModel.onPdfChangedListener?.onPageSelected(pageIndex)
            tv_readerActivity_pdfPage.post {
                tv_readerActivity_pdfPage.text="${(pageIndex) + 1}/${viewModel.pdfInfoHandler.getPdfPageCount()}"
            }
        }
    }

    private fun onIsPageInBookmarksChanged(isPageInBookmarks: Boolean?) {
        isPageInBookmarks?.let {
            if (it) {
                menuItemBookmark?.icon = ContextCompat.getDrawable(this, R.drawable.ic_bookmark_fill)
            } else {
                menuItemBookmark?.icon = ContextCompat.getDrawable(this, R.drawable.ic_bookmark_border)
            }
        }
    }

    private fun isBelowKitkat(): Boolean {
        return true
//        return Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT
    }

    private fun showAllToolbars() {
        if (isBelowKitkat()) {
            val duration = ((1 - toolbar_readerActivity.alpha) * UI_ANIMATION_DURATION).toLong()
            AnimationUtil.showViewFromTopToBottom(toolbar_readerActivity, duration)
            AnimationUtil.showViewFromBottomToTop(viewGroup_readerActivity_bottomToolbar, duration)
            AnimationUtil.showViewFromLeftToRight(viewGroup_readerActivity_leftToolbar, duration)
            AnimationUtil.showViewFromRightToLeft(viewGroup_readerActivity_rightToolbar, duration)
        } else {
            constrainLayout_readerActivity_root.applyConstraintSet(originConstraintSet, UI_ANIMATION_DURATION)
        }
        isHidePdfPage = true
    }

    private fun hideAllToolbars() {
        if (isBelowKitkat()) {
            val duration = (toolbar_readerActivity.alpha * UI_ANIMATION_DURATION).toLong()
            AnimationUtil.hideViewFromBottomToTop(toolbar_readerActivity, duration)
            AnimationUtil.hideViewFromTopToBottom(viewGroup_readerActivity_bottomToolbar, duration)
            AnimationUtil.hideViewFromRightToLeft(viewGroup_readerActivity_leftToolbar, duration)
            AnimationUtil.hideViewFromLeftToRight(viewGroup_readerActivity_rightToolbar, duration)
            hideSearchViewSoftKeyboard()
        } else {
            constrainLayout_readerActivity_root.applyConstraintSet(this, R.layout.activity_reader_hide_all, UI_ANIMATION_DURATION)
        }
    }

    private fun hideTopLeftBottomToolbars() {
        if (isBelowKitkat()) {
            val duration = (toolbar_readerActivity.alpha * UI_ANIMATION_DURATION).toLong()
            AnimationUtil.hideViewFromBottomToTop(toolbar_readerActivity, duration)
            AnimationUtil.hideViewFromTopToBottom(viewGroup_readerActivity_bottomToolbar, duration)
            AnimationUtil.hideViewFromRightToLeft(viewGroup_readerActivity_leftToolbar, duration)
            hideSearchViewSoftKeyboard()
        } else {
            constrainLayout_readerActivity_root.applyConstraintSet(this, R.layout.activity_reader_hide_top_left_bottom, UI_ANIMATION_DURATION)
        }
    }

    private fun setupPdfChangedListener() {
        readerModel.onPdfChangedListener = object : OnPdfChangedListener {
            override fun onPageCreated(pages: List<Int>) {
                TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
            }

            override fun onPageDeleted(pages: List<Int>) {
                val view = linearLayout_readerActivity_leftToolbarContainer.getChildAt(0)
                if (view is LeftToolbarView) {
                    view.updateContent()
                    view.onScrollToContent(currentPageIndex, true)
                }
            }

            override fun onPageSelected(pageIndex: Int) {
                val view = linearLayout_readerActivity_leftToolbarContainer.getChildAt(0)
                if (view is LeftToolbarView) {
                    view.onScrollToContent(currentPageIndex, true)
                }
            }

            override fun onPageUpdated(pages: List<Int>) {
                val view = linearLayout_readerActivity_leftToolbarContainer.getChildAt(0)
                if (view is LeftToolbarView) {
                    view.updateContent()
                    view.onScrollToContent(currentPageIndex, true)
                }
            }
        }
    }

    private fun updateBookmarkView() {
        val view = linearLayout_readerActivity_leftToolbarContainer.getChildAt(0)
        if (view is BookmarkView) {
            view.updateContent()
            view.onScrollToContent(currentPageIndex, true)
        }
    }

    private fun setupToolbar() {
        toolbar_readerActivity.setNavigationOnClickListener {
            if (!onClickCloseButton()) {
                finish()
            }
        }
        toolbar_readerActivity.setOnMenuItemClickListener {
            when (it.itemId) {
                R.id.item_reader_bookmark -> onClickBookmark()
                R.id.item_reader_more_text_reflow -> onClickTextReflow()
                R.id.item_reader_more_file_info -> onClickFileInfo()
                R.id.item_ibon_print -> onClickIBonPrint()
                R.id.item_reader_more_print -> onClickPrint()
                R.id.item_reader_more_user_guide -> onClickUserGuide()
                R.id.item_reader_more_clear_signature -> onClickClearSignature()
            }
            return@setOnMenuItemClickListener true
        }
    }

    private fun onClickBookmark() {
        onEvent(HookEvent.OnClickTopBookmarkBtn())
        viewModel.isPageInBookmarksLiveData.value?.let {
            if (!it) {
                showAddBookmarkDialog()
            } else {
                showDeleteBookmarkDialog()
            }
        }
    }

    private fun onClickClearSignature() {
        AlertDialog.Builder(this)
                .setMessage(R.string.reader_clear_signature_dialog_msg)
                .setPositiveButton(android.R.string.yes) { _, _ -> viewModel.clearSignature() }
                .setNegativeButton(android.R.string.no) { _, _ -> /* do nothing */ }
                .show()
    }

    private fun showAddBookmarkDialog() {
        val alertDialogBuilder = AlertDialog.Builder(this)
        val editText = EditText(this)
        val layoutParams =
                LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT)

        editText.layoutParams = layoutParams
        val defaultTitle = getString(R.string.dialogAddBookmark_page) + " " + (viewModel.pdfInfoHandler.getCurrentPage() + 1)
        editText.setText(defaultTitle, TextView.BufferType.EDITABLE)
        editText.setSelection(0, defaultTitle.length)

        alertDialogBuilder.setTitle(getString(R.string.reader_alert_dialog_title_add_bookmark))
        alertDialogBuilder.setView(editText)
        alertDialogBuilder.setPositiveButton(getString(R.string.reader_alert_dialog_button_confirm)) { dialog, which ->
            viewModel.addBookmark(editText.text.toString())
            updateBookmarkView()
        }
        alertDialogBuilder.setNegativeButton(getString(R.string.reader_alert_dialog_button_cancel)) { dialog, which ->
        }
        alertDialogBuilder.create().show()
        editText.requestFocus()
    }

    private fun getBookmarkTitle(page: Int): String {
        val bookmarks = viewModel.bookmarkHandler.getBookmarks()
        for (bookmark in bookmarks) {
            if (bookmark.pageNum == page) {
                return bookmark.title
            }
        }
        return ""
    }

    private fun showDeleteBookmarkDialog() {
        val alertDialogBuilder = AlertDialog.Builder(this)
        alertDialogBuilder.setTitle(getString(R.string.reader_alert_dialog_title_delete_bookmark))
        val bookmarkTitle = getBookmarkTitle(viewModel.pdfInfoHandler.getCurrentPage())
        val message = String.format(getString(R.string.reader_alert_dialog_message_delete_bookmark), bookmarkTitle)
        alertDialogBuilder.setMessage(message)
        alertDialogBuilder.setPositiveButton(getString(R.string.reader_alert_dialog_button_confirm)) { dialog, which ->
            viewModel.deleteBookmark()
            updateBookmarkView()
        }
        alertDialogBuilder.setNegativeButton(getString(R.string.reader_alert_dialog_button_cancel)) { dialog, which ->
        }
        alertDialogBuilder.create().show()
    }

    private fun hideSearchViewSoftKeyboard() {
        val view = linearLayout_readerActivity_leftToolbarContainer.getChildAt(0)
        if (view is SearchView) {
            view.hideSoftKeyboard()
        }
    }

    private fun setupLeftToolbar() {
        viewGroup_readerActivity_leftToolbar.setScroll(false)
        setLeftToolbarWidth(w_240)
        viewGroup_readerActivity_leftToolbar.smoothScrollTo(w_240, 0, 0)
        val child = layoutInflater.inflate(R.layout.view_thumbnail, null)
        linearLayout_readerActivity_leftToolbarContainer.addView(child)

        fun onClickLeftToolbarItem(leftToolbarType: ReaderViewModel.LeftToolbarType) {
            viewModel.setLeftToolbarType(leftToolbarType)
            updateLeftToolbarOpenState(leftToolbarType)
        }

        iv_readerActivity_thumbnail.setOnClickListener { onClickLeftToolbarItem(ReaderViewModel.LeftToolbarType.THUMBNAIL) }
        iv_readerActivity_bookmark.setOnClickListener { onClickLeftToolbarItem(ReaderViewModel.LeftToolbarType.BOOKMARK) }
        iv_readerActivity_outline.setOnClickListener { onClickLeftToolbarItem(ReaderViewModel.LeftToolbarType.OUTLINE) }
        iv_readerActivity_search.setOnClickListener { onClickLeftToolbarItem(ReaderViewModel.LeftToolbarType.SEARCH) }

        if (!isPdf()) {
            iv_readerActivity_bookmark.visibility = View.GONE
            if (!isPasswordProtected) iv_readerActivity_outline.visibility = View.GONE
        }
    }

    override fun onReadModeChanged(readMode: Int) {
        viewModel.readMode = when (readMode) {
            ReadingModeSelectView.modeDay -> ReaderViewModel.ReadMode.READ_MODE_DAY
            ReadingModeSelectView.modeNight -> ReaderViewModel.ReadMode.READ_MODE_NIGHT
            ReadingModeSelectView.modeSoft -> ReaderViewModel.ReadMode.READ_MODE_SOFT
            ReadingModeSelectView.modeChromeWhite -> ReaderViewModel.ReadMode.MODE_CHROME_WHITE
            ReadingModeSelectView.modeEtonBlue -> ReaderViewModel.ReadMode.MODE_ETON_BLUE
            ReadingModeSelectView.modeWhiteLilac -> ReaderViewModel.ReadMode.MODE_WHITE_LILAC
            else -> ReaderViewModel.ReadMode.READ_MODE_DAY
        }
    }

    override fun onCropModeEnableChanged(enable: Boolean) {
        viewModel.isCrop = enable
        val buttons = arrayOf(iv_readerActivity_highLight, iv_readerActivity_strike, iv_readerActivity_underline, iv_readerActivity_ink, ib_readerActivity_bottomToolbarMediaBox)

        if (enable) {
            viewModel.stopAnnotationMode()
            val color = ContextCompat.getColor(baseContext, R.color.reader_right_toolbar_disabled_bg)
            for (button in buttons) {
                button.isEnabled = false
                button.setBackgroundColor(color)
            }
        } else {
            for (button in buttons) {
                button.isEnabled = true
                button.setBackgroundDrawable(null)
            }
        }
    }

    override fun onShowStateBarEnableChanged(enable: Boolean, dialog: Dialog?) {
        when (enable) {
            true -> {
                dialog?.window?.clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN)
                window.clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN)
            }
            false -> {
                dialog?.window?.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
                window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
            }
        }
    }

    override fun onTurnPageDirectionChanged(direction: Int) {
        viewModel.viewDirection = when (direction == 0) {
            true -> ReaderViewModel.ViewDirection.VERTICAL_SINGLE_PAGE_CONTINUES
            false -> ReaderViewModel.ViewDirection.HORIZONTAL_SINGLE_PAGE
        }
    }

    override fun onShowTurnPageBtnEnableChanged(enable: Boolean) {
        when (enable) {
            true -> {
                ib_readerActivity_bottomToolbarPrevious.visibility = View.VISIBLE
                ib_readerActivity_bottomToolbarNext.visibility = View.VISIBLE
            }
            false -> {
                ib_readerActivity_bottomToolbarPrevious.visibility = View.GONE
                ib_readerActivity_bottomToolbarNext.visibility = View.GONE
            }
        }
    }

    override fun onLockScreenSleepEnableChanged(enable: Boolean) {
        when (enable) {
            true -> window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
            false -> window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
        }
    }

    override fun onShowCommentToolEnableChanged(enable: Boolean) {
    }

    override fun onShowBOTAToolEnableChanged(enable: Boolean) {
    }

    private fun setupRightSideToolbar() {
        iv_readerActivity_setting.setOnClickListener {
            val settingDialog = provideReaderSettingDialogFragment()
            settingDialog.show(supportFragmentManager, FRAGMENT_READER_SETTING_TAG)
        }
    }

    private fun applySetting() {
        val model = SharePrefsModel(this)
        onShowStateBarEnableChanged(model.isShowStateBarEnable.value ?: false, null)
        onTurnPageDirectionChanged(model.turnPageDirection.value ?: 0)
        onShowTurnPageBtnEnableChanged(model.isShowTurnPageBtnEnable.value ?: false)
        onLockScreenSleepEnableChanged(model.isLockScreenSleepEnable.value ?: false)
        onShowCommentToolEnableChanged(model.isShowCommentToolEnable.value ?: false)
        onShowBOTAToolEnableChanged(model.isShowBOTAToolEnable.value ?: false)
    }

    override fun isShowStateBar(): Boolean {
        return SharePrefsModel(this).isShowStateBarEnable.value ?: false
    }

    private fun setupBottomToolbar() {
        ib_readerActivity_bottomToolbarMediaBox.setOnClickListener {
            onEvent(HookEvent.OnClickBottomMediaBoxBtn())
            mediaBoxView.show()
        }
        ib_readerActivity_bottomToolbarViewAll.setOnClickListener {
            onEvent(HookEvent.OnClickBottomThumbnailBtn())
            onClickBottomThumb1()
        }
        ib_readerActivity_bottomToolbarPrevious.setOnClickListener {
            onEvent(HookEvent.OnClickBottomPreviousBtn())
            val handler = viewModel.pdfInfoHandler
            val pageIndex = handler.getCurrentPage()
            val previousPageIndex = Math.max(pageIndex - 1, 0)
            handler.goToCurrentPage(previousPageIndex)
        }
        ib_readerActivity_bottomToolbarNext.setOnClickListener {
            onEvent(HookEvent.OnClickBottomNextBtn())
            val handler = viewModel.pdfInfoHandler
            val pageIndex = handler.getCurrentPage()
            val nextPageIndex = Math.min(pageIndex + 1, handler.getPdfPageCount() - 1)
            handler.goToCurrentPage(nextPageIndex)
        }
        ib_readerActivity_bottomToolbarKdanCloud.visibility = if (isBottomBarKdanCloudBtnVisible()) {
            View.VISIBLE
        } else {
            View.GONE
        }
        ib_readerActivity_bottomToolbarKdanCloud.setOnClickListener {
            onClickKdanCloud()
        }
        ib_readerActivity_bottomToolbarShare.setOnClickListener {
            onClickShare()
        }

        if (!isPdf()) {
            ib_readerActivity_bottomToolbarMediaBox.visibility = View.GONE
        }
    }

    private fun setupMediaBoxView() {

        fun showSnackbar(title: String, btnText: String) {
            snackbarMediaBox = Snackbar.make(mediaBoxView, title, Snackbar.LENGTH_INDEFINITE)
                    .setAction(btnText) {
                        viewModel.clearSelection()
                        mediaBoxView.post {
                            mediaBoxView.show()
                            snackbarMediaBox?.dismiss()
                            snackbarMediaBox = null
                        }
                    }
            snackbarMediaBox?.setActionTextColor(ContextCompat.getColor(this, R.color.bright_blue))
            snackbarMediaBox?.show()
        }

        mediaBoxView.apply {
            onShowListener = Runnable {
                onMediaBoxShown()
                snackbarMediaBox?.dismiss()
                snackbarMediaBox = null
            }
            onDismissListener = Runnable {
                onMediaBoxDismissed()
                snackbarMediaBox?.dismiss()
                snackbarMediaBox = null
            }
            onClickAddButtonListener = object : MediaBoxView.OnClickHeaderButtonListener {
                override fun onClickTextBoxAddButton(textBoxTabView: TextBoxTabView) {
                    dismiss(false)
                    viewModel.setTextBoxAttribute(textBoxTabView.getTextBoxAttribute())
                    showSnackbar(resources.getString(R.string.reader_mediaBox_snakebar_textBox), resources.getString(R.string.reader_mediaBox_snakebar_undo))
                }

                override fun onClickTextBoxStyleApplyButton(textBoxTabView: TextBoxTabView) {
                    dismiss(false)
                    viewModel.setTextBoxAttribute(textBoxTabView.getTextBoxAttribute(), true)
                }

                override fun onClickSignatureAddButton(signatureTabView: SignatureTabView) {
                    dismiss(false)
                    viewModel.setSignatureAttribute(signatureTabView.getSignatureAttribute())
                    showSnackbar(resources.getString(R.string.reader_mediaBox_snakebar_signature), resources.getString(R.string.reader_mediaBox_snakebar_undo))
                }

                override fun onClickStampAddButton(stampTabView: StampTabView) {
                    dismiss(false)
                    viewModel.setStampAttribute(stampTabView.getStampAttribute())
                    showSnackbar(resources.getString(R.string.reader_mediaBox_snakebar_stamp), resources.getString(R.string.reader_mediaBox_snakebar_undo))
                }

                override fun onClickShapeAddButton(shapeTabView: ShapeTabView) {
                    dismiss(false)
                    viewModel.setShapeAttribute(shapeTabView.getShapeAttribute())
                    showSnackbar(resources.getString(R.string.reader_mediaBox_snakebar_shape), resources.getString(R.string.reader_mediaBox_snakebar_undo))
                }
            }
        }
    }

    private fun setupRightToolbar() {
        viewGroup_readerActivity_rightToolbar.setScroll(false)
        iv_readerActivity_highLight.apply {
            setOnClickListener {
                onEvent(HookEvent.OnClickHighlightBtn())
                viewModel.onClickHighlightBtn()
            }
            setOnLongClickListener { btn ->
                onEvent(HookEvent.OnLongClickHighlightBtn())
                viewModel.onLongClickHighlightBtn()
                val context = this@ReaderActivity
                AnnotationAttributeWindow(context, true).also { window ->
                    viewModel.highLightAttributeLiveData.value?.let { attr ->
                        window.annotationAttributeView.annotationAttribute = attr
                    }
                    window.annotationAttributeView.onChangeListener = object : AnnotationAttributeView.OnChangeListener {
                        override fun onChange(annotationAttributeView: AnnotationAttributeView) {
                            onEvent(HookEvent.OnUserChangeHighlightPropertySuccess())
                            viewModel.setHighLightAttributes(annotationAttributeView.annotationAttribute)
                        }
                    }
                    val contentView = window.contentView.apply {
                        val w = Utils.makeDropDownMeasureSpec(window.width)
                        val y = Utils.makeDropDownMeasureSpec(window.height)
                        measure(w, y)
                    }
                    val space = resources.getDimension(R.dimen.reader_annotation_property_setting_window_right_toolbar_space)
                    val xOff = (-contentView.measuredWidth - space).toInt()
                    val yOff = -btn.height
                    window.showAsDropDown(btn, xOff, yOff)
                }
                return@setOnLongClickListener true
            }
        }
        iv_readerActivity_strike.apply {
            setOnClickListener {
                onEvent(HookEvent.OnClickStrikeoutBtn())
                viewModel.onClickStrikeBtn()
            }
            setOnLongClickListener { btn ->
                onEvent(HookEvent.OnLongClickStrikeoutBtn())
                viewModel.onLongClickStrikeBtn()
                val context = this@ReaderActivity
                AnnotationAttributeWindow(context, true).also { window ->
                    viewModel.strikeAttributeLiveData.value?.let { attr ->
                        window.annotationAttributeView.annotationAttribute = attr
                    }
                    window.annotationAttributeView.onChangeListener = object : AnnotationAttributeView.OnChangeListener {
                        override fun onChange(annotationAttributeView: AnnotationAttributeView) {
                            onEvent(HookEvent.OnUserChangeStrikeoutPropertySuccess())
                            viewModel.setStrikeOutAttributes(annotationAttributeView.annotationAttribute)
                        }
                    }
                    val contentView = window.contentView.apply {
                        val w = Utils.makeDropDownMeasureSpec(window.width)
                        val y = Utils.makeDropDownMeasureSpec(window.height)
                        measure(w, y)
                    }
                    val space = resources.getDimension(R.dimen.reader_annotation_property_setting_window_right_toolbar_space)
                    val xOff = (-contentView.measuredWidth - space).toInt()
                    val yOff = -btn.height
                    window.showAsDropDown(btn, xOff, yOff)
                }
                return@setOnLongClickListener true
            }
        }
        iv_readerActivity_underline.apply {
            setOnClickListener {
                onEvent(HookEvent.OnClickUnderlineBtn())
                viewModel.onClickUnderlineBtn()
            }
            setOnLongClickListener { btn ->
                onEvent(HookEvent.OnLongClickUnderlineBtn())
                viewModel.onLongClickUnderlineBtn()
                val context = this@ReaderActivity
                AnnotationAttributeWindow(context, true).also { window ->
                    viewModel.underLineAttributeLiveData.value?.let { attr ->
                        window.annotationAttributeView.annotationAttribute = attr
                    }
                    window.annotationAttributeView.onChangeListener = object : AnnotationAttributeView.OnChangeListener {
                        override fun onChange(annotationAttributeView: AnnotationAttributeView) {
                            onEvent(HookEvent.OnUserChangeUnderlinePropertySuccess())
                            viewModel.setUnderLineAttributes(annotationAttributeView.annotationAttribute)
                        }
                    }
                    val contentView = window.contentView.apply {
                        val w = Utils.makeDropDownMeasureSpec(window.width)
                        val y = Utils.makeDropDownMeasureSpec(window.height)
                        measure(w, y)
                    }
                    val space = resources.getDimension(R.dimen.reader_annotation_property_setting_window_right_toolbar_space)
                    val xOff = (-contentView.measuredWidth - space).toInt()
                    val yOff = -btn.height
                    window.showAsDropDown(btn, xOff, yOff)
                }
                return@setOnLongClickListener true
            }
        }
        iv_readerActivity_ink.apply {
            setOnClickListener {
                onEvent(HookEvent.OnClickInkBtn())
                if (viewModel.annotationModeLiveData.value == ReaderViewModel.AnnotationMode.INK) {
                    AnimationUtil.hideViewAlpha(view_ink_menu)
                } else {
                    AnimationUtil.showViewAlpha(view_ink_menu)
                }
                viewModel.onClickInkBtn()
            }
            setOnLongClickListener { btn ->
                onEvent(HookEvent.OnLongClickInkBtn())
                viewModel.onLongClickInkBtn()
                val context = this@ReaderActivity
                AnnotationAttributeWindow(context, false).also { window ->
                    viewModel.inkAttributeLiveData.value?.let { attr ->
                        window.annotationAttributeView.inkAttribute = attr
                    }
                    window.annotationAttributeView.onChangeListener = object : AnnotationAttributeView.OnChangeListener {
                        override fun onChange(annotationAttributeView: AnnotationAttributeView) {
                            onEvent(HookEvent.OnUserChangeInkPropertySuccess())
                            viewModel.setInkAttributes(annotationAttributeView.inkAttribute)
                        }
                    }
                    val contentView = window.contentView.apply {
                        val w = Utils.makeDropDownMeasureSpec(window.width)
                        val y = Utils.makeDropDownMeasureSpec(window.height)
                        measure(w, y)
                    }
                    val space = resources.getDimension(R.dimen.reader_annotation_property_setting_window_right_toolbar_space)
                    val xOff = (-contentView.measuredWidth - space).toInt()
                    val yOff = -contentView.measuredHeight
                    window.showAsDropDown(btn, xOff, yOff)

                    AnimationUtil.hideViewAlpha(view_ink_menu)
                    window.setOnDismissListener {
                        AnimationUtil.showViewAlpha(view_ink_menu)
                    }
                }
                return@setOnLongClickListener true
            }
        }

        if (!isPdf()) {
            iv_readerActivity_highLight.visibility = View.GONE
            iv_readerActivity_strike.visibility = View.GONE
            iv_readerActivity_underline.visibility = View.GONE
            iv_readerActivity_ink.visibility = View.GONE
            view_readerActivity_highLightStroke.visibility = View.GONE
            view_readerActivity_strikeStroke.visibility = View.GONE
            view_readerActivity_underlineStroke.visibility = View.GONE
        }
    }

    private fun setLeftToolbarWidth(width: Int) {
        var params = viewGroup_readerActivity_leftToolbar.layoutParams as ConstraintLayout.LayoutParams
        params.width = width + w_left
        params.height = 0
        viewGroup_readerActivity_leftToolbar.layoutParams = params

        params = linearLayout_readerActivity_leftToolbarContainer.layoutParams as ConstraintLayout.LayoutParams
        params.width = width
        linearLayout_readerActivity_leftToolbarContainer.layoutParams = params
    }

    private fun updateLeftToolbarOpenState(type: ReaderViewModel.LeftToolbarType) {
        val isLeftToolbarOpen = viewModel.isLeftToolbarOpenLiveData.value ?: false
        viewModel.setIsLeftToolbarOpen(!isLeftToolbarOpen || oldLeftToolbarType != type)
        cloneOriginConstraintSet()
    }

    private fun onMediaBoxShown() {
        hideAllToolbars()
        isHideToolbar = true
    }

    private fun onMediaBoxDismissed() {
        showAllToolbars()
        isHideToolbar = false
        viewModel.clearSelection()
    }

    private fun setLeftToolbarContentView(leftToolbarType: ReaderViewModel.LeftToolbarType) {
        if (oldLeftToolbarType != leftToolbarType) {
            linearLayout_readerActivity_leftToolbarContainer.removeAllViews()
            val view = when (leftToolbarType) {
                ReaderViewModel.LeftToolbarType.NONE,
                ReaderViewModel.LeftToolbarType.THUMBNAIL -> {
                    val thumbnailView = ThumbnailView(this)
                    thumbnailView.setHandlers(viewModel.pdfInfoHandler, viewModel.thumbnailHandler)
                    thumbnailView
                }
                ReaderViewModel.LeftToolbarType.BOOKMARK -> {
                    val bookmarkView = BookmarkView(this)
                    bookmarkView.setHandlers(viewModel.pdfInfoHandler, viewModel.thumbnailHandler, viewModel.bookmarkHandler)
                    bookmarkView
                }
                ReaderViewModel.LeftToolbarType.OUTLINE -> {
                    val outlineView = OutlineView(this)
                    outlineView.setHandlers(viewModel.pdfInfoHandler, viewModel.outlineHandler)
                    outlineView
                }
                ReaderViewModel.LeftToolbarType.SEARCH -> {
                    val searchView = SearchView(this)
                    searchView.setHandlers(viewModel.pdfInfoHandler, viewModel.searchHandler)
                    searchView
                }
            }
            linearLayout_readerActivity_leftToolbarContainer.addView(view as View)
            oldLeftToolbarType = leftToolbarType
        }
    }

    private fun getLeftToolbarContentWidth(): Int {
        return when (viewModel.leftToolbarTypeLiveData.value == ReaderViewModel.LeftToolbarType.THUMBNAIL) {
            true -> w_240
            false -> w_318
        }
    }

    private fun onLeftToolbarTypeChanged(leftToolbarType: ReaderViewModel.LeftToolbarType?) {
        updateLeftToolbarIcons()
        setLeftToolbarWidth(getLeftToolbarContentWidth())
        cloneOriginConstraintSet()

        if (leftToolbarType != null) {
            setLeftToolbarContentView(leftToolbarType)
        }
    }

    private fun onLeftToolbarOpenStateChanged(open: Boolean?) {
        updateLeftToolbarIcons()

        when (open == true) {
            true -> viewGroup_readerActivity_leftToolbar.smoothScrollTo(0, 0, UI_ANIMATION_DURATION.toInt())
            false -> {
                viewGroup_readerActivity_leftToolbar.smoothScrollTo(getLeftToolbarContentWidth(), 0, UI_ANIMATION_DURATION.toInt())
                hideSearchViewSoftKeyboard()
            }
        }
    }

    private fun updateLeftToolbarIcons() {
        iv_readerActivity_thumbnail.setImageResource(R.drawable.ic_left_toolbar_thumbnails)
        iv_readerActivity_bookmark.setImageResource(R.drawable.ic_left_toolbar_bookmarks)
        iv_readerActivity_outline.setImageResource(R.drawable.ic_left_toolbar_outline)
        iv_readerActivity_search.setImageResource(R.drawable.ic_left_toolbar_search)
        if (viewModel.isLeftToolbarOpenLiveData.value == true) {
            when (viewModel.leftToolbarTypeLiveData.value) {
                ReaderViewModel.LeftToolbarType.NONE -> {}
                ReaderViewModel.LeftToolbarType.THUMBNAIL -> iv_readerActivity_thumbnail.setImageResource(R.drawable.ic_left_toolbar_thumbnails_selected)
                ReaderViewModel.LeftToolbarType.BOOKMARK -> iv_readerActivity_bookmark.setImageResource(R.drawable.ic_left_toolbar_bookmarks_selected)
                ReaderViewModel.LeftToolbarType.OUTLINE -> iv_readerActivity_outline.setImageResource(R.drawable.ic_left_toolbar_outline_selected)
                ReaderViewModel.LeftToolbarType.SEARCH -> iv_readerActivity_search.setImageResource(R.drawable.ic_left_toolbar_search_selected)
            }
        }
    }

    private fun onClickBottomThumb1() {
        val thumbDialog = providePdfThumbDialogFragment()
        thumbDialog.show(supportFragmentManager, FRAGMENT_PDF_THUMB_TAG)
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (resultCode == Activity.RESULT_OK){
            when (requestCode) {
                REQUEST_PASSWORD -> {
                    val password = data?.getStringExtra(DialogPasswordActivity.KEY_USER_INPUT_PASSWORD) ?: ""
                    if (password.isEmpty()) {
                        finish()
                    } else {
                        val isOpened = viewModel.isOpenedFileLiveData.value ?: return
                        if (isOpened) return
                        val result = viewModel.openPdfFile(
                                this@ReaderActivity,
                                password,
                                Runnable { requestPassword(true) },
                                intent.type
                        )
                        if (result == ReaderViewModel.OpenFileResult.FAILED) {
                            showFileCannotOpenDialog(getString(R.string.cannot_open_file_Path, filePath))
                        }
                    }
                }
            }
        }
    }

    private fun onEvent(event: ReaderViewModel.Event?) {
        if (event == null) return
        when (event) {
            is ReaderViewModel.Event.OnFinishedHighlight -> HookEvent.OnFinishedHighlight()
            is ReaderViewModel.Event.OnFinishedStrikeout -> HookEvent.OnFinishedStrikeout()
            is ReaderViewModel.Event.OnFinishedUnderLine -> HookEvent.OnFinishedUnderline()
            is ReaderViewModel.Event.OnFinishedInk -> HookEvent.OnFinishedInk()
        }.also {
            onEvent(it)
        }
        viewModel.onEventConsumed(event)
    }

    protected sealed class HookEvent {
        class OnClickTopBookmarkBtn : HookEvent()
        class OnClickBottomPreviousBtn : HookEvent()
        class OnClickBottomNextBtn : HookEvent()
        class OnClickBottomMediaBoxBtn : HookEvent()
        class OnClickBottomThumbnailBtn : HookEvent()
        class OnClickHighlightBtn : HookEvent()
        class OnClickStrikeoutBtn : HookEvent()
        class OnClickUnderlineBtn : HookEvent()
        class OnClickInkBtn : HookEvent()
        class OnLongClickHighlightBtn : HookEvent()
        class OnLongClickStrikeoutBtn : HookEvent()
        class OnLongClickUnderlineBtn : HookEvent()
        class OnLongClickInkBtn : HookEvent()
        class OnFinishedHighlight : HookEvent()
        class OnFinishedStrikeout : HookEvent()
        class OnFinishedUnderline : HookEvent()
        class OnFinishedInk : HookEvent()
        class OnUserChangeHighlightPropertySuccess : HookEvent()
        class OnUserChangeStrikeoutPropertySuccess : HookEvent()
        class OnUserChangeUnderlinePropertySuccess : HookEvent()
        class OnUserChangeInkPropertySuccess : HookEvent()
    }
}