use lvc::{diff::{diff, fast_diff}, Frame, Pixel, Ref, View, P2, PixelValue};
use std::{
    io::{stdin, stdout, BufReader, BufWriter, Read, Write},
    time::Instant,
};

fn main() {
    let size = P2 { x: 1920, y: 1080 };

    // let frame1 = read_frame(size);
    // let frame2 = read_frame(size);

    // encode(&frame1, &frame2, View::all(size));

    let mut last_frame = Frame {
        pixels: vec![Pixel::default(); size.area()],
        size,
    };

    let mut stdin = BufReader::new(stdin());
    let mut stdout = BufWriter::new(stdout());

    loop {
        let frame = read_frame(&mut stdin, size);

        let t1 = Instant::now();
        let d = diff([&last_frame, &frame], View::all(size), Ref::default());
        let t2 = Instant::now();
        eprintln!("diff {:?} {d}", t2 - t1);

        let t1 = Instant::now();
        let d = fast_diff([&last_frame, &frame], View::all(size), Ref::default());
        let t2 = Instant::now();
        eprintln!("diff2 {:?} {d}", t2 - t1);

        write_frame(&mut stdout, &frame);
        last_frame = frame;
    }
}

fn read_frame(inp: &mut impl Read, size: P2) -> Frame {
    let mut f = Frame {
        size,
        pixels: vec![Pixel::default(); size.area()],
    };

    for y in 0..size.y {
        for x in 0..size.x {
            let mut cc = [0u8; 3];
            inp.read_exact(&mut cc).unwrap();
            f[P2 { x, y }] = Pixel {
                r: cc[0] as PixelValue,
                g: cc[1] as PixelValue,
                b: cc[2] as PixelValue,
            };
        }
    }
    f
}

fn write_frame(out: &mut impl Write, frame: &Frame) {
    for y in 0..frame.size.y {
        for x in 0..frame.size.x {
            let p = frame[P2 { x, y }];
            let mut cc = [0u8; 3];
            cc[0] = p.r as u8;
            cc[1] = p.g as u8;
            cc[2] = p.b as u8;
            out.write_all(&mut cc).unwrap();
        }
    }
}