use config::Config;
use std::path::Path;
use std::process;
use std::{thread, time};
use log::{debug, info};

use crate::util::io;
use super::repository::Repository;

pub struct Transcoder {
  config: Config,
  repository: Repository,
}

impl Transcoder {
  pub fn new(config: Config, repository: Repository) -> Transcoder {
    return Transcoder{
      config: config,
      repository: repository,
    }
  }

  pub fn start(self) {
    info!("Starting transcoder...");

    loop {
      // search for files in ingest
      let ingest_files = self.repository.search_ingest();

      // check if we found any files to transcode
      if ingest_files.len() < 1 {
        info!("There were no files found in ingest to transcode; skipping run.");
      } else {
        // log that the transcoder is starting up
        info!("Found {} files in ingest to transcode. Standby...", ingest_files.len());

        // loop through each file found in ingest
        for i in ingest_files {
          let ingest_path = Path::new(&self.repository.ingest_dir).join(&i);
          if io::is_file_locked(&ingest_path.to_str().unwrap()) {
            info!("{} is currently open in another program; skipping it for this run.", &i);
            continue;
          }

          // copy the file to the archive
          self.repository.archive_file(&i);

          // perform the video transcode
          self.transcode(&i);

          // remove the source file
          self.repository.cleanup_file(&i);
        }

        // let the user know the transcode has finished
        info!("Finished transcoding. Sleeping...");
      }

      // put the loop to sleep for X minutes
      let sleep_minutes = time::Duration::from_secs((self.config.get_int("transcoder.interval").unwrap() as u64 * 60).into());
      thread::sleep(sleep_minutes);
    }
  }

  fn transcode(&self, file: &str) {
    let ingest_file = Path::new(&self.repository.ingest_dir).join(file);
    let video_format = &self.config.get_string("transcoder.video_format").unwrap();
    let output_stem = Path::new(file).file_stem().unwrap();
    let output_bits = vec![output_stem.to_str().unwrap(), &video_format];
    let output_name = output_bits.join(".");
    let output_file = Path::new(&self.repository.output_dir).join(output_name);

    let video_codec = &self.config.get_string("transcoder.video_codec").unwrap();
    info!("Transcoding {} to {} with the {} encoder.", ingest_file.display(), output_file.display(), video_codec);

    let cmd_output = process::Command::new("/usr/bin/ffmpeg")
      .arg("-i")        .arg(&*ingest_file.to_string_lossy())
      .arg("-y")
      .arg("-f")        .arg(&video_format)
      .arg("-c:v")      .arg(&video_codec)
      .arg("-s")        .arg(&self.config.get_string("transcoder.video_resolution").unwrap())
      .arg("-r")        .arg(format!("{}", self.config.get_string("transcoder.video_framerate").unwrap()))
      .arg("-vf")       .arg(format!("format={}", &self.config.get_string("transcoder.video_color").unwrap()))
      .arg("-profile:v").arg(&self.config.get_string("transcoder.video_profile").unwrap())
      .arg("-c:a")      .arg(&self.config.get_string("transcoder.audio_codec").unwrap())
      .arg(&*output_file.to_string_lossy())
      .output()
      .expect("Failed to execute command");

    assert!(cmd_output.status.success());

    let results_raw = &String::from_utf8_lossy(&cmd_output.stderr);
    debug!("{}", results_raw);
  }
}