LibreTube/app/src/main/java/com/github/libretube/fragments/PlayerFragment.kt

package com.github.libretube.fragments

import android.annotation.SuppressLint
import android.app.NotificationManager
import android.app.PictureInPictureParams
import android.content.Context
import android.content.Intent
import android.content.pm.ActivityInfo
import android.graphics.Rect
import android.net.Uri
import android.os.Build
import android.os.Build.VERSION.SDK_INT
import android.os.Bundle
import android.os.PowerManager
import android.support.v4.media.session.MediaSessionCompat
import android.text.Html
import android.text.TextUtils
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.constraintlayout.motion.widget.MotionLayout
import androidx.constraintlayout.widget.ConstraintLayout
import androidx.core.net.toUri
import androidx.core.os.bundleOf
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.GridLayoutManager
import androidx.recyclerview.widget.LinearLayoutManager
import com.github.libretube.R
import com.github.libretube.activities.MainActivity
import com.github.libretube.activities.hideKeyboard
import com.github.libretube.adapters.ChaptersAdapter
import com.github.libretube.adapters.CommentsAdapter
import com.github.libretube.adapters.TrendingAdapter
import com.github.libretube.databinding.ExoStyledPlayerControlViewBinding
import com.github.libretube.databinding.FragmentPlayerBinding
import com.github.libretube.dialogs.AddtoPlaylistDialog
import com.github.libretube.dialogs.DownloadDialog
import com.github.libretube.dialogs.ShareDialog
import com.github.libretube.obj.ChapterSegment
import com.github.libretube.obj.PipedStream
import com.github.libretube.obj.Playlist
import com.github.libretube.obj.Segment
import com.github.libretube.obj.Segments
import com.github.libretube.obj.SponsorBlockPrefs
import com.github.libretube.obj.StreamItem
import com.github.libretube.obj.Streams
import com.github.libretube.obj.Subscribe
import com.github.libretube.preferences.PreferenceHelper
import com.github.libretube.services.IS_DOWNLOAD_RUNNING
import com.github.libretube.util.CronetHelper
import com.github.libretube.util.DescriptionAdapter
import com.github.libretube.util.RetrofitInstance
import com.github.libretube.util.formatShort
import com.google.android.exoplayer2.C
import com.google.android.exoplayer2.DefaultLoadControl
import com.google.android.exoplayer2.ExoPlayer
import com.google.android.exoplayer2.MediaItem
import com.google.android.exoplayer2.MediaItem.SubtitleConfiguration
import com.google.android.exoplayer2.MediaItem.fromUri
import com.google.android.exoplayer2.Player
import com.google.android.exoplayer2.audio.AudioAttributes
import com.google.android.exoplayer2.ext.cronet.CronetDataSource
import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector
import com.google.android.exoplayer2.source.DefaultMediaSourceFactory
import com.google.android.exoplayer2.source.MediaSource
import com.google.android.exoplayer2.source.MergingMediaSource
import com.google.android.exoplayer2.source.ProgressiveMediaSource
import com.google.android.exoplayer2.ui.AspectRatioFrameLayout
import com.google.android.exoplayer2.ui.PlayerNotificationManager
import com.google.android.exoplayer2.ui.StyledPlayerView
import com.google.android.exoplayer2.upstream.DataSource
import com.google.android.exoplayer2.upstream.DefaultDataSource
import com.google.android.exoplayer2.upstream.DefaultHttpDataSource
import com.google.android.exoplayer2.util.RepeatModeUtil
import com.google.android.exoplayer2.video.VideoSize
import com.google.android.material.button.MaterialButton
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.squareup.picasso.Picasso
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import org.chromium.net.CronetEngine
import retrofit2.HttpException
import java.io.IOException
import java.util.concurrent.Executors
import kotlin.math.abs

var isFullScreen = false
var isMiniPlayerVisible = false

class PlayerFragment : Fragment() {

    private val TAG = "PlayerFragment"
    private lateinit var binding: FragmentPlayerBinding
    private lateinit var playerBinding: ExoStyledPlayerControlViewBinding

    private var videoId: String? = null
    private var playlistId: String? = null
    private var sId: Int = 0
    private var eId: Int = 0
    private var paused = false
    private var whichQuality = 0
    private var transitioning = false
    private var autoplay = false
    private var isZoomed: Boolean = false

    private var isSubscribed: Boolean = false

    private var commentsAdapter: CommentsAdapter? = null
    private var commentsLoaded: Boolean? = false
    private var nextPage: String? = null
    private var isLoading = true
    private lateinit var exoPlayerView: StyledPlayerView
    private lateinit var exoPlayer: ExoPlayer
    private lateinit var segmentData: Segments
    private var relatedStreamsEnabled = true

    private var relatedStreams: List<StreamItem>? = arrayListOf()
    private var nextStreamId: String? = null
    private var playlistStreamIds: MutableList<String> = arrayListOf()
    private var playlistNextPage: String? = null

    private var isPlayerLocked: Boolean = false

    private lateinit var mediaSession: MediaSessionCompat
    private lateinit var mediaSessionConnector: MediaSessionConnector
    private lateinit var playerNotification: PlayerNotificationManager

    private lateinit var title: String
    private lateinit var uploader: String
    private lateinit var thumbnailUrl: String
    private val sponsorBlockPrefs = SponsorBlockPrefs()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        arguments?.let {
            videoId = it.getString("videoId")
            playlistId = it.getString("playlistId")
        }
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = FragmentPlayerBinding.inflate(layoutInflater, container, false)
        playerBinding = binding.player.binding
        // Inflate the layout for this fragment
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        hideKeyboard()

