AquaStream/app/src/main/java/com/lagradost/cloudstream3/ui/player/FullScreenPlayer.kt

package com.lagradost.cloudstream3.ui.player

import android.animation.ObjectAnimator
import android.annotation.SuppressLint
import android.content.Context
import android.content.pm.ActivityInfo
import android.content.res.ColorStateList
import android.content.res.Resources
import android.graphics.Color
import android.media.AudioManager
import android.os.Build
import android.os.Bundle
import android.provider.Settings
import android.util.DisplayMetrics
import android.view.KeyEvent
import android.view.MotionEvent
import android.view.View
import android.view.WindowManager
import android.view.WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
import android.view.animation.AlphaAnimation
import android.view.animation.Animation
import android.view.animation.AnimationUtils
import androidx.core.graphics.blue
import androidx.core.graphics.green
import androidx.core.graphics.red
import androidx.core.view.isGone
import androidx.core.view.isVisible
import androidx.preference.PreferenceManager
import com.lagradost.cloudstream3.AcraApplication.Companion.getKey
import com.lagradost.cloudstream3.AcraApplication.Companion.setKey
import com.lagradost.cloudstream3.CommonActivity.keyEventListener
import com.lagradost.cloudstream3.CommonActivity.playerEventListener
import com.lagradost.cloudstream3.R
import com.lagradost.cloudstream3.mvvm.logError
import com.lagradost.cloudstream3.utils.Qualities
import com.lagradost.cloudstream3.utils.SingleSelectionHelper.showDialog
import com.lagradost.cloudstream3.utils.UIHelper.colorFromAttribute
import com.lagradost.cloudstream3.utils.UIHelper.getNavigationBarHeight
import com.lagradost.cloudstream3.utils.UIHelper.getStatusBarHeight
import com.lagradost.cloudstream3.utils.UIHelper.hideSystemUI
import com.lagradost.cloudstream3.utils.UIHelper.popCurrentPage
import com.lagradost.cloudstream3.utils.UIHelper.showSystemUI
import com.lagradost.cloudstream3.utils.UIHelper.toPx
import com.lagradost.cloudstream3.utils.Vector2
import kotlinx.android.synthetic.main.fragment_player.*
import kotlinx.android.synthetic.main.player_custom_layout.*
import kotlin.math.*

const val MINIMUM_SEEK_TIME = 7000L         // when swipe seeking
const val MINIMUM_VERTICAL_SWIPE = 2.0f     // in percentage
const val MINIMUM_HORIZONTAL_SWIPE = 2.0f   // in percentage
const val VERTICAL_MULTIPLIER = 2.0f
const val HORIZONTAL_MULTIPLIER = 2.0f
const val DOUBLE_TAB_MAXIMUM_HOLD_TIME = 200L
const val DOUBLE_TAB_MINIMUM_TIME_BETWEEN = 200L    // this also affects the UI show response time
const val DOUBLE_TAB_PAUSE_PERCENTAGE = 0.15        // in both directions

// All the UI Logic for the player
open class FullScreenPlayer : AbstractPlayerFragment(R.layout.fragment_player) {
    // state of player UI
    protected var isShowing = false
    protected var isLocked = false

    // options for player
    protected var currentPrefQuality =
        Qualities.P2160.value // preferred maximum quality, used for ppl w bad internet or on cell
    protected var fastForwardTime = 10000L
    protected var swipeHorizontalEnabled = false
    protected var swipeVerticalEnabled = false
    protected var playBackSpeedEnabled = false
    protected var playerResizeEnabled = false
    protected var doubleTapEnabled = false
    protected var doubleTapPauseEnabled = true

    //private var useSystemBrightness = false
    protected var useTrueSystemBrightness = true
    private val fullscreenNotch = true //TODO SETTING

    protected val displayMetrics: DisplayMetrics = Resources.getSystem().displayMetrics

    // screenWidth and screenHeight does always
    // refer to the screen while in landscape mode
    private val screenWidth: Int
        get() {
            return max(displayMetrics.widthPixels, displayMetrics.heightPixels)
        }
    private val screenHeight: Int
        get() {
            return min(displayMetrics.widthPixels, displayMetrics.heightPixels)
        }

    private var statusBarHeight: Int? = null
    private var navigationBarHeight: Int? = null

