/*
    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::{stream_info, SMediaInfo};
use anyhow::{anyhow, bail, Result};
use jellybase::common::stream::StreamContainer;
use jellyremuxer::matroska_to_mpeg4;
use jellytranscoder::fragment::transcode;
use log::warn;
use std::sync::Arc;
use tokio::{fs::File, io::DuplexStream};
use tokio_util::io::SyncIoBridge;

pub async fn fragment_stream(
    mut b: DuplexStream,
    info: Arc<SMediaInfo>,
    track: usize,
    segment: usize,
    index: usize,
    format_num: usize,
    container: StreamContainer,
) -> Result<()> {
    let (iinfo, info) = stream_info(info).await?;
    let (file_index, track_num) = *iinfo
        .track_to_file
        .get(track)
        .ok_or(anyhow!("track not found"))?;
    let path = iinfo.paths[file_index].clone();
    let seg = info
        .segments
        .get(segment)
        .ok_or(anyhow!("segment not found"))?;
    let track = seg.tracks.get(track).ok_or(anyhow!("track not found"))?;
    let format = track
        .formats
        .get(format_num)
        .ok_or(anyhow!("format not found"))?;

    if format.remux {
        tokio::task::spawn_blocking(move || {
            if let Err(err) = jellyremuxer::write_fragment_into(
                SyncIoBridge::new(b),
                &path,
                track_num,
                container == StreamContainer::WebM,
                &info.name.unwrap_or_default(),
                index,
            ) {
                warn!("segment stream error: {err}");
            }
        });
    } else {
        let location = transcode(
            &format!("{path:?} {track_num} {index} {format_num} {container}"), // TODO maybe not use the entire source
            track.kind,
            format,
            move |b| {
                tokio::task::spawn_blocking(move || {
                    if let Err(err) = jellyremuxer::write_fragment_into(
                        SyncIoBridge::new(b),
                        &path,
                        track_num,
                        false,
                        &info.name.unwrap_or_default(),
                        index,
                    ) {
                        warn!("segment stream error: {err}");
                    }
                });
            },
        )
        .await?;
        eprintln!("{:?}", location.abs());
        let mut frag = File::open(location.abs()).await?;
        match container {
            StreamContainer::WebM => {}
            StreamContainer::Matroska => {
                tokio::task::spawn(async move {
                    if let Err(err) = tokio::io::copy(&mut frag, &mut b).await {
                        warn!("cannot write stream: {err}")
                    }
                });
            }
            StreamContainer::MPEG4 => {
                tokio::task::spawn_blocking(move || {
                    if let Err(err) =
                        matroska_to_mpeg4(SyncIoBridge::new(frag), SyncIoBridge::new(b))
                    {
                        warn!("mpeg4 transmux failed: {err}");
                    }
                });
            }
            _ => bail!("unsupported"),
        }
    }

    Ok(())
}