private enum class MediaCodecState {
    UNINITIALIZED, // 调用 reset 或者 stop 时进入
    RUNNING, // 首次 dequeue Input(Output) Buffer 成功时进入
    END_OF_STREAM,  // Output Buffer 结束时进入
    ERROR, // 遇见错误时进入
    RELEASED, // 调用 release 时进入
    PAUSED, // 自定义状态，非 MediaCodec 标准状态，用于暂停场景
    RESET, //  自定义状态，非 MediaCodec 标准状态，用于重置场景
    FLUSHED, // 自定义状态，非 MediaCodec 标准状态，用于清除缓存
}

/**
 * Video 需要用到 Surface
 * Audio 需要输出到 AudioTrack
 * */
fun decode(context: Context, surface: Surface? = null) {
    try {
        // 1. 配置 HardwareDecoder
        if (!configMedia(context)) {
            return
        }
        // 2. 配置音频和视频的差异项
        if (isVideo) {
            this.surface = surface
        } else {
            if (audioTrack == null) {
                this.audioTrack = createAndConfigAudioPlayer()
            }
        }
        // 3. 创建 MediaCodec，并开始解码
        createAndDecode()
        // 解码完成，释放资源
        release()
    } catch (e: Exception) {
        LogUtil.e(TAG, e)
        state = MediaCodecState.ERROR
    }
}

// 先定义格式信息
data class HardwareMediaInfo(
    val mimeType: String,
    val trackIndex: Int,
    val mediaFormat: MediaFormat?,
)

private fun configMedia(context: Context): Boolean {
    // 1. 获取 MediaExtractor 实例
    var mExtractor: MediaExtractor = MediaExtractor()
    // 2. 配置 MediaExtractor，传入 mp4 文件的 fileUri
    mExtractor.setDataSource(context, fileUri, null)
    // 3. 找到音视频相关信息
    mediaInfo = findMediaFormat()

    if (mediaInfo!!.trackIndex < 0 || mediaInfo!!.mediaFormat == null) {
        return false
    }
    // 4. 选中对应的轨道
    mExtractor.selectTrack(mediaInfo!!.trackIndex)

    return true
}

fun findMediaFormat(): HardwareMediaInfo {
    // 定义 mimeType 前缀
    val prefix = if (isVideo) {
        "video/"
    } else {
        "audio/"
    }
    // 读取 mp4 所有的音视频轨道，并拿到目标数据
    (0 until mExtractor.trackCount).forEach {
        val format = mExtractor.getTrackFormat(it)
        val mimeType = format.getString(MediaFormat.KEY_MIME) ?: ""
        if (mimeType.startsWith(prefix)) {
            // 找到目标格式的数据信息，返回 mimeType、trackIndex 和 MediaFormat
            return HardwareMediaInfo(mimeType, it, format)
        }
    }

    return HardwareMediaInfo("", -1, null)
}

private fun createAndConfigAudioPlayer(): AudioTrack {
    // 创建音频播放器
    // 1. 获取 minBufferSize
    val minBufferSize = AudioTrack.getMinBufferSize(
        mediaInfo!!.sampleRate,
        mediaInfo!!.voiceTrack,
        mediaInfo!!.sampleDepth
    )
    // 说明 https://stackoverflow.com/questions/50866991/android-audiotrack-playback-fast
    // 2. 生成 AudioTrack 实例
    val audioTrack = AudioTrack(
        AudioAttributes.Builder()
            .setUsage(AudioAttributes.USAGE_MEDIA)
            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
            .build(),
        AudioFormat.Builder()
            .setSampleRate(mediaInfo!!.sampleRate)
            .setChannelMask(mediaInfo!!.voiceTrack)
            .setEncoding(mediaInfo!!.sampleDepth)
            .build(),
        minBufferSize,
        AudioTrack.MODE_STREAM,
        AudioManager.AUDIO_SESSION_ID_GENERATE
    )
    // 3. 准备播放，此时不会播放，因为没有数据传入
    audioTrack.play()
    //updatePlayState(audioTrack) TODO 此行代码暂未用上，保留着用以说明 AudioTrack 的状态转换逻辑

    return audioTrack
}

private fun createAndDecode() = try {
    // 创建解码器
    create()
    // 开始解码
    startDecode()
} catch (e: Exception) {
    LogUtil.e(TAG, e)
    state = MediaCodecState.ERROR
}

fun create() {
    if (decoder == null) {
        // 根据 mimeType 创建 MediaCodec 实例
        decoder = MediaCodec.createDecoderByType(
            mediaInfo?.mimeType ?: ""
        )
    }
    state = MediaCodecState.UNINITIALIZED
}

fun prepare() {
    if (state != MediaCodecState.UNINITIALIZED) {
        LogUtil.e(TAG, "can not prepare decoder which not in uninitialized state")
        return
    }
    // 解码音频不需要 surface，surface 为 null
    decoder?.configure(mediaInfo?.mediaFormat, surface, null, 0)
    decoder?.start()
}

/**
 * 原始数据写入解码器，返回值表示编码数据是否全部读取完成
 * */
