dependencies {

    // media3
    implementation("androidx.media3:media3-exoplayer:1.5.1")
    implementation("androidx.media3:media3-effect:1.5.1")

    // 以下省略..
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            Media3VideoSideBlurTheme {
                MainScreen()
            }
        }
    }
}

@Composable
private fun MainScreen() {
    val context = LocalContext.current

    // ExoPlayer
    val exoPlayer = remember { ExoPlayer.Builder(context).build() }

    // PhotoPicker
    val videoPicker = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.PickVisualMedia(),
        onResult = { uri ->
            // 動画を選んだらセットして再生
            exoPlayer.setMediaItem(MediaItem.fromUri(uri ?: return@rememberLauncherForActivityResult))
            exoPlayer.prepare()
            exoPlayer.playWhenReady = true
        }
    )

    Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
        Column(
            modifier = Modifier
                .padding(innerPadding)
                .fillMaxWidth(),
            horizontalAlignment = Alignment.CenterHorizontally
        ) {

            Button(onClick = { videoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.VideoOnly)) }) {
                Text(text = "動画を選ぶ")
            }

            // アスペクト比を縦動画に
            AndroidView(
                modifier = Modifier
                    .fillMaxHeight(0.8f)
                    .aspectRatio(9 / 16f),
                factory = { SurfaceView(it) },
                update = { surfaceView ->
                    // 出力先にする
                    exoPlayer.setVideoSurfaceView(surfaceView)
                }
            )
        }
    }
}

// ExoPlayer
val exoPlayer = remember {
    ExoPlayer.Builder(context).build().apply {
        setVideoEffects(
            listOf(
                // 縦動画に
                Presentation.createForAspectRatio(9 / 16f, Presentation.LAYOUT_SCALE_TO_FIT)
            )
        )
    }
}

#version 300 es
precision highp float;

in vec2 vTexSamplingCoord;
uniform sampler2D uTexSampler;

// 出力する色
out vec4 fragColor;

void main()
{
    vec4 Color = texture( uTexSampler, vTexSamplingCoord);
    fragColor = Color;
}

fragColor = texture(uTexSampler, vTexSamplingCoord);
fragColor.g = 0.;
fragColor.b = 0.;

fragColor = texture(uTexSampler, vTexSamplingCoord);
fragColor = vec4(fragColor.r, vec3(0));

/** ExoPlayer で両端をぼかすやつ */
@UnstableApi
class Media3VideoSideBlurEffect : GlEffect {

    override fun toGlShaderProgram(context: Context, useHdr: Boolean): GlShaderProgram {
        return BlurEffectGlShaderProgram(useHdr, 1)
    }

    private class BlurEffectGlShaderProgram(
        useHighPrecisionColorComponents: Boolean,
        texturePoolCapacity: Int
    ) : BaseGlShaderProgram(useHighPrecisionColorComponents, texturePoolCapacity) {

        private val glProgram = GlProgram(VERTEX_SHADER, FRAGMENT_SHADER)
        private val identityTransformationMatrix = GlUtil.create4x4IdentityMatrix()
        private val identityTexTransformationMatrix = GlUtil.create4x4IdentityMatrix()

        private var size: Size? = null

        init {
            glProgram.setBufferAttribute(
                "aFramePosition",
                GlUtil.getNormalizedCoordinateBounds(),
                GlUtil.HOMOGENEOUS_COORDINATE_VECTOR_SIZE
            )
            // Uniform 変数を更新
            glProgram.setFloatsUniform("uTransformationMatrix", identityTransformationMatrix)
            glProgram.setFloatsUniform("uTexTransformationMatrix", identityTexTransformationMatrix)

            // アルファブレンディングを有効
            // 2回 glDrawArrays してブラーの背景の上に動画を重ねるため
            GLES20.glEnable(GLES20.GL_BLEND)
            GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA)
        }

        override fun configure(inputWidth: Int, inputHeight: Int): Size {
            val size = Size(inputWidth, inputHeight)
            // Uniform 変数でも使いたい
            this.size = size
            return size
        }

        override fun drawFrame(inputTexId: Int, presentationTimeUs: Long) {
            glProgram.use()
            // テクスチャID（映像フレーム）をセット
            glProgram.setSamplerTexIdUniform("uTexSampler", inputTexId, /* texUnitIndex= */ 0)
            // サイズを Uniform 変数に入れる
            glProgram.setFloatsUniform("vResolution", floatArrayOf(size!!.width.toFloat(), size!!.height.toFloat()))

            // 描画する。まず背景（ブラー）
            glProgram.setIntUniform("iDrawMode", 1)
            // 3倍くらいに拡大してはみ出させる
            Matrix.setIdentityM(identityTransformationMatrix, 0)
            Matrix.scaleM(identityTransformationMatrix, 0, 3.5f, 3.5f, 1f)
            glProgram.setFloatsUniform("uTransformationMatrix", identityTransformationMatrix)
            glProgram.bindAttributesAndUniforms()
            // The four-vertex triangle strip forms a quad.
            GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, /* first= */ 0, /* count= */ 4)