    private val brightnessIcons = listOf(
        R.drawable.sun_1,
        R.drawable.sun_2,
        R.drawable.sun_3,
        R.drawable.sun_4,
        R.drawable.sun_5,
        R.drawable.sun_6,
        //R.drawable.sun_7,
        // R.drawable.ic_baseline_brightness_1_24,
        // R.drawable.ic_baseline_brightness_2_24,
        // R.drawable.ic_baseline_brightness_3_24,
        // R.drawable.ic_baseline_brightness_4_24,
        // R.drawable.ic_baseline_brightness_5_24,
        // R.drawable.ic_baseline_brightness_6_24,
        // R.drawable.ic_baseline_brightness_7_24,
    )

    private val volumeIcons = listOf(
        R.drawable.ic_baseline_volume_mute_24,
        R.drawable.ic_baseline_volume_down_24,
        R.drawable.ic_baseline_volume_up_24,
    )

    open fun showMirrorsDialogue() {
        throw NotImplementedError()
    }

    /** Returns false if the touch is on the status bar or navigation bar*/
    private fun isValidTouch(rawX: Float, rawY: Float): Boolean {
        val statusHeight = statusBarHeight ?: 0
        // val navHeight = navigationBarHeight ?: 0
        // nav height is removed because screenWidth already takes into account that
        return rawY > statusHeight && rawX < screenWidth //- navHeight
    }

    private fun animateLayoutChanges() {
        if (isShowing) {
            updateUIVisibility()
        } else {
            player_holder?.postDelayed({ updateUIVisibility() }, 200)
        }

        val titleMove = if (isShowing) 0f else -50.toPx.toFloat()
        player_video_title?.let {
            ObjectAnimator.ofFloat(it, "translationY", titleMove).apply {
                duration = 200
                start()
            }
        }
        player_video_title_rez?.let {
            ObjectAnimator.ofFloat(it, "translationY", titleMove).apply {
                duration = 200
                start()
            }
        }
        val playerBarMove = if (isShowing) 0f else 50.toPx.toFloat()
        bottom_player_bar?.let {
            ObjectAnimator.ofFloat(it, "translationY", playerBarMove).apply {
                duration = 200
                start()
            }
        }

        val fadeTo = if (isShowing) 1f else 0f
        val fadeAnimation = AlphaAnimation(1f - fadeTo, fadeTo)

        fadeAnimation.duration = 100
        fadeAnimation.fillAfter = true

        val sView = subView
        val sStyle = subStyle
        if (sView != null && sStyle != null) {
            val move = if (isShowing) -((bottom_player_bar?.height?.toFloat()
                ?: 0f) + 40.toPx) else -sStyle.elevation.toPx.toFloat()
            ObjectAnimator.ofFloat(sView, "translationY", move).apply {
                duration = 200
                start()
            }
        }

        if (!isLocked) {
            player_ffwd_holder?.alpha = 1f
            player_rew_holder?.alpha = 1f
            // player_pause_play_holder?.alpha = 1f

            shadow_overlay?.startAnimation(fadeAnimation)
            player_ffwd_holder?.startAnimation(fadeAnimation)
            player_rew_holder?.startAnimation(fadeAnimation)
            player_pause_play?.startAnimation(fadeAnimation)

            /*if (isBuffering) {
                    player_pause_play?.isVisible = false
                    player_pause_play_holder?.isVisible = false
                } else {
                    player_pause_play?.isVisible = true
                    player_pause_play_holder?.startAnimation(fadeAnimation)
                    player_pause_play?.startAnimation(fadeAnimation)
                }*/
            //player_buffering?.startAnimation(fadeAnimation)
        }

        bottom_player_bar?.startAnimation(fadeAnimation)
        player_top_holder?.startAnimation(fadeAnimation)
    }

    override fun onResume() {
        activity?.hideSystemUI()
        activity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && fullscreenNotch) {
            val params = activity?.window?.attributes
            params?.layoutInDisplayCutoutMode = LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
            activity?.window?.attributes = params
        }

