// объявим нашу структуру, которая будет хранить все нужные нам данные
#[derive(Debug, Default)]
struct Render {
    // список из значений альфы
    transition: Vec<f32>,
    // 1-ая фотка в rgb24
    image1: Vec<u8>,
    // 2-я
    image2: Vec<u8>,
    // имя выходного видео
    output: String,
    // размер фото
    size: Size,
}

// структура для размера изображения
#[derive(Debug, Default, PartialEq, Eq)]
struct Size {
    width: usize,
    height: usize,
}

// с одной функцией
impl Size {
    fn new(width: usize, height: usize) -> Size {
        Size { width, height }
    }
}

impl Render {
    // 1
    pub fn first_image<P: AsRef<Path>>(mut self, filename: P) -> Render {}
    pub fn second_image<P: AsRef<Path>>(mut self, filename: P) -> Render {}
    // 2
    pub fn add_transition(mut self, start: f32, stop: f32, step: f32) -> Render {}
    // 3
    pub fn set_output_file(mut self, output: &str) -> Render {}
    // 4
    pub fn render(self, fps: u8) {}
    // 5
    fn blend(&self, alpha: f32) -> Vec<u8> {}
}

extern crate lodepng;
extern crate rgb;

use std::path::Path;
use crate::rgb::ComponentBytes;

// вспомотагельная функция по загрузке изображений
fn load_image<P: AsRef<Path>>(filename: P) -> Result<(Vec<u8>, Size), lodepng::Error> {
    // загружаем нашу pngшку
    let image = lodepng::decode24_file(filename)?;
    // заполняем структуру размера фото
    let size = Size::new(image.width, image.height);
    // возврашаем данные в нужном нам виде
    Ok((image.buffer.as_bytes().to_vec(), size))
}

pub fn first_image<P: AsRef<Path>>(mut self, filename: P) -> Render {
    // загружаем фото
    let (image, size) = load_image(filename).unwrap();
    // и заполянем наши переменные
    self.image1 = image;
    self.size = size;
    // передаём дальше нашу структуру
    self
}

pub fn second_image<P: AsRef<Path>>(mut self, filename: P) -> Render {
    let (image, size) = load_image(filename).unwrap();
    // никаких переходов в случае картинок разного размера
    if self.size != size {
        panic!("image size mismatch");
    }
    self.image2 = image;
    self
}

pub fn set_output_file(mut self, output: &str) -> Render {
    // просто передаём владение над строкой
    self.output = output.to_owned();
    self
}

pub fn add_transition(mut self, start: f32, stop: f32, step: f32) -> Render {
    // эти два варианта мы игнорируем, т.к. они расходятся
    let bad_condition = (start > stop && step > 0.0) || (start < stop && step < 0.0);
    // для всех остальных считаем количество шагов
    let count = if !bad_condition {
        ((start - stop) / step).abs() as u32 + 1
    } else {
        0
    };
    // и генерируем переход
    let mut transition: Vec<f32> = (0..count).map(|x| start + x as f32 * step).collect();
    self.transition.append(&mut transition);
    self
}

fn blend(&self, alpha: f32) -> Vec<u8> {
    // инициализируем выходной массив по размеру изображения
    let mut r = vec![0; self.image1.len()];
    // итерируемся по 3-м массивам, но r у нас будет изменяемый
    for (d, (a, b)) in r.iter_mut().zip(self.image1.iter().zip(self.image2.iter())) {
        // записываем в массив новое значение расчитанное по формуле
        *d = (*a as f32 * alpha + *b as f32 * (1.0 - alpha)).round() as u8;
    }
    // готово!
    r
}

pub fn render(self, fps: u8) {
    // аргументы для ffmpeg
    let arguments = [
        // входной формат фото
        "-f", "rawvideo", "-pix_fmt", "rgb24",
        // + размер
        "-video_size", &format!("{}x{}", self.size.width, self.size.height),
        // + fps
        "-r", &format!("{}", fps),
        // нам нужен pipe
        "-i", "-",
        // профиль кодирования видео оптимизирующий под youtube (также подходит для telegram)
        "-c:v", "libx264", "-preset", "slow", "-profile:v", "high", "-crf", "18", "-coder", "1",
        // формат картинки в видео
        "-pix_fmt", "yuv420p",
        // с размеров кратным 2-ке по высоте
        "-vf", "scale=iw:-2",
        // ещё параметры оптимизации под youtube
        "-movflags", "+faststart", "-g", "30", "-bf", "2",
        // игнорируем существующий файл + имя выходного файла
        "-y", &self.output,
    ];
    // создаём процесс
    let mut process = match Command::new("ffmpeg")
        // с аргументами
        .args(&arguments)
        // и stdin как pipe
        .stdin(Stdio::piped())
        // спавним процесс
        .spawn()
    {
        Err(why) => panic!("couldn't spawn ffmpeg: {}", why),
        Ok(process) => process,
    };
    {
        // заимствуем stdin в таком виде чтобы не захватить process
        let stdin = process.stdin.as_mut().unwrap();
        // и фигачим в него наши картиночки
        for alpha in &self.transition {
            // смешиваем в нужных пропорциях
            let img = self.blend(*alpha);
            // и записываем в pipe
            match stdin.write_all(&img) {
                Err(why) => panic!("couldn't write to ffmpeg stdin: {}", why),
                Ok(_) => (),
            };
        }
    }
    // ожидаем завершения ffmpeg
    let _result = process.wait().unwrap();
}

fn main() {
    // время ролика в секундах
    let transition_time = 5;
    // количество кадров в секунду у выходного видео
    let fps = 25;
    // шаг для создания перехода на заданное время и fps
    // 2.0, т.к. у нас будет 2 перехода
    let step = 2.0 / (fps * transition_time) as f32;
    // тут должно быть всё понятно
    let i = Render::default()
        .first_image("./demo/01.png")
        .second_image("./demo/02.png")
        // преобразование 1-ой фотографии во 2-ую
        .add_transition(0.0, 1.0, step)
        // и обратно
        .add_transition(1.0, 0.0, -step)
        .set_output_file("render.mp4");
    i.render(fps);
}