[dependencies]
libffmpeg = { git = "https://github.com/charliethomson/libffmpeg" }
tokio = { version = "1.47", features = ["rt", "process", "sync", "time", "macros"] }
tokio-util = { version = "0.7" }
anyhow = "1"
clap = { version = "4", features = ["derive"] }
humansize = "2"
humantime = "2"

use std::{path::PathBuf, time::Duration};
use clap::Parser;
use libffmpeg::ffmpeg::ffmpeg;
use tokio_util::{future::FutureExt, sync::CancellationToken};

#[derive(Debug, Parser)]
struct Args {
    /// Input video file path
    #[arg(short, long)]
    input: PathBuf,

    /// Output video file path
    #[arg(short, long)]
    output: PathBuf,

    /// Optional duration limit in seconds
    #[arg(short, long)]
    time: Option<u64>,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let args = Args::parse();

    // Create cancellation tokens
    let root_token = CancellationToken::new();
    let transcode_token = root_token.child_token();
    let exit_token = root_token.child_token();

    // Setup Ctrl+C handler (requires libsignal crate)
    // For this quickstart, we'll handle cancellation manually
    tokio::spawn({
        let root_token = root_token.clone();
        async move {
            tokio::signal::ctrl_c().await.ok();
            println!("\nReceived Ctrl+C, cancelling...");
            root_token.cancel();
        }
    });

    // Get video duration using ffprobe
    println!("Analyzing input file...");
    let video_duration = libffmpeg::util::get_duration(
        &args.input, 
        root_token.child_token()
    ).await?;
    
    let total = args.time.unwrap_or(video_duration.as_secs()) as f64;
    println!("Duration: {:.2}s\n", total);

    // Create command monitor for stdout/stderr streaming
    let monitor = libffmpeg::libcmd::CommandMonitor::with_capacity(100);

    // Spawn progress monitoring task
    let monitor_fut = {
        let mut client = monitor.client.clone();
        let exit_token = exit_token.clone();
        tokio::spawn(async move {
            let mut progress = libffmpeg::ffmpeg::progress::PartialProgress::default();

            while let Some(Some(delivery)) = 
                client.recv().with_cancellation_token(&exit_token).await 
            {
                match delivery {
                    libffmpeg::libcmd::CommandMonitorMessage::Stdout { line } => {
                        // Try to parse as progress update
                        if !progress.with_line(&line) {
                            println!("[stdout] {}", line);
                            continue;
                        }

                        // Print structured progress
                        if let Some(update) = progress.finish() {
                            let percent = 100.0 * update.out_time.as_secs_f64() / total;
                            println!(
                                "[Progress] {:.1}% | {} / {} | {} @ {:.0}fps ({:.1}x realtime)",
                                percent,
                                humantime::format_duration(update.out_time),
                                humantime::format_duration(Duration::from_secs_f64(total)),
                                humansize::format_size_i(
                                    update.bitrate,
                                    humansize::DECIMAL.suffix("ps")
                                ),
                                update.fps,
                                update.speed,
                            );
                        }
                    }
                    libffmpeg::libcmd::CommandMonitorMessage::Stderr { line } => {
                        eprintln!("[stderr] {}", line);
                    }
                }
            }
        })
    };

    // Run ffmpeg with monitoring
    println!("Starting transcode...\n");
    let result = ffmpeg(transcode_token, &monitor.server, |cmd| {
        cmd.arg("-i").arg(&args.input);
        cmd.arg("-t").arg(total.to_string());
        cmd.arg("-c:v").arg("libx264");
        cmd.arg("-preset").arg("fast");
        cmd.arg("-crf").arg("23");
        cmd.arg("-c:a").arg("aac");
        cmd.arg("-b:a").arg("128k");
        cmd.arg("-progress").arg("pipe:1");
        cmd.arg("-y");
        cmd.arg(&args.output);
    }).await?;

    // Stop the monitor
    exit_token.cancel();
    if let Err(e) = monitor_fut.await {
        eprintln!("Failed to wait for monitor: {}", e);
    }

    // Check result
    println!("\n");
    if result.exit_code
        .as_ref()
        .map(|exit| exit.success)
        .unwrap_or_default() 
    {
        println!("✓ Transcoding completed successfully!");
        println!("Output saved to: {}", args.output.display());
    } else {
        println!("✗ Transcoding failed");
        if let Some(code) = result.exit_code {
            println!("Exit code: {:?}", code.code);
        }
    }

    Ok(())
}