pub mod motion;

use motion::{dec::MotionDecoder, enc::MotionEncoder, CommonBuffers, Params};
use pollster::FutureExt;
use std::io::{stdin, stdout, Read, Write};
use wgpu::{
    Backends, DeviceDescriptor, Extent3d, Features, Instance, InstanceDescriptor, Limits,
    MaintainBase, PowerPreference, RequestAdapterOptions,
};

use crate::motion::RoundParams;

fn main() {
    let instance = Instance::new(InstanceDescriptor {
        backends: Backends::all(),
        ..Default::default()
    });

    let adapter = instance
        .request_adapter(&RequestAdapterOptions {
            power_preference: PowerPreference::HighPerformance,
            force_fallback_adapter: false,
            compatible_surface: None,
        })
        .block_on()
        .unwrap();

    let (device, queue) = adapter
        .request_device(
            &DeviceDescriptor {
                label: None,
                features: Features::BGRA8UNORM_STORAGE,
                limits: Limits::default(),
            },
            None,
        )
        .block_on()
        .unwrap();

    let (width, height) = (1920, 1080);
    let params = Params {
        width,
        height,
        extent: Extent3d {
            width: width as u32,
            height: height as u32,
            depth_or_array_layers: 1,
        },
        blocks_x: width / 8,
        blocks_y: height / 8,
        block_width: 8,
        block_height: 8,
        blocks: (width / 8) * (height / 8),
    };

    let bufs = CommonBuffers::create(&device, &params);
    let menc = MotionEncoder::create(&device, &params, &bufs);
    let mdec = MotionDecoder::create(&device, &params, &bufs);

    let mut buffer = vec![0u8; width * height * 4];

    menc.write_uniforms(&queue);
    mdec.write_uniforms(&queue);

    let mut i = 0;
    loop {
        let rp = RoundParams { swap: i % 2 };
        eprintln!("read");
        stdin().read_exact(&mut buffer).unwrap();

        eprintln!("upload");
        bufs.upload(&queue, &params, &rp, &buffer);

        eprintln!("compute");

        let mut encoder = device.create_command_encoder(&Default::default());

        if i > 1 {
            menc.pass(&mut encoder, &params, &rp);
            mdec.pass(&mut encoder, &params, &rp);
        }
        bufs.prepare_texture_download(&mut encoder, &params, &rp);

        queue.submit(Some(encoder.finish()));
        device.poll(MaintainBase::Wait);

        eprintln!("download");
        bufs.download(&device, &mut buffer);

        eprintln!("write");
        stdout().write_all(&buffer).unwrap();
        i += 1;
    }
}