        setSponsorBlockPrefs()
        createExoPlayer(view)
        initializeTransitionLayout(view)
        playVideo(view)
    }

    private fun initializeTransitionLayout(view: View) {
        videoId = videoId!!.replace("/watch?v=", "")

        val mainActivity = activity as MainActivity
        mainActivity.binding.container.visibility = View.VISIBLE

        exoPlayerView = binding.player
        binding.mainContainer.visibility = View.GONE

        binding.playerMotionLayout.addTransitionListener(object : MotionLayout.TransitionListener {
            override fun onTransitionStarted(
                motionLayout: MotionLayout?,
                startId: Int,
                endId: Int
            ) {
            }

            override fun onTransitionChange(
                motionLayout: MotionLayout?,
                startId: Int,
                endId: Int,
                progress: Float
            ) {
                val mainActivity = activity as MainActivity
                val mainMotionLayout =
                    mainActivity.binding.mainMotionLayout
                mainMotionLayout.progress = abs(progress)
                exoPlayerView.hideController()
                eId = endId
                sId = startId
            }

            override fun onTransitionCompleted(motionLayout: MotionLayout?, currentId: Int) {
                println(currentId)
                val mainActivity = activity as MainActivity
                val mainMotionLayout =
                    mainActivity.binding.mainMotionLayout
                if (currentId == eId) {
                    isMiniPlayerVisible = true
                    exoPlayerView.useController = false
                    mainMotionLayout.progress = 1F
                } else if (currentId == sId) {
                    isMiniPlayerVisible = false
                    exoPlayerView.useController = true
                    mainMotionLayout.progress = 0F
                }
            }

            override fun onTransitionTrigger(
                MotionLayout: MotionLayout?,
                triggerId: Int,
                positive: Boolean,
                progress: Float
            ) {
            }
        })

        binding.playerMotionLayout.progress = 1.toFloat()
        binding.playerMotionLayout.transitionToStart()

        binding.closeImageView.setOnClickListener {
            isMiniPlayerVisible = false
            binding.playerMotionLayout.transitionToEnd()
            val mainActivity = activity as MainActivity
            mainActivity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
            mainActivity.supportFragmentManager.beginTransaction()
                .remove(this)
                .commit()
        }
        playerBinding.closeImageButton.setOnClickListener {
            isMiniPlayerVisible = false
            binding.playerMotionLayout.transitionToEnd()
            val mainActivity = activity as MainActivity
            mainActivity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
            mainActivity.supportFragmentManager.beginTransaction()
                .remove(this)
                .commit()
        }
        binding.playImageView.setOnClickListener {
            paused = if (paused) {
                binding.playImageView.setImageResource(R.drawable.ic_pause)
                exoPlayer.play()
                false
            } else {
                binding.playImageView.setImageResource(R.drawable.ic_play)
                exoPlayer.pause()
                true
            }
        }

        // video description and chapters toggle
        binding.playerTitleLayout.setOnClickListener {
            binding.playerDescriptionArrow.animate().rotationBy(180F).setDuration(250).start()
            binding.descLinLayout.visibility =
                if (binding.descLinLayout.isVisible) View.GONE else View.VISIBLE
        }

        binding.commentsToggle.setOnClickListener {
            toggleComments()
        }

        // FullScreen button trigger
        playerBinding.fullscreen.setOnClickListener {
            exoPlayerView.hideController()
            var scaleFactor: Float? = null
            if (!isFullScreen) {
                // go to fullscreen mode
                with(binding.playerMotionLayout) {
                    getConstraintSet(R.id.start).constrainHeight(R.id.player, -1)
                    enableTransition(R.id.yt_transition, false)
                }

                binding.mainContainer.isClickable = true
                binding.linLayout.visibility = View.GONE
                playerBinding.fullscreen.setImageResource(R.drawable.ic_fullscreen_exit)
                playerBinding.exoTitle.visibility = View.VISIBLE

                scaleFactor = 1.3F

                val mainActivity = activity as MainActivity
                mainActivity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
            } else {
                // leave fullscreen mode
                with(binding.playerMotionLayout) {
                    getConstraintSet(R.id.start).constrainHeight(R.id.player, 0)
                    enableTransition(R.id.yt_transition, true)
                }

                binding.mainContainer.isClickable = false
                binding.linLayout.visibility = View.VISIBLE
                playerBinding.fullscreen.setImageResource(R.drawable.ic_fullscreen)
                playerBinding.exoTitle.visibility = View.INVISIBLE

                scaleFactor = 1F

                val mainActivity = activity as MainActivity
                mainActivity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
            }
            isFullScreen = !isFullScreen

            // scale the exo player center controls
            playerBinding.exoFfwdWithAmount.scaleX = scaleFactor
            playerBinding.exoFfwdWithAmount.scaleY = scaleFactor
            playerBinding.exoRewWithAmount.scaleX = scaleFactor
            playerBinding.exoRewWithAmount.scaleY = scaleFactor
            playerBinding.exoPlayPause.scaleX = scaleFactor
            playerBinding.exoPlayPause.scaleY = scaleFactor
        }

        // switching between original aspect ratio (black bars) and zoomed to fill device screen
        playerBinding.aspectRatioButton.setOnClickListener {
            if (isZoomed) {
                exoPlayerView.resizeMode = AspectRatioFrameLayout.RESIZE_MODE_FIT
                isZoomed = false
            } else {
                exoPlayerView.resizeMode = AspectRatioFrameLayout.RESIZE_MODE_ZOOM
                isZoomed = true
            }
        }

        // lock and unlock the player
        playerBinding.lockPlayer.setOnClickListener {
            // change the locked/unlocked icon
            if (!isPlayerLocked) {
                playerBinding.lockPlayer.setImageResource(R.drawable.ic_locked)
            } else {
                playerBinding.lockPlayer.setImageResource(R.drawable.ic_unlocked)
            }

            // show/hide all the controls
            lockPlayer(isPlayerLocked)

            // change locked status
            isPlayerLocked = !isPlayerLocked
        }

        binding.playerScrollView.viewTreeObserver
            .addOnScrollChangedListener {
                if (binding.playerScrollView.getChildAt(0).bottom
                    == (binding.playerScrollView.height + binding.playerScrollView.scrollY) &&
                    nextPage != null
                ) {
                    fetchNextComments()
                }
            }

        binding.commentsRecView.layoutManager = LinearLayoutManager(view.context)
        binding.commentsRecView.setItemViewCacheSize(20)

        binding.relatedRecView.layoutManager =
            GridLayoutManager(view.context, resources.getInteger(R.integer.grid_items))
    }

    private fun toggleComments() {
        binding.commentsRecView.visibility =
            if (binding.commentsRecView.isVisible) View.GONE else View.VISIBLE
        binding.relatedRecView.visibility =
            if (binding.relatedRecView.isVisible) View.GONE else View.VISIBLE
        if (!commentsLoaded!!) fetchComments()
    }

    override fun onPause() {
        // pause the player if the screen is turned off
        val pausePlayerOnScreenOffEnabled = PreferenceHelper.getBoolean(
            requireContext(),
            "pause_screen_off",
            false
        )

        // check whether the screen is on
        val pm = context?.getSystemService(Context.POWER_SERVICE) as PowerManager
        val isScreenOn = pm.isInteractive

        // pause player if screen off and setting enabled
        if (
            this::exoPlayer.isInitialized && !isScreenOn && pausePlayerOnScreenOffEnabled
        ) {
            exoPlayer.pause()
        }
        super.onPause()
    }

    override fun onDestroy() {
        super.onDestroy()
        try {
            saveWatchPosition()
            mediaSession.isActive = false
            mediaSession.release()
            mediaSessionConnector.setPlayer(null)
            playerNotification.setPlayer(null)
            val notificationManager = context?.getSystemService(
                Context.NOTIFICATION_SERVICE
            ) as NotificationManager
            notificationManager.cancel(1)
            exoPlayer.release()
        } catch (e: Exception) {
        }
    }

    // save the watch position if video isn't finished and option enabled
    private fun saveWatchPosition() {
        val watchPositionsEnabled = PreferenceHelper.getBoolean(
            requireContext(),
            "watch_positions_toggle",
            true
        )
        if (watchPositionsEnabled && exoPlayer.currentPosition != exoPlayer.duration) {
            PreferenceHelper.saveWatchPosition(
                requireContext(),
                videoId!!,
                exoPlayer.currentPosition
            )
        } else if (watchPositionsEnabled) {
            // delete watch position if video has ended
            PreferenceHelper.removeWatchPosition(requireContext(), videoId!!)
        }
    }

    private fun checkForSegments() {
        if (!exoPlayer.isPlaying || !sponsorBlockPrefs.sponsorBlockEnabled) return

        exoPlayerView.postDelayed(this::checkForSegments, 100)

        if (!::segmentData.isInitialized || segmentData.segments.isEmpty()) {
            return
        }

        segmentData.segments.forEach { segment: Segment ->
            val segmentStart = (segment.segment!![0] * 1000.0f).toLong()
            val segmentEnd = (segment.segment[1] * 1000.0f).toLong()
            val currentPosition = exoPlayer.currentPosition
            if (currentPosition in segmentStart until segmentEnd) {
                if (sponsorBlockPrefs.sponsorNotificationsEnabled) {
                    Toast.makeText(context, R.string.segment_skipped, Toast.LENGTH_SHORT).show()
                }
                exoPlayer.seekTo(segmentEnd)
            }
        }
    }

    private fun playVideo(view: View) {
        fun run() {
            lifecycleScope.launchWhenCreated {
                val response = try {
                    RetrofitInstance.api.getStreams(videoId!!)
                } catch (e: IOException) {
                    println(e)
                    Log.e(TAG, "IOException, you might not have internet connection")
                    Toast.makeText(context, R.string.unknown_error, Toast.LENGTH_SHORT).show()
                    return@launchWhenCreated
                } catch (e: HttpException) {
                    Log.e(TAG, "HttpException, unexpected response")
                    Toast.makeText(context, R.string.server_error, Toast.LENGTH_SHORT).show()
                    return@launchWhenCreated
                }
                // for the notification description adapter
                title = response.title!!
                uploader = response.uploader!!
                thumbnailUrl = response.thumbnailUrl!!

                // save whether related streams and autoplay are enabled
                autoplay = PreferenceHelper.getBoolean(requireContext(), "autoplay", false)
                relatedStreamsEnabled =
                    PreferenceHelper.getBoolean(requireContext(), "related_streams_toggle", true)
                // save related streams for autoplay
                relatedStreams = response.relatedStreams

                runOnUiThread {
                    // set media sources for the player
                    setResolutionAndSubtitles(view, response)
                    prepareExoPlayerView()
                    initializePlayerView(view, response)
                    seekToWatchPosition()
                    exoPlayer.prepare()
                    exoPlayer.play()
                    exoPlayerView.useController = true
                    initializePlayerNotification(requireContext())
                    fetchSponsorBlockSegments()
                    // show comments if related streams disabled
                    if (!relatedStreamsEnabled) toggleComments()
                    // prepare for autoplay
                    initAutoPlay()
                    val watchHistoryEnabled =
                        PreferenceHelper.getBoolean(requireContext(), "Watch_history_toggle", true)
                    if (watchHistoryEnabled) {
                        PreferenceHelper.addToWatchHistory(requireContext(), videoId!!, response)
                    }
                }
            }
        }
        run()
    }

    private fun seekToWatchPosition() {
        // seek to saved watch position if available
        val watchPositions = PreferenceHelper.getWatchPositions(requireContext())
        watchPositions.forEach {
            if (it.videoId == videoId) exoPlayer.seekTo(it.position)
        }
        // support for time stamped links
        if (arguments?.getLong("timeStamp") != null) {
            val position = arguments?.getLong("timeStamp")!! * 1000
            exoPlayer.seekTo(position)
        }
    }

    // the function is working recursively
    private fun initAutoPlay() {
        // save related streams for autoplay
        if (autoplay) {
            // if it's a playlist use the next video
            if (playlistId != null) {
                lateinit var playlist: Playlist // var for saving the list in
                // runs only the first time when starting a video from a playlist
                if (playlistStreamIds.isEmpty()) {
                    CoroutineScope(Dispatchers.IO).launch {
                        // fetch the playlists videos
                        playlist = RetrofitInstance.api.getPlaylist(playlistId!!)
                        // save the playlist urls in the array
                        playlist.relatedStreams?.forEach { video ->
                            playlistStreamIds += video.url?.replace("/watch?v=", "")!!
                        }
                        // save playlistNextPage for usage if video is not contained
                        playlistNextPage = playlist.nextpage
                        // restart the function after videos are loaded
                        initAutoPlay()
                    }
                }
                // if the playlists contain the video, then save the next video as next stream
                else if (playlistStreamIds.contains(videoId)) {
                    val index = playlistStreamIds.indexOf(videoId)
                    // check whether there's a next video
                    if (index + 1 <= playlistStreamIds.size) {
                        nextStreamId = playlistStreamIds[index + 1]
                    }
                    // fetch the next page of the playlist if the video isn't contained
                } else if (playlistNextPage != null) {
                    CoroutineScope(Dispatchers.IO).launch {
                        RetrofitInstance.api.getPlaylistNextPage(playlistId!!, playlistNextPage!!)
                        // append all the playlist item urls to the array
                        playlist.relatedStreams?.forEach { video ->
                            playlistStreamIds += video.url?.replace("/watch?v=", "")!!
                        }
                        // save playlistNextPage for usage if video is not contained
                        playlistNextPage = playlist.nextpage
                        // restart the function after videos are loaded
                        initAutoPlay()
                    }
                }
                // else: the video must be the last video of the playlist so nothing happens

                // if it's not a playlist then use the next related video
            } else if (relatedStreams != null && relatedStreams!!.isNotEmpty()) {
                // save next video from related streams for autoplay
                nextStreamId = relatedStreams!![0].url!!.replace("/watch?v=", "")
            }
        }
    }

    // used for autoplay and skipping to next video
    private fun playNextVideo() {
        // check whether there is a new video in the queue
        // by making sure that the next and the current video aren't the same
        if (videoId != nextStreamId) {
            // save the id of the next stream as videoId and load the next video
            videoId = nextStreamId
            playVideo(view!!)
        }
    }

    private fun setSponsorBlockPrefs() {
        sponsorBlockPrefs.sponsorBlockEnabled =
            PreferenceHelper.getBoolean(requireContext(), "sb_enabled_key", true)
        sponsorBlockPrefs.sponsorNotificationsEnabled =
            PreferenceHelper.getBoolean(requireContext(), "sb_notifications_key", true)
        sponsorBlockPrefs.introEnabled =
            PreferenceHelper.getBoolean(requireContext(), "intro_category_key", false)
        sponsorBlockPrefs.selfPromoEnabled =
            PreferenceHelper.getBoolean(requireContext(), "selfpromo_category_key", false)
        sponsorBlockPrefs.interactionEnabled =
            PreferenceHelper.getBoolean(requireContext(), "interaction_category_key", false)
        sponsorBlockPrefs.sponsorsEnabled =
            PreferenceHelper.getBoolean(requireContext(), "sponsors_category_key", true)
        sponsorBlockPrefs.outroEnabled =
            PreferenceHelper.getBoolean(requireContext(), "outro_category_key", false)
        sponsorBlockPrefs.fillerEnabled =
            PreferenceHelper.getBoolean(requireContext(), "filler_category_key", false)
        sponsorBlockPrefs.musicOffTopicEnabled =
            PreferenceHelper.getBoolean(requireContext(), "music_offtopic_category_key", false)
        sponsorBlockPrefs.previewEnabled =
            PreferenceHelper.getBoolean(requireContext(), "preview_category_key", false)
    }

    private fun fetchSponsorBlockSegments() {
        fun run() {
            lifecycleScope.launch(Dispatchers.IO) {
                if (sponsorBlockPrefs.sponsorBlockEnabled) {
                    val categories: ArrayList<String> = arrayListOf()
                    if (sponsorBlockPrefs.introEnabled) {
                        categories.add("intro")
                    }
                    if (sponsorBlockPrefs.selfPromoEnabled) {
                        categories.add("selfpromo")
                    }
                    if (sponsorBlockPrefs.interactionEnabled) {
                        categories.add("interaction")
                    }
                    if (sponsorBlockPrefs.sponsorsEnabled) {
                        categories.add("sponsor")
                    }
                    if (sponsorBlockPrefs.outroEnabled) {
                        categories.add("outro")
                    }
                    if (sponsorBlockPrefs.fillerEnabled) {
                        categories.add("filler")
                    }
                    if (sponsorBlockPrefs.musicOffTopicEnabled) {
                        categories.add("music_offtopic")
                    }
                    if (sponsorBlockPrefs.previewEnabled) {
                        categories.add("preview")
                    }
                    if (categories.size > 0) {
                        segmentData = try {
                            RetrofitInstance.api.getSegments(
                                videoId!!,
                                "[\"" + TextUtils.join("\",\"", categories) + "\"]"
                            )
                        } catch (e: IOException) {
                            println(e)
                            Log.e(TAG, "IOException, you might not have internet connection")
                            return@launch
                        } catch (e: HttpException) {
                            Log.e(TAG, "HttpException, unexpected response")
                            return@launch
                        }
                    }
                }
            }
        }
        run()
    }

    private fun prepareExoPlayerView() {
        exoPlayerView.apply {
            setShowSubtitleButton(true)
            setShowNextButton(false)
            setShowPreviousButton(false)
            setRepeatToggleModes(RepeatModeUtil.REPEAT_TOGGLE_MODE_ALL)
            // controllerShowTimeoutMs = 1500
            controllerHideOnTouch = true
            useController = false
            player = exoPlayer
        }
    }

    private fun initializePlayerView(view: View, response: Streams) {
        binding.playerViewsInfo.text =
            context?.getString(R.string.views, response.views.formatShort()) +
            " • " + response.uploadDate
        binding.textLike.text = response.likes.formatShort()
        binding.textDislike.text = response.dislikes.formatShort()
        Picasso.get().load(response.uploaderAvatar).into(binding.playerChannelImage)
        binding.playerChannelName.text = response.uploader

        binding.titleTextView.text = response.title
        binding.playerTitle.text = response.title
        binding.playerDescription.text = response.description

        playerBinding.exoTitle.text = response.title

        // init the chapters recyclerview
        if (response.chapters != null) initializeChapters(response.chapters)

        // Listener for play and pause icon change
        exoPlayer.addListener(object : Player.Listener {
            override fun onIsPlayingChanged(isPlaying: Boolean) {
                if (isPlaying && sponsorBlockPrefs.sponsorBlockEnabled) {
                    exoPlayerView.postDelayed(
                        this@PlayerFragment::checkForSegments,
                        100
                    )
                }
            }

            override fun onVideoSizeChanged(
                videoSize: VideoSize
            ) {
                // Set new width/height of view
                // height or width must be cast to float as int/int will give 0

                // Redraw the player container with the new layout height
                (binding.mainContainer.layoutParams as ConstraintLayout.LayoutParams).apply {
                    matchConstraintPercentHeight = (
                        videoSize.height / videoSize.width
                        ).toFloat()
                }
                binding.mainContainer.requestLayout()
            }

            @Deprecated(message = "Deprecated", level = DeprecationLevel.HIDDEN)
            override fun onPlayerStateChanged(
                playWhenReady: Boolean,
                playbackState: Int
            ) {
                exoPlayerView.keepScreenOn = !(
                    playbackState == Player.STATE_IDLE ||
                        playbackState == Player.STATE_ENDED ||
                        !playWhenReady
                    )

                // check if video has ended, next video is available and autoplay is enabled.
                if (
                    playbackState == Player.STATE_ENDED &&
                    nextStreamId != null &&
                    !transitioning &&
                    autoplay
                ) {
                    transitioning = true
                    // check whether autoplay is enabled
                    if (autoplay) playNextVideo()
                }

                if (playWhenReady && playbackState == Player.STATE_READY) {
                    // media actually playing
                    transitioning = false
                    binding.playImageView.setImageResource(R.drawable.ic_pause)
                } else if (playWhenReady) {
                    // might be idle (plays after prepare()),
                    // buffering (plays when data available)
                    // or ended (plays when seek away from end)
                    binding.playImageView.setImageResource(R.drawable.ic_play)
                } else {
                    // player paused in any state
                    binding.playImageView.setImageResource(R.drawable.ic_play)
                }
            }
        })

        // share button
        binding.relPlayerShare.setOnClickListener {
            val shareDialog = ShareDialog(videoId!!, false)
            shareDialog.show(childFragmentManager, "ShareDialog")
        }
        // check if livestream
        if (response.duration!! > 0) {
            // download clicked
            binding.relPlayerDownload.setOnClickListener {
                if (!IS_DOWNLOAD_RUNNING) {
                    val newFragment = DownloadDialog()
                    val bundle = Bundle()
                    bundle.putString("video_id", videoId)
                    bundle.putParcelable("streams", response)
                    newFragment.arguments = bundle
                    newFragment.show(childFragmentManager, "Download")
                } else {
                    Toast.makeText(context, R.string.dlisinprogress, Toast.LENGTH_SHORT)
                        .show()
                }
            }
        } else {
            Toast.makeText(context, R.string.cannotDownload, Toast.LENGTH_SHORT).show()
        }

        if (response.hls != null) {
            binding.relPlayerVlc.setOnClickListener {
                // start an intent with video as mimetype using the hls stream
                val uri: Uri = Uri.parse(response.hls)
                val intent = Intent()

                intent.action = Intent.ACTION_VIEW
                intent.setDataAndType(uri, "video/*")
                intent.putExtra(Intent.EXTRA_TITLE, title)
                intent.putExtra("title", title)
                intent.putExtra("artist", uploader)
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)

                startActivity(intent)
            }
        }
        if (relatedStreamsEnabled) {
            // only show related streams if enabled
            binding.relatedRecView.adapter = TrendingAdapter(
                response.relatedStreams!!,
                childFragmentManager
            )
        }
        // set video description
        val description = response.description!!
        binding.playerDescription.text =
            // detect whether the description is html formatted
            if (description.contains("<") && description.contains(">")) {
                if (SDK_INT >= Build.VERSION_CODES.N) {
                    Html.fromHtml(description, Html.FROM_HTML_MODE_COMPACT)
                        .trim()
                } else {
                    Html.fromHtml(description).trim()
                }
            } else {
                description
            }

        binding.playerChannel.setOnClickListener {
            val activity = view.context as MainActivity
            val bundle = bundleOf("channel_id" to response.uploaderUrl)
            activity.navController.navigate(R.id.channelFragment, bundle)
            activity.binding.mainMotionLayout.transitionToEnd()
            binding.playerMotionLayout.transitionToEnd()
        }
        val token = PreferenceHelper.getToken(requireContext())
        if (token != "") {
            val channelId = response.uploaderUrl?.replace("/channel/", "")
            isSubscribed(binding.playerSubscribe, channelId!!)
            binding.save.setOnClickListener {
                val newFragment = AddtoPlaylistDialog()
                val bundle = Bundle()
                bundle.putString("videoId", videoId)
                newFragment.arguments = bundle
                newFragment.show(childFragmentManager, "AddToPlaylist")
            }
        }
    }

    private fun initializeChapters(chapters: List<ChapterSegment>) {
        if (chapters.isNotEmpty()) {
            binding.chaptersRecView.layoutManager =
                LinearLayoutManager(this.context, LinearLayoutManager.HORIZONTAL, false)
            binding.chaptersRecView.adapter = ChaptersAdapter(chapters, exoPlayer)
            binding.chaptersRecView.visibility = View.VISIBLE
        }
    }

    private fun setMediaSource(
        subtitle: MutableList<SubtitleConfiguration>,
        videoUri: Uri,
        audioUrl: String
    ) {
        val dataSourceFactory: DataSource.Factory =
            DefaultHttpDataSource.Factory()
        val videoItem: MediaItem = MediaItem.Builder()
            .setUri(videoUri)
            .setSubtitleConfigurations(subtitle)
            .build()
        val videoSource: MediaSource =
            DefaultMediaSourceFactory(dataSourceFactory)
                .createMediaSource(videoItem)
        val audioSource: MediaSource =
            ProgressiveMediaSource.Factory(dataSourceFactory)
                .createMediaSource(fromUri(audioUrl))
        val mergeSource: MediaSource =
            MergingMediaSource(videoSource, audioSource)
        exoPlayer.setMediaSource(mergeSource)
    }

    private fun setResolutionAndSubtitles(view: View, response: Streams) {
        val videoFormatPreference =
            PreferenceHelper.getString(requireContext(), "player_video_format", "WEBM")
        val defres = PreferenceHelper.getString(requireContext(), "default_res", "")!!

        var videosNameArray: Array<CharSequence> = arrayOf()
        var videosUrlArray: Array<Uri> = arrayOf()

        // append hls to list if available
        if (response.hls != null) {
            videosNameArray += getString(R.string.hls)
            videosUrlArray += response.hls.toUri()
        }

        for (vid in response.videoStreams!!) {
            // append quality to list if it has the preferred format (e.g. MPEG)
            if (vid.format.equals(videoFormatPreference)) { // preferred format
                videosNameArray += vid.quality!!
                videosUrlArray += vid.url!!.toUri()
            } else if (vid.quality.equals("LBRY") && vid.format.equals("MP4")) { // LBRY MP4 format)
                videosNameArray += "LBRY MP4"
                videosUrlArray += vid.url!!.toUri()
            }
        }
        // create a list of subtitles
        val subtitle = mutableListOf<SubtitleConfiguration>()
        response.subtitles!!.forEach {
            subtitle.add(
                SubtitleConfiguration.Builder(it.url!!.toUri())
                    .setMimeType(it.mimeType!!) // The correct MIME type (required).
                    .setLanguage(it.code) // The subtitle language (optional).
                    .build()
            )
        }
        // set resolution in the beginning
        when {
            // search for the default resolution in the videoNamesArray, select quality if found
            defres != "" -> {
                run lit@{
                    videosNameArray.forEachIndexed { index, pipedStream ->
                        if (pipedStream.contains(defres)) {
                            val videoUri = videosUrlArray[index]
                            val audioUrl = getMostBitRate(response.audioStreams!!)
                            setMediaSource(subtitle, videoUri, audioUrl)
                            playerBinding.qualityText.text = videosNameArray[index]
                            return@lit
                        } else if (response.hls != null) {
                            val mediaItem: MediaItem = MediaItem.Builder()
                                .setUri(response.hls)
                                .setSubtitleConfigurations(subtitle)
                                .build()
                            exoPlayer.setMediaItem(mediaItem)
                        } else {
                            Toast.makeText(
                                context,
                                getString(R.string.unknown_error),
                                Toast.LENGTH_LONG
                            ).show()
                        }
                    }
                }
            }
            // if defres doesn't match use hls if available
            response.hls != null -> {
                val mediaItem: MediaItem = MediaItem.Builder()
                    .setUri(response.hls)
                    .setSubtitleConfigurations(subtitle)
                    .build()
                exoPlayer.setMediaItem(mediaItem)
            }
            // otherwise use the first list entry
            else -> {
                val videoUri = videosUrlArray[0]
                val audioUrl = getMostBitRate(response.audioStreams!!)
                setMediaSource(subtitle, videoUri, audioUrl)
                playerBinding.qualityText.text = videosNameArray[0]
            }
        }

        playerBinding.qualitySelect.setOnClickListener {
            // Dialog for quality selection
            val builder: MaterialAlertDialogBuilder? = activity?.let {
                MaterialAlertDialogBuilder(it)
            }
            val lastPosition = exoPlayer.currentPosition
            builder!!.setTitle(R.string.choose_quality_dialog)
                .setItems(
                    videosNameArray
                ) { _, which ->
                    whichQuality = which
                    if (
                        videosNameArray[which] == getString(R.string.hls) ||
                        videosNameArray[which] == "LBRY HLS"
                    ) {
                        // no need to merge sources if using hls
                        val mediaItem: MediaItem = MediaItem.Builder()
                            .setUri(videosUrlArray[which])
                            .setSubtitleConfigurations(subtitle)
                            .build()
                        exoPlayer.setMediaItem(mediaItem)
                    } else {
                        val videoUri = videosUrlArray[which]
                        val audioUrl = getMostBitRate(response.audioStreams!!)
                        setMediaSource(subtitle, videoUri, audioUrl)
                    }
                    exoPlayer.seekTo(lastPosition)
                    playerBinding.qualityText.text = videosNameArray[which]
                }
            val dialog = builder.create()
            dialog.show()
        }
    }

    private fun createExoPlayer(view: View) {
        val playbackSpeed =
            PreferenceHelper.getString(requireContext(), "playback_speed", "1F")?.toFloat()
        // multiply by thousand: s -> ms
        val bufferingGoal =
            PreferenceHelper.getString(requireContext(), "buffering_goal", "50")?.toInt()!! * 1000
        val seekIncrement =
            PreferenceHelper.getString(requireContext(), "seek_increment", "5")?.toLong()!! * 1000

        val cronetEngine: CronetEngine = CronetHelper.getCronetEngine()
        val cronetDataSourceFactory: CronetDataSource.Factory =
            CronetDataSource.Factory(cronetEngine, Executors.newCachedThreadPool())

        val dataSourceFactory = DefaultDataSource.Factory(
            requireContext(),
            cronetDataSourceFactory
        )

        // handles the audio focus
        val audioAttributes = AudioAttributes.Builder()
            .setUsage(C.USAGE_MEDIA)
            .setContentType(C.CONTENT_TYPE_MOVIE)
            .build()

        // handles the duration of media to retain in the buffer prior to the current playback position (for fast backward seeking)
        val loadControl = DefaultLoadControl.Builder()
            // cache the last three minutes
            .setBackBuffer(1000 * 60 * 3, true)
            .setBufferDurationsMs(
                1000 * 10, // exo default is 50s
                bufferingGoal,
                DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS,
                DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS
            )
            .build()

        exoPlayer = ExoPlayer.Builder(view.context)
            .setMediaSourceFactory(DefaultMediaSourceFactory(dataSourceFactory))
            .setLoadControl(loadControl)
            .setSeekBackIncrementMs(seekIncrement)
            .setSeekForwardIncrementMs(seekIncrement)
            .build()

        exoPlayer.setAudioAttributes(audioAttributes, true)

        exoPlayer.setPlaybackSpeed(playbackSpeed!!)
    }

    private fun initializePlayerNotification(c: Context) {
        mediaSession = MediaSessionCompat(c, this.javaClass.name)
        mediaSession.apply {
            isActive = true
        }

        mediaSessionConnector = MediaSessionConnector(mediaSession)
        mediaSessionConnector.setPlayer(exoPlayer)

        playerNotification = PlayerNotificationManager
            .Builder(c, 1, "background_mode")
            .setMediaDescriptionAdapter(
                DescriptionAdapter(title, uploader, thumbnailUrl, requireContext())
            )
            .build()

        playerNotification.apply {
            setPlayer(exoPlayer)
            setUsePreviousAction(false)
            setUseStopAction(true)
            setMediaSessionToken(mediaSession.sessionToken)
        }
    }

    private fun lockPlayer(isLocked: Boolean) {
        val visibility = if (isLocked) View.VISIBLE else View.GONE
        playerBinding.exoTopBarRight.visibility = visibility
        playerBinding.exoPlayPause.visibility = visibility
        playerBinding.exoFfwdWithAmount.visibility = visibility
        playerBinding.exoRewWithAmount.visibility = visibility
        playerBinding.exoBottomBar.visibility = visibility
        playerBinding.closeImageButton.visibility = visibility
        playerBinding.exoTitle.visibility = visibility
    }

    private fun isSubscribed(button: MaterialButton, channel_id: String) {
        @SuppressLint("ResourceAsColor")
        fun run() {
            lifecycleScope.launchWhenCreated {
                val response = try {
                    val token = PreferenceHelper.getToken(requireContext())
                    RetrofitInstance.authApi.isSubscribed(
                        channel_id,
                        token
                    )
                } catch (e: IOException) {
                    println(e)
                    Log.e(TAG, "IOException, you might not have internet connection")
                    return@launchWhenCreated
                } catch (e: HttpException) {
                    Log.e(TAG, "HttpException, unexpected response")
                    return@launchWhenCreated
                }

                runOnUiThread {
                    if (response.subscribed == true) {
                        isSubscribed = true
                        button.text = getString(R.string.unsubscribe)
                    }
                    if (response.subscribed != null) {
                        button.setOnClickListener {
                            if (isSubscribed) {
                                unsubscribe(channel_id)
                                button.text = getString(R.string.subscribe)
                            } else {
                                subscribe(channel_id)
                                button.text = getString(R.string.unsubscribe)
                            }
                        }
                    }
                }
            }
        }
        run()
    }

    private fun subscribe(channel_id: String) {
        fun run() {
            lifecycleScope.launchWhenCreated {
                val response = try {
                    val token = PreferenceHelper.getToken(requireContext())
                    RetrofitInstance.authApi.subscribe(
                        token,
                        Subscribe(channel_id)
                    )
                } catch (e: IOException) {
                    println(e)
                    Log.e(TAG, "IOException, you might not have internet connection")
                    return@launchWhenCreated
                } catch (e: HttpException) {
                    Log.e(TAG, "HttpException, unexpected response$e")
                    return@launchWhenCreated
                }
                isSubscribed = true
            }
        }
        run()
    }

    private fun unsubscribe(channel_id: String) {
        fun run() {
            lifecycleScope.launchWhenCreated {
                val response = try {
                    val token = PreferenceHelper.getToken(requireContext())
                    RetrofitInstance.authApi.unsubscribe(
                        token,
                        Subscribe(channel_id)
                    )
                } catch (e: IOException) {
                    println(e)
                    Log.e(TAG, "IOException, you might not have internet connection")
                    return@launchWhenCreated
                } catch (e: HttpException) {
                    Log.e(TAG, "HttpException, unexpected response")
                    return@launchWhenCreated
                }
                isSubscribed = false
            }
        }
        run()
    }

    private fun Fragment?.runOnUiThread(action: () -> Unit) {
        this ?: return
        if (!isAdded) return // Fragment not attached to an Activity
        activity?.runOnUiThread(action)
    }

    private fun getMostBitRate(audios: List<PipedStream>): String {
        var bitrate = 0
        var index = 0
        for ((i, audio) in audios.withIndex()) {
            val q = audio.quality!!.replace(" kbps", "").toInt()
            if (q > bitrate) {
                bitrate = q
                index = i
            }
        }
        return audios[index].url!!
    }

    private fun fetchComments() {
        lifecycleScope.launchWhenCreated {
            val commentsResponse = try {
                RetrofitInstance.api.getComments(videoId!!)
            } catch (e: IOException) {
                println(e)
                Log.e(TAG, "IOException, you might not have internet connection")
                Toast.makeText(context, R.string.unknown_error, Toast.LENGTH_SHORT).show()
                return@launchWhenCreated
            } catch (e: HttpException) {
                Log.e(TAG, "HttpException, unexpected response")
                return@launchWhenCreated
            }
            commentsAdapter = CommentsAdapter(videoId!!, commentsResponse.comments)
            binding.commentsRecView.adapter = commentsAdapter
            nextPage = commentsResponse.nextpage
            commentsLoaded = true
            isLoading = false
        }
    }

    private fun fetchNextComments() {
        lifecycleScope.launchWhenCreated {
            if (!isLoading) {
                isLoading = true
                val response = try {
                    RetrofitInstance.api.getCommentsNextPage(videoId!!, nextPage!!)
                } catch (e: IOException) {
                    println(e)
                    Log.e(TAG, "IOException, you might not have internet connection")
                    return@launchWhenCreated
                } catch (e: HttpException) {
                    Log.e(TAG, "HttpException, unexpected response," + e.response())
                    return@launchWhenCreated
                }
                nextPage = response.nextpage
                commentsAdapter?.updateItems(response.comments)
                isLoading = false
            }
        }
    }

    override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
        super.onPictureInPictureModeChanged(isInPictureInPictureMode)
        if (isInPictureInPictureMode) {
            exoPlayerView.hideController()
            exoPlayerView.useController = false
            with(binding.playerMotionLayout) {
                getConstraintSet(R.id.start).constrainHeight(R.id.player, -1)
                enableTransition(R.id.yt_transition, false)
            }
            binding.mainContainer.isClickable = true
            playerBinding.exoTopBar.visibility = View.GONE
            val mainActivity = activity as MainActivity
            mainActivity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
            isFullScreen = false
        } else {
            with(binding.playerMotionLayout) {
                getConstraintSet(R.id.start).constrainHeight(R.id.player, 0)
                enableTransition(R.id.yt_transition, true)
            }
            exoPlayerView.showController()
            exoPlayerView.useController = true
            binding.mainContainer.isClickable = false
            playerBinding.exoTopBar.visibility = View.VISIBLE
        }
    }

    fun onUserLeaveHint() {
        val bounds = Rect()
        binding.playerScrollView.getHitRect(bounds)

        if (SDK_INT >= Build.VERSION_CODES.O &&
            exoPlayer.isPlaying && (binding.playerScrollView.getLocalVisibleRect(bounds) || isFullScreen)
        ) {
            activity?.enterPictureInPictureMode(updatePipParams())
        }
    }

    private fun updatePipParams() = PictureInPictureParams.Builder()
        .setActions(emptyList())
        .build()
}