/*
    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
    Copyright (C) 2025 metamuffin <metamuffin.org>
*/

use crate::LOCAL_VIDEO_TRANSCODING_TASKS;
use jellybase::{
    cache::{async_cache_file, CachePath},
    common::stream::{StreamContainer, StreamFormatInfo, TrackKind},
    CONF,
};
use log::{debug, info};
use std::process::Stdio;
use tokio::{
    io::copy,
    process::{ChildStdin, Command},
};

// TODO odd video resolutions can cause errors when transcoding to YUV42{0,2}
// TODO with an implementation that cant handle it (SVT-AV1 is such an impl).

pub async fn transcode(
    key: &str,
    kind: TrackKind,
    format: &StreamFormatInfo,
    container: StreamContainer,
    input: impl FnOnce(ChildStdin),
) -> anyhow::Result<CachePath> {
    async_cache_file(
        &["frag-tc", key, &format!("{format:?}")],
        move |mut output| async move {
            let _permit = LOCAL_VIDEO_TRANSCODING_TASKS.acquire().await?;
            debug!("transcoding fragment with {format:?}");

            let template = match format.codec.as_str() {
                "V_AVC" => CONF.encoders.avc.as_ref(),
                "V_HEVC" => CONF.encoders.hevc.as_ref(),
                "V_VP8" => CONF.encoders.vp8.as_ref(),
                "V_VP9" => CONF.encoders.vp9.as_ref(),
                "V_AV1" => CONF.encoders.av1.as_ref(),
                _ => None,
            }
            .or(CONF.encoders.generic.as_ref())
            .cloned()
            .unwrap_or("ffmpeg %i %f %e %o".to_owned());

            let filter = match kind {
                TrackKind::Video => format!("-vf scale={}:-1", format.width.unwrap()),
                TrackKind::Audio => format!(""),
                TrackKind::Subtitle => String::new(),
            };
            let typechar = match kind {
                TrackKind::Video => "v",
                TrackKind::Audio => "a",
                TrackKind::Subtitle => "s",
            };
            let fallback_encoder = match format.codec.as_str() {
                "A_OPUS" => "libopus",
                _ => unreachable!(),
            };

            let args = template
                .replace("%i", "-f matroska -i pipe:0")
                .replace("%o", "-f %C pipe:1")
                .replace("%f", &filter)
                .replace("%e", "-c:%t %c -b:%t %r")
                .replace("%t", typechar)
                .replace("%c", fallback_encoder)
                .replace("%r", &(format.bitrate as i64).to_string())
                .replace("%C", &container.to_string());

            info!("encoding with {:?}", args);

            let container = match container {
                StreamContainer::WebM => "webm",
                StreamContainer::Matroska => "matroska",
                StreamContainer::WebVTT => "vtt",
                StreamContainer::MPEG4 => "mp4",
                StreamContainer::JVTT => unreachable!(),
            };

            let mut proc = Command::new("ffmpeg")
                .stdin(Stdio::piped())
                .stdout(Stdio::piped())
                .args(["-f", "matroska", "-i", "pipe:0"])
                .args(args.split(" "))
                .args(["-f", container, "pipe:1"])
                .spawn()?;

            let stdin = proc.stdin.take().unwrap();
            let mut stdout = proc.stdout.take().unwrap();

            input(stdin);
            copy(&mut stdout, &mut output).await?;

            proc.wait().await.unwrap().exit_ok()?;
            info!("done");
            Ok(())
        },
    )
    .await
}