package com.suno.android.preview

import android.os.Looper
import android.view.Surface
import android.view.SurfaceHolder
import android.view.SurfaceView
import android.view.TextureView
import androidx.annotation.OptIn
import androidx.media3.common.AudioAttributes
import androidx.media3.common.DeviceInfo
import androidx.media3.common.MediaItem
import androidx.media3.common.MediaMetadata
import androidx.media3.common.PlaybackException
import androidx.media3.common.PlaybackParameters
import androidx.media3.common.Player
import androidx.media3.common.Timeline
import androidx.media3.common.TrackSelectionParameters
import androidx.media3.common.Tracks
import androidx.media3.common.VideoSize
import androidx.media3.common.text.CueGroup
import androidx.media3.common.util.Size
import androidx.media3.common.util.UnstableApi
import org.jetbrains.annotations.TestOnly
import kotlin.time.Duration
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Duration.Companion.seconds

@TestOnly
fun Player.xFake(
    playTime: Duration = 14.seconds,
    duration: Duration = 2.minutes + 47.seconds,
) = FakePlayer(
    playTime = playTime,
    duration = duration,
)

@TestOnly
@OptIn(UnstableApi::class)
@Suppress("TooManyFunctions")
class FakePlayer(
    private val playTime: Duration = 14.seconds,
    private val duration: Duration = 2.minutes + 47.seconds,
) : Player {
    override fun getCurrentPosition(): Long = playTime.inWholeMilliseconds
    override fun getDuration(): Long = duration.inWholeMilliseconds

    override fun getApplicationLooper(): Looper = Looper.getMainLooper()

    override fun isCommandAvailable(
        command: Int,
    ): Boolean = true

    override fun canAdvertiseSession(): Boolean = false

    override fun getAvailableCommands(): Player.Commands =
        Player.Commands.Builder()
            .addAllCommands()
            .build()

    override fun getPlaybackState(): Int = Player.STATE_IDLE

    override fun getPlaybackSuppressionReason(): Int = Player.PLAYBACK_SUPPRESSION_REASON_NONE

    override fun isPlaying(): Boolean = false

    override fun getPlayerError(): PlaybackException? = null

    override fun getPlayWhenReady(): Boolean = false

    override fun getRepeatMode(): Int = Player.REPEAT_MODE_OFF

    override fun getShuffleModeEnabled(): Boolean = false

    override fun isLoading(): Boolean = false

    override fun getSeekBackIncrement(): Long = 5000

    override fun getSeekForwardIncrement(): Long = 5000

    override fun hasPreviousMediaItem(): Boolean = false

    override fun getMaxSeekToPreviousPosition(): Long = 5000

    override fun hasNextMediaItem(): Boolean = false

    override fun getPlaybackParameters(): PlaybackParameters = PlaybackParameters.DEFAULT

    override fun getCurrentTracks(): Tracks = Tracks.EMPTY

    override fun getTrackSelectionParameters(): TrackSelectionParameters =
        TrackSelectionParameters.DEFAULT_WITHOUT_CONTEXT

    override fun getMediaMetadata(): MediaMetadata = MediaMetadata.EMPTY

    override fun getPlaylistMetadata(): MediaMetadata = MediaMetadata.EMPTY

    override fun getCurrentManifest(): Any? = null

    override fun getCurrentTimeline(): Timeline = Timeline.EMPTY

    override fun getCurrentPeriodIndex(): Int = 0

    override fun getCurrentWindowIndex(): Int = 0

    override fun getCurrentMediaItemIndex(): Int = 0

    override fun getNextWindowIndex(): Int = -1

    override fun getNextMediaItemIndex(): Int = -1

    override fun getPreviousWindowIndex(): Int = -1

    override fun getPreviousMediaItemIndex(): Int = -1

    override fun getCurrentMediaItem(): MediaItem? = null

    override fun getMediaItemCount(): Int = 0

    override fun getMediaItemAt(
        index: Int,
    ): MediaItem = MediaItem.EMPTY

    override fun getBufferedPosition(): Long = 0

    override fun getBufferedPercentage(): Int = 0

    override fun getTotalBufferedDuration(): Long = 0

    override fun isCurrentWindowDynamic(): Boolean = false

    override fun isCurrentMediaItemDynamic(): Boolean = false

    override fun isCurrentWindowLive(): Boolean = false

    override fun isCurrentMediaItemLive(): Boolean = false

    override fun getCurrentLiveOffset(): Long = 0

    override fun isCurrentWindowSeekable(): Boolean = false

    override fun isCurrentMediaItemSeekable(): Boolean = false

    override fun isPlayingAd(): Boolean = false

    override fun getCurrentAdGroupIndex(): Int = -1

    override fun getCurrentAdIndexInAdGroup(): Int = -1

    override fun getContentDuration(): Long = 0

    override fun getContentPosition(): Long = 0

    override fun getContentBufferedPosition(): Long = 0

    override fun getAudioAttributes(): AudioAttributes = AudioAttributes.DEFAULT

    override fun getVolume(): Float = 1.0f

    override fun getVideoSize(): VideoSize = VideoSize(1080, 1920)

    override fun getSurfaceSize(): Size = Size(1080, 1920)

    override fun getCurrentCues(): CueGroup = CueGroup.EMPTY_TIME_ZERO

    override fun getDeviceInfo(): DeviceInfo = DeviceInfo.UNKNOWN

    override fun getDeviceVolume(): Int = 50

    override fun isDeviceMuted(): Boolean = false

    override fun addListener(
        listener: Player.Listener,
    ) {}

    override fun removeListener(
        listener: Player.Listener,
    ) {}

    override fun setMediaItems(
        mediaItems: MutableList<MediaItem>,
    ) {}

    override fun setMediaItems(
        mediaItems: MutableList<MediaItem>,
        resetPosition: Boolean,
    ) {}

    override fun setMediaItems(
        mediaItems: MutableList<MediaItem>,
        startIndex: Int,
        startPositionMs: Long,
    ) {}

    override fun setMediaItem(
        mediaItem: MediaItem,
    ) {}

    override fun setMediaItem(
        mediaItem: MediaItem,
        startPositionMs: Long,
    ) {}

    override fun setMediaItem(
        mediaItem: MediaItem,
        resetPosition: Boolean,
    ) {}

    override fun addMediaItem(
        mediaItem: MediaItem,
    ) {}

    override fun addMediaItem(
        index: Int,
        mediaItem: MediaItem,
    ) {}

    override fun addMediaItems(
        mediaItems: MutableList<MediaItem>,
    ) {}

    override fun addMediaItems(
        index: Int,
        mediaItems: MutableList<MediaItem>,
    ) {}

    override fun moveMediaItem(
        currentIndex: Int,
        newIndex: Int,
    ) {}

    override fun moveMediaItems(
        fromIndex: Int,
        toIndex: Int,
        newIndex: Int,
    ) {}

    override fun replaceMediaItem(
        index: Int,
        mediaItem: MediaItem,
    ) {}

    override fun replaceMediaItems(
        fromIndex: Int,
        toIndex: Int,
        mediaItems: MutableList<MediaItem>,
    ) {}

    override fun removeMediaItem(
        index: Int,
    ) {}

    override fun removeMediaItems(
        fromIndex: Int,
        toIndex: Int,
    ) {}

    override fun clearMediaItems() {}

    override fun prepare() {}

    override fun play() {}

    override fun pause() {}

    override fun setPlayWhenReady(
        playWhenReady: Boolean,
    ) {}

    override fun setRepeatMode(
        repeatMode: Int,
    ) {}

    override fun setShuffleModeEnabled(
        shuffleModeEnabled: Boolean,
    ) {}

    override fun seekToDefaultPosition() {}

    override fun seekToDefaultPosition(
        mediaItemIndex: Int,
    ) {}

    override fun seekTo(
        positionMs: Long,
    ) {}

    override fun seekTo(
        mediaItemIndex: Int,
        positionMs: Long,
    ) {}

    override fun seekBack() {}

    override fun seekForward() {}

    override fun seekToPreviousMediaItem() {}

    override fun seekToPrevious() {}

    override fun seekToNextMediaItem() {}

    override fun seekToNext() {}

    override fun setPlaybackParameters(
        playbackParameters: PlaybackParameters,
    ) {}

    override fun setPlaybackSpeed(
        speed: Float,
    ) {}

    override fun stop() {}

    override fun release() {}

    override fun setTrackSelectionParameters(
        parameters: TrackSelectionParameters,
    ) {}

    override fun setPlaylistMetadata(
        mediaMetadata: MediaMetadata,
    ) {}

    override fun setVolume(
        volume: Float,
    ) {}

    override fun clearVideoSurface() {}

    override fun clearVideoSurface(
        surface: Surface?,
    ) {}

    override fun setVideoSurface(
        surface: Surface?,
    ) {}

    override fun setVideoSurfaceHolder(
        surfaceHolder: SurfaceHolder?,
    ) {}

    override fun clearVideoSurfaceHolder(
        surfaceHolder: SurfaceHolder?,
    ) {}

    override fun setVideoSurfaceView(
        surfaceView: SurfaceView?,
    ) {}

    override fun clearVideoSurfaceView(
        surfaceView: SurfaceView?,
    ) {}

    override fun setVideoTextureView(
        textureView: TextureView?,
    ) {}

    override fun clearVideoTextureView(
        textureView: TextureView?,
    ) {}

    override fun setDeviceVolume(
        volume: Int,
    ) {}

    override fun setDeviceVolume(
        volume: Int,
        flags: Int,
    ) {}

    override fun increaseDeviceVolume() {}

    override fun increaseDeviceVolume(
        flags: Int,
    ) {}

    override fun decreaseDeviceVolume() {}

    override fun decreaseDeviceVolume(
        flags: Int,
    ) {}

    override fun setDeviceMuted(
        muted: Boolean,
    ) {}

    override fun setDeviceMuted(
        muted: Boolean,
        flags: Int,
    ) {}

    override fun setAudioAttributes(
        audioAttributes: AudioAttributes,
        handleAudioFocus: Boolean,
    ) {}
}