private fun MediaCodec.inputData(mExtractor: MediaExtractor?): Boolean? {
    // 1. dequeue: 出列，拿到一个输入缓冲区的index，-1表示暂时没有可用的
    val inputBufferIndex = dequeueInputBuffer(TIMEOUT)
    if (inputBufferIndex < 0) {
        LogUtil.d(TAG, "isVideo = $isVideo, inputBufferIndex = $inputBufferIndex")
        return null
    }

    if (state != MediaCodecState.RUNNING) {
        state = MediaCodecState.RUNNING
    }

    // 2. 使用返回的 inputBuffer 的 index 得到一个 ByteBuffer，可以放数据了
    val inputBuffer = getInputBuffer(inputBufferIndex) ?: return null

    // 3. 往 InputBuffer 里面写入数据。返回的是写入的实际数据量，-1 表示已全部写入
    val sampleSize = mExtractor?.readSampleData(inputBuffer, 0) ?: -1
    // 4. 数据入队
    return if (sampleSize >= 0) {
        // 数据已填充入 InputBuffer，分别设置 size 和 sampleTime
        // 这里 sampleTime 不一定是顺序来的，所以需要缓冲区来调节顺序
        queueInputBuffer(
            inputBufferIndex, 
            0, 
            sampleSize, 
            mExtractor?.sampleTime ?: 0, 
            0
        )
        // 在 MediaExtractor 执行完一次 readSampleData 方法后，
        // 需要调用 advance() 去跳到下一个 sample，
        // 然后再次读取数据(读取下次采样视频帧)
        mExtractor?.advance()
        false
    } else {
        // 数据读完，入队结束
        queueInputBuffer(inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
        true
    }
}

/**
 * 从解码器获取解码后的音频数据
 * */
private fun MediaCodec.outputData(startTime: Long): Boolean? {
    val bufferInfo = MediaCodec.BufferInfo()
    // 等待 50 豪秒
    val outputBufferIndex = dequeueOutputBuffer(bufferInfo, TIMEOUT)
    if (outputBufferIndex >= 0) {
        if (!isVideo) {
            // 解码音频，数据需要放入 AudioTrack 中
            val byteBuffer = getOutputBuffer(outputBufferIndex) ?: return null
            val pcmData = ByteArray(bufferInfo.size)

            // 读取缓存到数组
            byteBuffer.position(0)
            byteBuffer.get(pcmData, 0, bufferInfo.size)
            byteBuffer.clear()
            // audioTrack.write(pcmData, 0, audioBufferInfo.size);//用这个写法会导致少帧？
            // 数据写入播放器
            audioTrack?.write(pcmData, bufferInfo.offset, bufferInfo.offset + bufferInfo.size)
        }
        currentSampleTime = bufferInfo.presentationTimeUs / 1000
        // 直接渲染到 Surface 时使用不到 outputBuffer
        // ByteBuffer outputBuffer = videoCodec.getOutputBuffer(outputBufferIndex);
        // 如果缓冲区里的展示时间(PTS) > 当前音频播放的进度，就休眠一下(音频解析过快，需要缓缓)
        sleep(bufferInfo, startTime)
        // 将该ByteBuffer释放掉，以供缓冲区的循环使用
        releaseOutputBuffer(outputBufferIndex, true)
    }

    // outputBufferIndex < 0 时需要检查是否解码完成
    return if (bufferInfo.flags.and(MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
        state = MediaCodecState.END_OF_STREAM
        true
    } else {
        false
    }
}

private fun startDecode() {
    // 配置并开始解码，音频的 surface 为空
    prepare()
    start()

    var inputDone = false
    var outputDone = false

    while (!outputDone) {
        // 没有输出了，退出循环
        if (state == MediaCodecState.END_OF_STREAM) {
            break
        }
        // 暂停时不处理数据的输入输出
        if (state == MediaCodecState.PAUSED) {
            continue
        }
        if (state == MediaCodecState.RESET) {
            // 退到 0 帧处重新开始
            seekTo(0)
        }
        if (state == MediaCodecState.FLUSHED) {
            decoder?.flush()
            audioTrack?.flush()
        }
        // startMs time 随时可改，不能保证线程安全，此处赋值一次，保证一个输入输出内，startTime 值不变
        val nowStartTime = startMs
        // 将资源传递到解码器
        if (!inputDone) {
            inputDone = decoder?.inputData(mExtractor) ?: inputDone
        }
        // 从 codec 读取数据
        outputDone = decoder?.outputData(nowStartTime) ?: outputDone
    }
}

// 调到指定位置，单位 毫秒
fun seekTo(time: Long) {
    mExtractor.seekTo(time * 1000, MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
    // 主要用于音视频同步
    startMs += (currentSampleTime - time)
    state = MediaCodecState.FLUSHED
}

private fun sleep(mediaBufferInfo: MediaCodec.BufferInfo, decodeStartTime: Long) {
    // videoBufferInfo.presentationTimeUs / 1000  PTS 视频的展示时间戳(相对时间)
    val fastForwardTime = mediaBufferInfo.presentationTimeUs / 1000 + decodeStartTime - System.currentTimeMillis()
    if (fastForwardTime > 0) {
        // 音视频解析快了
        Thread.sleep(fastForwardTime)
    }
}

withContext(Dispatchers.IO) {
    // 同步时间，用于音频、视频 PTS 同步校准
    val startTime = System.currentTimeMillis()
    videoDecoder?.startMs = startTime
    audioDecoder?.startMs = startTime
    // 音频和视频的解析同步进行
    launch { videoDecoder?.decode(activity, surface) }
    launch { audioDecoder?.decode(activity) }
}

// 调到指定位置，单位 毫秒
fun seekTo(time: Long) {
    mExtractor.seekTo(time * 1000, MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
    // 调整开始时间，用于音视频同步
    startMs += (currentSampleTime - time) // 等价于 System.currentTimeMillis() - time
    state = MediaCodecState.FLUSHED
}

// 恢复解码
fun resume() {
    // 暂停后恢复了，音频解析慢了，startTime 加上差值对齐时间戳。否则视频视频播放会过快
    startMs = System.currentTimeMillis() - currentSampleTime
    state = MediaCodecState.RUNNING
}