        super.onResume()
    }

    override fun onDestroy() {
        activity?.showSystemUI()
        activity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER

        // simply resets brightness and notch settings that might have been overridden
        val lp = activity?.window?.attributes
        lp?.screenBrightness = WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            lp?.layoutInDisplayCutoutMode =
                WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT
        }
        activity?.window?.attributes = lp
        super.onDestroy()
    }

    private fun setPlayBackSpeed(speed: Float) {
        try {
            setKey(PLAYBACK_SPEED_KEY, speed)
            player_speed_btt?.text =
                getString(R.string.player_speed_text_format).format(speed)
                    .replace(".0x", "x")
        } catch (e: Exception) {
            // the format string was wrong
            logError(e)
        }

        player.setPlaybackSpeed(speed)
    }

    private fun skipOp() {
        player.seekTime(85000) // skip 85s
    }

    private fun showSpeedDialog() {
        val speedsText =
            listOf(
                "0.5x",
                "0.75x",
                "0.85x",
                "1x",
                "1.15x",
                "1.25x",
                "1.4x",
                "1.5x",
                "1.75x",
                "2x"
            )
        val speedsNumbers =
            listOf(0.5f, 0.75f, 0.85f, 1f, 1.15f, 1.25f, 1.4f, 1.5f, 1.75f, 2f)
        val speedIndex = speedsNumbers.indexOf(player.getPlaybackSpeed())

        activity?.let { act ->
            act.showDialog(
                speedsText,
                speedIndex,
                act.getString(R.string.player_speed),
                false,
                {
                    activity?.hideSystemUI()
                }) { index ->
                activity?.hideSystemUI()
                setPlayBackSpeed(speedsNumbers[index])
            }
        }
    }

    fun resetRewindText() {
        exo_rew_text?.text =
            getString(R.string.rew_text_regular_format).format(fastForwardTime / 1000)
    }

    fun resetFastForwardText() {
        exo_ffwd_text?.text =
            getString(R.string.ffw_text_regular_format).format(fastForwardTime / 1000)
    }

    private fun rewind() {
        try {
            player_center_menu?.isGone = false
            player_rew_holder?.alpha = 1f

            val rotateLeft = AnimationUtils.loadAnimation(context, R.anim.rotate_left)
            exo_rew?.startAnimation(rotateLeft)

            val goLeft = AnimationUtils.loadAnimation(context, R.anim.go_left)
            goLeft.setAnimationListener(object : Animation.AnimationListener {
                override fun onAnimationStart(animation: Animation?) {}

                override fun onAnimationRepeat(animation: Animation?) {}

                override fun onAnimationEnd(animation: Animation?) {
                    exo_rew_text?.post {
                        resetRewindText()
                        player_center_menu?.isGone = !isShowing
                        player_rew_holder?.alpha = if (isShowing) 1f else 0f
                    }
                }
            })
            exo_rew_text?.startAnimation(goLeft)
            exo_rew_text?.text = getString(R.string.rew_text_format).format(fastForwardTime / 1000)
            player.seekTime(-fastForwardTime)
        } catch (e: Exception) {
            logError(e)
        }
    }

    private fun fastForward() {
        try {
            player_center_menu?.isGone = false
            player_ffwd_holder?.alpha = 1f

            val rotateRight = AnimationUtils.loadAnimation(context, R.anim.rotate_right)
            exo_ffwd?.startAnimation(rotateRight)

            val goRight = AnimationUtils.loadAnimation(context, R.anim.go_right)
            goRight.setAnimationListener(object : Animation.AnimationListener {
                override fun onAnimationStart(animation: Animation?) {}

                override fun onAnimationRepeat(animation: Animation?) {}

                override fun onAnimationEnd(animation: Animation?) {
                    exo_ffwd_text?.post {
                        resetFastForwardText()
                        player_center_menu?.isGone = !isShowing
                        player_ffwd_holder?.alpha = if (isShowing) 1f else 0f
                    }
                }
            })
            exo_ffwd_text?.startAnimation(goRight)
            exo_ffwd_text?.text = getString(R.string.ffw_text_format).format(fastForwardTime / 1000)
            player.seekTime(fastForwardTime)
        } catch (e: Exception) {
            logError(e)
        }
    }

    private fun onClickChange() {
        isShowing = !isShowing
        if (isShowing) {
            autoHide()
        }
        activity?.hideSystemUI()
        animateLayoutChanges()
    }

    private fun toggleLock() {
        if (!isShowing) {
            onClickChange()
        }

        isLocked = !isLocked
        if (isLocked && isShowing) {
            player_holder?.postDelayed({
                if (isLocked && isShowing) {
                    onClickChange()
                }
            }, 200)
        }

        val fadeTo = if (isLocked) 0f else 1f

        val fadeAnimation = AlphaAnimation(player_video_title.alpha, fadeTo).apply {
            duration = 100
            fillAfter = true
        }

        updateUIVisibility()
        // MENUS
        //centerMenu.startAnimation(fadeAnimation)
        player_pause_play?.startAnimation(fadeAnimation)
        player_ffwd_holder?.startAnimation(fadeAnimation)
        player_rew_holder?.startAnimation(fadeAnimation)
        //player_media_route_button?.startAnimation(fadeAnimation)
        //video_bar.startAnimation(fadeAnimation)

        //TITLE
        player_video_title_rez?.startAnimation(fadeAnimation)
        player_video_title?.startAnimation(fadeAnimation)
        player_top_holder?.startAnimation(fadeAnimation)
        // BOTTOM
        player_lock_holder?.startAnimation(fadeAnimation)
        //player_go_back_holder?.startAnimation(fadeAnimation)

        shadow_overlay?.startAnimation(fadeAnimation)

        updateLockUI()
    }

    private fun updateUIVisibility() {
        val isGone = isLocked || !isShowing
        player_lock_holder?.isGone = isGone
        player_video_bar?.isGone = isGone
        player_pause_play_holder?.isGone = isGone
        player_pause_play?.isGone = isGone
        //player_buffering?.isGone = isGone
        player_top_holder?.isGone = isGone
        player_center_menu?.isGone = isGone
        player_lock?.isGone = !isShowing
        //player_media_route_button?.isClickable = !isGone
        player_go_back_holder?.isGone = isGone
    }

    private fun updateLockUI() {
        player_lock?.setIconResource(if (isLocked) R.drawable.video_locked else R.drawable.video_unlocked)
        val color = if (isLocked) context?.colorFromAttribute(R.attr.colorPrimary)
        else Color.WHITE
        if (color != null) {
            player_lock?.setTextColor(color)
            player_lock?.iconTint = ColorStateList.valueOf(color)
            player_lock?.rippleColor =
                ColorStateList.valueOf(Color.argb(50, color.red, color.green, color.blue))
        }
    }

    private var currentTapIndex = 0
    protected fun autoHide() {
        currentTapIndex++
        val index = currentTapIndex
        player_holder?.postDelayed({
            if (!isCurrentTouchValid && isShowing && index == currentTapIndex && player.getIsPlaying()) {
                onClickChange()
            }
        }, 2000)
    }

    // this is used because you don't want to hide UI when double tap seeking
    private var currentDoubleTapIndex = 0
    private fun toggleShowDelayed() {
        if (doubleTapEnabled) {
            val index = currentDoubleTapIndex
            player_holder?.postDelayed({
                if (index == currentDoubleTapIndex) {
                    onClickChange()
                }
            }, DOUBLE_TAB_MINIMUM_TIME_BETWEEN)
        } else {
            onClickChange()
        }
    }

    private var isCurrentTouchValid = false
    private var currentTouchStart: Vector2? = null
    private var currentTouchLast: Vector2? = null
    private var currentTouchAction: TouchAction? = null
    private var currentLastTouchAction: TouchAction? = null
    private var currentTouchStartPlayerTime: Long? =
        null // the time in the player when you first click
    private var currentTouchStartTime: Long? = null // the system time when you first click
    private var currentLastTouchEndTime: Long = 0 // the system time when you released your finger
    private var currentClickCount: Int =
        0 // amount of times you have double clicked, will reset when other action is taken

    // requested volume and brightness is used to make swiping smoother
    // to make it not jump between values,
    // this value is within the range [0,1]
    private var currentRequestedVolume: Float = 0.0f
    private var currentRequestedBrightness: Float = 1.0f

    enum class TouchAction {
        Brightness,
        Volume,
        Time,
    }

    companion object {
        private fun forceLetters(inp: Long, letters: Int = 2): String {
            val added: Int = letters - inp.toString().length
            return if (added > 0) {
                "0".repeat(added) + inp.toString()
            } else {
                inp.toString()
            }
        }

        private fun convertTimeToString(sec: Long): String {
            val rsec = sec % 60L
            val min = ceil((sec - rsec) / 60.0).toInt()
            val rmin = min % 60L
            val h = ceil((min - rmin) / 60.0).toLong()
            //int rh = h;// h % 24;
            return (if (h > 0) forceLetters(h) + ":" else "") + (if (rmin >= 0 || h >= 0) forceLetters(
                rmin
            ) + ":" else "") + forceLetters(
                rsec
            )
        }
    }

    private fun calculateNewTime(
        startTime: Long?,
        touchStart: Vector2?,
        touchEnd: Vector2?
    ): Long? {
        if (touchStart == null || touchEnd == null || startTime == null) return null
        val diffX = (touchEnd.x - touchStart.x) * HORIZONTAL_MULTIPLIER / screenWidth.toFloat()
        val duration = player.getDuration() ?: return null
        return max(
            min(
                startTime + ((duration * (diffX * diffX)) * (if (diffX < 0) -1 else 1)).toLong(),
                duration
            ), 0
        )
    }

    private fun getBrightness(): Float? {
        return if (useTrueSystemBrightness) {
            try {
                Settings.System.getInt(
                    context?.contentResolver,
                    Settings.System.SCREEN_BRIGHTNESS
                ) / 255f
            } catch (e: Exception) {
                // because true system brightness requires
                // permission, this is a lazy way to check
                // as it will throw an error if we do not have it
                useTrueSystemBrightness = false
                return getBrightness()
            }
        } else {
            try {
                activity?.window?.attributes?.screenBrightness
            } catch (e: Exception) {
                logError(e)
                null
            }
        }
    }

    private fun setBrightness(brightness: Float) {
        if (useTrueSystemBrightness) {
            try {
                Settings.System.putInt(
                    context?.contentResolver,
                    Settings.System.SCREEN_BRIGHTNESS_MODE,
                    Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL
                )

                Settings.System.putInt(
                    context?.contentResolver,
                    Settings.System.SCREEN_BRIGHTNESS, (brightness * 255).toInt()
                )
            } catch (e: Exception) {
                useTrueSystemBrightness = false
                setBrightness(brightness)
            }
        } else {
            try {
                val lp = activity?.window?.attributes
                lp?.screenBrightness = brightness
                activity?.window?.attributes = lp
            } catch (e: Exception) {
                logError(e)
            }
        }
    }

    @SuppressLint("SetTextI18n")
    private fun handleMotionEvent(view: View?, event: MotionEvent?): Boolean {
        if (event == null || view == null) return false
        val currentTouch = Vector2(event.x, event.y)
        val startTouch = currentTouchStart

        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                // validates if the touch is inside of the player area
                isCurrentTouchValid = isValidTouch(currentTouch.x, currentTouch.y)
                if (isCurrentTouchValid) {
                    currentTouchStartTime = System.currentTimeMillis()
                    currentTouchStart = currentTouch
                    currentTouchLast = currentTouch
                    currentTouchStartPlayerTime = player.getPosition()

                    getBrightness()?.let {
                        currentRequestedBrightness = it
                    }
                    (activity?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager)?.let { audioManager ->
                        val currentVolume =
                            audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)
                        val maxVolume =
                            audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)

                        currentRequestedVolume = currentVolume.toFloat() / maxVolume.toFloat()
                    }
                }
            }
            MotionEvent.ACTION_UP -> {
                if (isCurrentTouchValid && !isLocked) {
                    // seek time
                    if (swipeHorizontalEnabled && currentTouchAction == TouchAction.Time) {
                        val startTime = currentTouchStartPlayerTime
                        if (startTime != null) {
                            calculateNewTime(startTime, startTouch, currentTouch)?.let { seekTo ->
                                if (abs(seekTo - startTime) > MINIMUM_SEEK_TIME) {
                                    player.seekTo(seekTo)
                                }
                            }
                        }
                    }
                }

                // see if click is eligible for seek 10s
                val holdTime = currentTouchStartTime?.minus(System.currentTimeMillis())
                if (isCurrentTouchValid // is valid
                    && currentTouchAction == null // no other action like swiping is taking place
                    && currentLastTouchAction == null // last action was none, this prevents mis input random seek
                    && holdTime != null
                    && holdTime < DOUBLE_TAB_MAXIMUM_HOLD_TIME // it is a click not a long hold
                ) {
                    if (doubleTapEnabled
                        && !isLocked
                        && (System.currentTimeMillis() - currentLastTouchEndTime) < DOUBLE_TAB_MINIMUM_TIME_BETWEEN // the time since the last action is short
                    ) {
                        currentClickCount++

                        if (currentClickCount >= 1) { // have double clicked
                            currentDoubleTapIndex++
                            if (doubleTapPauseEnabled) { // you can pause if your tap is in the middle of the screen
                                when {
                                    currentTouch.x < screenWidth / 2 - (DOUBLE_TAB_PAUSE_PERCENTAGE * screenWidth) -> {
                                        rewind()
                                    }
                                    currentTouch.x > screenWidth / 2 + (DOUBLE_TAB_PAUSE_PERCENTAGE * screenWidth) -> {
                                        fastForward()
                                    }
                                    else -> {
                                        player.handleEvent(CSPlayerEvent.PlayPauseToggle)
                                    }
                                }
                            } else {
                                if (currentTouch.x < screenWidth / 2) {
                                    rewind()
                                } else {
                                    fastForward()
                                }
                            }
                        }
                    } else {
                        // is a valid click but not fast enough for seek
                        currentClickCount = 0
                        toggleShowDelayed()
                        //onClickChange()
                    }
                } else {
                    currentClickCount = 0
                }

                // call auto hide as it wont hide when you have your finger down
                autoHide()

                // reset variables
                isCurrentTouchValid = false
                currentTouchStart = null
                currentLastTouchAction = currentTouchAction
                currentTouchAction = null
                currentTouchStartPlayerTime = null
                currentTouchLast = null
                currentTouchStartTime = null

                // resets UI
                player_time_text?.isVisible = false
                player_progressbar_left_holder?.isVisible = false
                player_progressbar_right_holder?.isVisible = false
                currentLastTouchEndTime = System.currentTimeMillis()
            }
            MotionEvent.ACTION_MOVE -> {
                // if current touch is valid
                if (startTouch != null && isCurrentTouchValid && !isLocked) {
                    // action is unassigned and can therefore be assigned
                    if (currentTouchAction == null) {
                        val diffFromStart = startTouch - currentTouch

                        if (swipeVerticalEnabled) {
                            if (abs(diffFromStart.y * 100 / screenHeight) > MINIMUM_VERTICAL_SWIPE) {
                                // left = Brightness, right = Volume, but the UI is reversed to show the UI better
                                currentTouchAction = if (startTouch.x < screenWidth / 2) {
                                    // hide the UI if you hold brightness to show screen better, better UX
                                    if (isShowing) {
                                        isShowing = false
                                        animateLayoutChanges()
                                    }

                                    TouchAction.Brightness
                                } else {
                                    TouchAction.Volume
                                }
                            }
                        }
                        if (swipeHorizontalEnabled) {
                            if (abs(diffFromStart.x * 100 / screenHeight) > MINIMUM_HORIZONTAL_SWIPE) {
                                currentTouchAction = TouchAction.Time
                            }
                        }
                    }

                    // display action
                    val lastTouch = currentTouchLast
                    if (lastTouch != null) {
                        val diffFromLast = lastTouch - currentTouch
                        val verticalAddition =
                            diffFromLast.y * VERTICAL_MULTIPLIER / screenHeight.toFloat()

                        // update UI
                        player_time_text?.isVisible = false
                        player_progressbar_left_holder?.isVisible = false
                        player_progressbar_right_holder?.isVisible = false

                        when (currentTouchAction) {
                            TouchAction.Time -> {
                                // this simply updates UI as the seek logic happens on release
                                // startTime is rounded to make the UI sync in a nice way
                                val startTime =
                                    currentTouchStartPlayerTime?.div(1000L)?.times(1000L)
                                if (startTime != null) {
                                    calculateNewTime(
                                        startTime,
                                        startTouch,
                                        currentTouch
                                    )?.let { newMs ->
                                        val skipMs = newMs - startTime
                                        player_time_text?.text =
                                            "${convertTimeToString(newMs / 1000)} [${
                                                (if (abs(skipMs) < 1000) "" else (if (skipMs > 0) "+" else "-"))
                                            }${convertTimeToString(abs(skipMs / 1000))}]"
                                        player_time_text?.isVisible = true
                                    }
                                }
                            }
                            TouchAction.Brightness -> {
                                player_progressbar_right_holder?.isVisible = true
                                val lastRequested = currentRequestedBrightness
                                currentRequestedBrightness =
                                    min(
                                        1.0f,
                                        max(currentRequestedBrightness + verticalAddition, 0.0f)
                                    )

                                // this is to not spam request it, just in case it fucks over someone
                                if (lastRequested != currentRequestedBrightness)
                                    setBrightness(currentRequestedBrightness)

                                // max is set high to make it smooth
                                player_progressbar_right?.max = 100_000
                                player_progressbar_right?.progress =
                                    max(2_000, (currentRequestedBrightness * 100_000f).toInt())

                                player_progressbar_right_icon?.setImageResource(
                                    brightnessIcons[min( // clamp the value just in case
                                        brightnessIcons.size - 1,
                                        max(
                                            0,
                                            round(currentRequestedBrightness * (brightnessIcons.size - 1)).toInt()
                                        )
                                    )]
                                )
                            }
                            TouchAction.Volume -> {
                                (activity?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager)?.let { audioManager ->
                                    player_progressbar_left_holder?.isVisible = true
                                    val maxVolume =
                                        audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)
                                    val currentVolume =
                                        audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)

                                    // clamps volume and adds swipe
                                    currentRequestedVolume =
                                        min(
                                            1.0f,
                                            max(currentRequestedVolume + verticalAddition, 0.0f)
                                        )

                                    // max is set high to make it smooth
                                    player_progressbar_left?.max = 100_000
                                    player_progressbar_left?.progress =
                                        max(2_000, (currentRequestedVolume * 100_000f).toInt())

                                    player_progressbar_left_icon?.setImageResource(
                                        volumeIcons[min( // clamp the value just in case
                                            volumeIcons.size - 1,
                                            max(
                                                0,
                                                round(currentRequestedVolume * (volumeIcons.size - 1)).toInt()
                                            )
                                        )]
                                    )

                                    // this is used instead of set volume because old devices does not support it
                                    val desiredVolume =
                                        round(currentRequestedVolume * maxVolume).toInt()
                                    if (desiredVolume != currentVolume) {
                                        val newVolumeAdjusted =
                                            if (desiredVolume < currentVolume) AudioManager.ADJUST_LOWER else AudioManager.ADJUST_RAISE

                                        audioManager.adjustStreamVolume(
                                            AudioManager.STREAM_MUSIC,
                                            newVolumeAdjusted,
                                            0
                                        )
                                    }
                                }
                            }
                            else -> Unit
                        }
                    }
                }
            }
        }
        currentTouchLast = currentTouch
        return true
    }

    private fun handleKeyEvent(event: KeyEvent): Boolean {
        event.keyCode.let { keyCode ->
            when (event.action) {
                KeyEvent.ACTION_DOWN -> {
                    when (keyCode) {
                        KeyEvent.KEYCODE_DPAD_CENTER, KeyEvent.KEYCODE_DPAD_UP -> {
                            if (!isShowing) {
                                onClickChange()
                                return true
                            }
                        }
                    }

                    //println("Keycode: $keyCode")
                    //showToast(
                    //    this,
                    //    "Got Keycode $keyCode | ${KeyEvent.keyCodeToString(keyCode)} \n ${event?.action}",
                    //    Toast.LENGTH_LONG
                    //)
                }
            }

            when (keyCode) {
                // don't allow dpad move when hidden
                KeyEvent.KEYCODE_DPAD_LEFT,
                KeyEvent.KEYCODE_DPAD_DOWN,
                KeyEvent.KEYCODE_DPAD_UP,
                KeyEvent.KEYCODE_DPAD_RIGHT,
                KeyEvent.KEYCODE_DPAD_DOWN_LEFT,
                KeyEvent.KEYCODE_DPAD_DOWN_RIGHT,
                KeyEvent.KEYCODE_DPAD_UP_LEFT,
                KeyEvent.KEYCODE_DPAD_UP_RIGHT -> {
                    if (!isShowing) {
                        return true
                    } else {
                        autoHide()
                    }
                }

                // netflix capture back and hide ~monke
                KeyEvent.KEYCODE_BACK -> {
                    if (isShowing) {
                        onClickChange()
                        return true
                    }
                }
            }
        }

        return false
    }

    protected fun uiReset() {
        isLocked = false
        isShowing = false

        // if nothing has loaded these buttons should not be visible
        player_skip_episode?.isVisible = false
        player_skip_op?.isVisible = false

        updateLockUI()
        updateUIVisibility()
        animateLayoutChanges()
        resetFastForwardText()
        resetRewindText()
    }

    @SuppressLint("ClickableViewAccessibility")
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        // init variables
        setPlayBackSpeed(getKey(PLAYBACK_SPEED_KEY) ?: 1.0f)
        fastForwardTime = getKey(PLAYBACK_FASTFORWARD) ?: 10000L

        // handle tv controls
        playerEventListener = { eventType ->
            when (eventType) {
                PlayerEventType.Lock -> {
                    toggleLock()
                }
                PlayerEventType.NextEpisode -> {
                    player.handleEvent(CSPlayerEvent.NextEpisode)
                }
                PlayerEventType.Pause -> {
                    player.handleEvent(CSPlayerEvent.Pause)
                }
                PlayerEventType.PlayPauseToggle -> {
                    player.handleEvent(CSPlayerEvent.PlayPauseToggle)
                }
                PlayerEventType.Play -> {
                    player.handleEvent(CSPlayerEvent.Play)
                }
                PlayerEventType.Resize -> {
                    nextResize()
                }
                PlayerEventType.PrevEpisode -> {
                    player.handleEvent(CSPlayerEvent.PrevEpisode)
                }
                PlayerEventType.SeekForward -> {
                    player.handleEvent(CSPlayerEvent.SeekForward)
                }
                PlayerEventType.ShowSpeed -> {
                    showSpeedDialog()
                }
                PlayerEventType.SeekBack -> {
                    player.handleEvent(CSPlayerEvent.SeekBack)
                }
                PlayerEventType.ToggleMute -> {
                    player.handleEvent(CSPlayerEvent.ToggleMute)
                }
                PlayerEventType.ToggleHide -> {
                    onClickChange()
                }
                PlayerEventType.ShowMirrors -> {
                    showMirrorsDialogue()
                }
            }
        }

        // handle tv controls directly based on player state
        keyEventListener = { keyEvent ->
            if (keyEvent != null) {
                handleKeyEvent(keyEvent)
            } else {
                false
            }
        }

        try {
            val settingsManager = PreferenceManager.getDefaultSharedPreferences(activity)
            context?.let { ctx ->
                navigationBarHeight = ctx.getNavigationBarHeight()
                statusBarHeight = ctx.getStatusBarHeight()

                swipeHorizontalEnabled =
                    settingsManager.getBoolean(ctx.getString(R.string.swipe_enabled_key), true)
                swipeVerticalEnabled =
                    settingsManager.getBoolean(
                        ctx.getString(R.string.swipe_vertical_enabled_key),
                        true
                    )
                playBackSpeedEnabled = settingsManager.getBoolean(
                    ctx.getString(R.string.playback_speed_enabled_key),
                    false
                )
                playerResizeEnabled =
                    settingsManager.getBoolean(
                        ctx.getString(R.string.player_resize_enabled_key),
                        true
                    )
                doubleTapEnabled =
                    settingsManager.getBoolean(
                        ctx.getString(R.string.double_tap_enabled_key),
                        false
                    )

                doubleTapPauseEnabled =
                    settingsManager.getBoolean(
                        ctx.getString(R.string.double_tap_pause_enabled_key),
                        false
                    )

                currentPrefQuality = settingsManager.getInt(
                    ctx.getString(R.string.quality_pref_key),
                    currentPrefQuality
                )
                // useSystemBrightness =
                //    settingsManager.getBoolean(ctx.getString(R.string.use_system_brightness_key), false)
            }

            player_speed_btt?.isVisible = playBackSpeedEnabled
            player_resize_btt?.isVisible = playerResizeEnabled
        } catch (e: Exception) {
            logError(e)
        }

        player_pause_play?.setOnClickListener {
            autoHide()
            player.handleEvent(CSPlayerEvent.PlayPauseToggle)
        }

        // init clicks
        player_resize_btt?.setOnClickListener {
            autoHide()
            nextResize()
        }

        player_speed_btt?.setOnClickListener {
            autoHide()
            showSpeedDialog()
        }

        player_skip_op?.setOnClickListener {
            autoHide()
            skipOp()
        }

        player_skip_episode?.setOnClickListener {
            autoHide()
            player.handleEvent(CSPlayerEvent.NextEpisode)
        }

        player_lock?.setOnClickListener {
            autoHide()
            toggleLock()
        }

        exo_rew?.setOnClickListener {
            autoHide()
            rewind()
        }

        exo_ffwd?.setOnClickListener {
            autoHide()
            fastForward()
        }

        player_go_back?.setOnClickListener {
            activity?.popCurrentPage()
        }

        player_sources_btt?.setOnClickListener {
            showMirrorsDialogue()
        }

        // it is !not! a bug that you cant touch the right side, it does not register inputs on navbar or status bar
        player_holder?.setOnTouchListener { callView, event ->
            return@setOnTouchListener handleMotionEvent(callView, event)
        }

        exo_progress?.setOnTouchListener { _, event ->
            // this makes the bar not disappear when sliding
            when (event.action) {
                MotionEvent.ACTION_DOWN -> {
                    currentTapIndex++
                }
                MotionEvent.ACTION_MOVE -> {
                    currentTapIndex++
                }
                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL, MotionEvent.ACTION_BUTTON_RELEASE -> {
                    autoHide()
                }
            }
            return@setOnTouchListener false
        }
        // init UI
        try {
            uiReset()

            // init chromecast UI
            // removed due to having no use and bugging
            //activity?.let {
            //    if (it.isCastApiAvailable()) {
            //        try {
            //            CastButtonFactory.setUpMediaRouteButton(it, player_media_route_button)
            //            val castContext = CastContext.getSharedInstance(it.applicationContext)
            //
            //            player_media_route_button?.isGone =
            //                castContext.castState == CastState.NO_DEVICES_AVAILABLE
            //            castContext.addCastStateListener { state ->
            //                player_media_route_button?.isGone =
            //                    state == CastState.NO_DEVICES_AVAILABLE
            //            }
            //        } catch (e: Exception) {
            //            logError(e)
            //        }
            //    } else {
            //        // if cast is not possible hide UI
            //        player_media_route_button?.isGone = true
            //    }
            //}
        } catch (e: Exception) {
            logError(e)
        }
    }
}