use super::{cmd, filter::Filter};
use crate::{
	render::filter::channel,
	time::{format_time, Time}
};
use anyhow::bail;
use camino::{Utf8Path as Path, Utf8PathBuf as PathBuf};
use rational::Rational;
use std::{borrow::Cow, process::Command};

pub(crate) struct FfmpegInput {
	pub(crate) concat: bool,
	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 {
			concat: false,
			loop_input: false,
			fps: None,
			start: None,
			duration: None,
			path
		}
	}

	fn append_to_cmd(self, cmd: &mut Command) {
		if self.concat {
			cmd.arg("-f").arg("concat").arg("-safe").arg("0");
		}
		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>,
	filters: Vec<Filter>,
	filters_output: Cow<'static, str>,
	loudnorm: bool,
	output: PathBuf,

	filter_idx: usize
}

impl Ffmpeg {
	pub fn new(output: PathBuf) -> Self {
		Self {
			inputs: Vec::new(),
			filters: Vec::new(),
			filters_output: "0".into(),
			loudnorm: false,
			output,

			filter_idx: 0
		}
	}

	pub fn add_input(&mut self, input: FfmpegInput) -> &mut Self {
		self.inputs.push(input);
		self
	}

	pub fn add_filter(&mut self, filter: Filter) -> &mut Self {
		assert!(!self.loudnorm);
		self.filters.push(filter);
		self
	}

	pub fn set_filter_output<T: Into<Cow<'static, str>>>(
		&mut self,
		output: T
	) -> &mut Self {
		self.filters_output = output.into();
		self
	}

	pub fn enable_loudnorm(&mut self) -> &mut Self {
		assert!(self.filters.is_empty());
		self.loudnorm = true;
		self
	}

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

		// determine whether the video need to be re-encoded
		let venc = self.filters.iter().any(|f| f.is_video_filter());
		let aenc = self.filters.iter().any(|f| f.is_audio_filter()) || self.loudnorm;

		// initialise a vaapi device if one exists
		let vaapi_device: PathBuf = "/dev/dri/renderD128".into();
		let vaapi = venc && 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");

		// TODO apply filters
		match (self.loudnorm, self.filters) {
			(true, f) if f.is_empty() => {
				cmd.arg("-af").arg("pan=mono|c0=FR,loudnorm,pan=stereo|c0=c0|c1=c0,aformat=sample_rates=48000");
			},
			(true, _) => panic!("Filters and loudnorm at the same time is not supported"),

			(false, f) if f.is_empty() => {},
			(false, f) => {
				let mut complex = String::new();
				for filter in f {
					filter.append_to_complex_filter(&mut complex, &mut self.filter_idx);
				}
				cmd.arg("-filter_complex").arg(complex);
				cmd.arg("-map").arg(channel('v', &self.filters_output));
				cmd.arg("-map").arg(channel('a', &self.filters_output));
			}
		}

		// append encoding options
		if vaapi {
			cmd.arg("-c:v").arg("h264_vaapi");
			cmd.arg("-rc_mode").arg("CQP");
			cmd.arg("-global_quality").arg("22");
		} else if venc {
			cmd.arg("-c:v").arg("libx264");
			cmd.arg("-crf").arg("22");
		} else {
			cmd.arg("-c:v").arg("copy");
		}
		if aenc {
			cmd.arg("-c:a").arg("aac");
			cmd.arg("-b:a").arg("128000");
		} else {
			cmd.arg("-c:a").arg("copy");
		}

		cmd.arg(&self.output);
		let status = cmd.status()?;
		if status.success() {
			Ok(())
		} else {
			bail!("ffmpeg failed with exit code {:?}", status.code())
		}
	}
}