use super::cmd;
use crate::time::{format_time, Time};
use camino::{Utf8Path as Path, Utf8PathBuf as PathBuf};
use rational::Rational;
use std::process::Command;

pub(crate) struct FfmpegInput {
	pub(crate) loop_input: bool,
	pub(crate) fps: Option<Rational>,
	pub(crate) start: Option<Time>,
	pub(crate) duration: Option<Time>,
	pub(crate) path: PathBuf
}

impl FfmpegInput {
	pub(crate) fn new(path: PathBuf) -> Self {
		Self {
			loop_input: false,
			fps: None,
			start: None,
			duration: None,
			path
		}
	}

	fn append_to_cmd(self, cmd: &mut Command) {
		if self.loop_input {
			cmd.arg("-loop").arg("1");
		}
		if let Some(fps) = self.fps {
			cmd.arg("-r").arg(fps.to_string());
		}
		if let Some(start) = self.start {
			cmd.arg("-ss").arg(format_time(start));
		}
		if let Some(duration) = self.duration {
			cmd.arg("-t").arg(format_time(duration));
		}
		cmd.arg("-i").arg(self.path);
	}
}

pub(crate) struct Ffmpeg {
	inputs: Vec<FfmpegInput>,
	output: PathBuf
}

impl Ffmpeg {
	pub fn new(output: PathBuf) -> Self {
		Self {
			inputs: Vec::new(),
			output
		}
	}

	pub fn run(self) -> anyhow::Result<()> {
		let mut cmd = cmd();
		cmd.arg("ffmpeg").arg("-hide_banner");

		// initialise a vaapi device if one exists
		let vaapi_device: PathBuf = "/dev/dri/renderD128".into();
		let vaapi = vaapi_device.exists();
		if vaapi {
			cmd.arg("-vaapi_device").arg(&vaapi_device);
		}

		// append all the inputs
		for i in self.inputs {
			i.append_to_cmd(&mut cmd);
		}

		// always try to synchronise audio
		cmd.arg("-async").arg("1");

		unimplemented!()
	}
}