            // 次に最前面の動画を
            glProgram.setIntUniform("iDrawMode", 2)
            glProgram.setSamplerTexIdUniform("uTexSampler", inputTexId, /* texUnitIndex= */ 0)
            // はみ出しは戻す
            Matrix.setIdentityM(identityTransformationMatrix, 0)
            glProgram.setFloatsUniform("uTransformationMatrix", identityTransformationMatrix)
            glProgram.bindAttributesAndUniforms()
            // The four-vertex triangle strip forms a quad.
            GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, /* first= */ 0, /* count= */ 4)
        }

        companion object {

            /** バーテックスシェーダー */
            private const val VERTEX_SHADER = """#version 300 es
                in vec4 aFramePosition;
                uniform mat4 uTransformationMatrix;
                uniform mat4 uTexTransformationMatrix;
                
                out vec2 vTexSamplingCoord;
                
                void main() {
                  gl_Position = uTransformationMatrix * aFramePosition;
                  vec4 texturePosition = vec4(aFramePosition.x * 0.5 + 0.5,
                                              aFramePosition.y * 0.5 + 0.5, 0.0, 1.0);
                  vTexSamplingCoord = (uTexTransformationMatrix * texturePosition).xy;
                }    
            """

            /**
             * フラグメントシェーダー
             * thx!!!!
             * https://github.com/GameMakerDiscord/blur-shaders
             */
            private const val FRAGMENT_SHADER = """#version 300 es
                precision highp float;
                
                in vec2 vTexSamplingCoord;
                uniform sampler2D uTexSampler;
                
                // どっちを描画するか。1 = 背景(ブラー) / 2 = 最前面(ブラーしない)
                uniform int iDrawMode;
                
                // 動画のサイズ
                uniform vec2 vResolution;
                
                // ぼかし
                const int Quality = 3;
                const int Directions = 16;
                const float Pi = 6.28318530718; //pi * 2
                const float Radius = 16.0; // ぼかし具合
                
                // 出力する色
                out vec4 fragColor;
                
                void main()
                {
                    vec2 radius = Radius / vResolution.xy;
                    vec4 Color = texture( uTexSampler, vTexSamplingCoord);
                    
                    // 背景を描画するモード
                    if (iDrawMode == 1) {
                        for( float d=0.0;d<Pi;d+=Pi/float(Directions) )
                        {
                            for( float i=1.0/float(Quality);i<=1.0;i+=1.0/float(Quality) )
                            {
                                Color += texture( uTexSampler, vTexSamplingCoord+vec2(cos(d),sin(d))*radius*i);
                            }
                        }
                        Color /= float(Quality)*float(Directions)+1.0;
                        fragColor = Color;
                    }
                    
                    // 最前面の動画を描画するモード                    
                    if (iDrawMode == 2) {
                        fragColor = Color;
                    }
                }
"""
        }
    }
}

// ExoPlayer
val exoPlayer = remember {
    ExoPlayer.Builder(context).build().apply {
        setVideoEffects(
            listOf(
                // 縦動画に
                Presentation.createForAspectRatio(9 / 16f, Presentation.LAYOUT_SCALE_TO_FIT),
                // ぼかす
                Media3VideoSideBlurEffect()
            )
        )
    }
}

dependencies {

    // media3
    implementation("androidx.media3:media3-exoplayer:1.5.1")
    implementation("androidx.media3:media3-effect:1.5.1")
    // transformer
    implementation("androidx.media3:media3-transformer:1.5.1")
    implementation("androidx.media3:media3-common:1.5.1")

    // 以下省略...

// media3-transformer 用
val scope = rememberCoroutineScope()
val transformVideoPicker = rememberLauncherForActivityResult(
    contract = ActivityResultContracts.PickVisualMedia(),
    onResult = { uri ->
        uri ?: return@rememberLauncherForActivityResult
        // 動画の一時保存先
        val tempVideoFile = context.getExternalFilesDir(null)!!.resolve("VideoSideBlur_${System.currentTimeMillis()}.mp4")
        val inputMediaItem = MediaItem.fromUri(uri)
        val editedMediaItem = EditedMediaItem.Builder(inputMediaItem).apply {
            setEffects(
                Effects(
                    /* audioProcessors = */ emptyList(),
                    /* videoEffects = */ listOf(
                        // 縦動画に
                        Presentation.createForAspectRatio(9 / 16f, Presentation.LAYOUT_SCALE_TO_FIT),
                        // ぼかす
                        Media3VideoSideBlurEffect()
                    )
                )
            )
        }.build()
        val transformer = Transformer.Builder(context).apply {
            setVideoMimeType(MimeTypes.VIDEO_H264)
            addListener(object : Transformer.Listener {
                // 完了した
                override fun onCompleted(composition: Composition, exportResult: ExportResult) {
                    super.onCompleted(composition, exportResult)
                    // 端末の動画フォルダに移動させる
                    val contentValues = contentValuesOf(
                        MediaStore.Video.Media.DISPLAY_NAME to tempVideoFile.name,
                        MediaStore.Video.Media.RELATIVE_PATH to "${Environment.DIRECTORY_MOVIES}/VideoSideBlur"
                    )
                    val copyToUri = context.contentResolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues)!!
                    context.contentResolver.openOutputStream(copyToUri)?.use { outputStream ->
                        tempVideoFile.inputStream().use { inputStream ->
                            inputStream.copyTo(outputStream)
                        }
                    }
                    tempVideoFile.delete()
                    Toast.makeText(context, "おわり", Toast.LENGTH_SHORT).show()
                }
            })
        }.build()
        transformer.start(editedMediaItem, tempVideoFile.path)
    }
)
Button(onClick = { transformVideoPicker.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.VideoOnly)) }) {
    Text(text = "ぼかした動画を動画ファイルにする")
}