pub mod decode;
pub mod encode;

use decode::Dec;
use encode::Enc;
use framework::bitstream_filter_main;
use glam::IVec2;
use std::{collections::VecDeque, env::args};

fn main() -> Result<(), std::io::Error> {
    match args().nth(1).unwrap().as_str() {
        "enc" => bitstream_filter_main::<Enc>(),
        "dec" => bitstream_filter_main::<Dec>(),
        _ => panic!("unknown mode"),
    }
}

pub const BLOCK_SIZE: i32 = 8;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AbsRef {
    pub off: IVec2,
    pub frame: u64,
}

#[derive(Clone)]
pub struct Frame {
    pub res: IVec2,
    pub data: Vec<u8>,
}

impl Frame {
    pub fn new(res: IVec2) -> Self {
        let ures = res.as_usizevec2();
        Self {
            res,
            data: vec![0; ures.x * ures.y + 2 * (ures.x / 2 * ures.y / 2)],
        }
    }
    pub fn export_rect(&self, off: IVec2, size: IVec2, buf: &mut Vec<u8>) {
        // Luma
        for y in 0..size.y {
            let y_off = off.x + (y + off.y) * self.res.x;
            buf.extend(&self.data[y_off as usize..(y_off + size.x) as usize]);
        }
        // Chroma
        let uvplane_off = self.res.x * self.res.y;
        for y in 0..size.y / 2 {
            let y_off = uvplane_off + (off.x & !1) + (y + off.y / 2) * self.res.x;
            buf.extend(&self.data[y_off as usize..(y_off + size.x) as usize]);
        }
    }
    pub fn import_rect(&mut self, off: IVec2, size: IVec2, buf: &[u8]) -> usize {
        let mut p = 0;
        // Luma
        for y in 0..size.y {
            let y_off = off.x + (y + off.y) * self.res.x;
            self.data[y_off as usize..(y_off + size.x) as usize]
                .copy_from_slice(&buf[p..p + size.x as usize]);
            p += size.x as usize;
        }
        // Chroma
        let uvplane_off = self.res.x * self.res.y;
        for y in 0..size.y / 2 {
            let y_off = uvplane_off + (off.x & !1) + (y + off.y / 2) * self.res.x;
            self.data[y_off as usize..(y_off + size.x) as usize]
                .copy_from_slice(&buf[p..p + size.x as usize]);
            p += size.x as usize;
        }
        p
    }
}

pub fn frame_to_frame_rect_copy(
    aframe: &Frame,
    bframe: &mut Frame,
    size: IVec2,
    aoff: IVec2,
    boff: IVec2,
) {
    assert_eq!(aframe.res, bframe.res);
    let res = aframe.res;
    // Luma
    for y in 0..size.y {
        let ay_off = aoff.x + (y + aoff.y) * res.x;
        let by_off = boff.x + (y + boff.y) * res.x;

        bframe.data[by_off as usize..(by_off + size.x) as usize]
            .copy_from_slice(&aframe.data[ay_off as usize..(ay_off + size.x) as usize]);
    }

    // Chroma
    let uvplane_off = res.x * res.y;
    for y in 0..size.y / 2 {
        let ay_off = uvplane_off + (aoff.x & !1) + (y + aoff.y / 2) * res.x;
        let by_off = uvplane_off + (boff.x & !1) + (y + boff.y / 2) * res.x;

        bframe.data[by_off as usize..(by_off + size.x) as usize]
            .copy_from_slice(&aframe.data[ay_off as usize..(ay_off + size.x) as usize]);
    }
}

pub struct LastFrames {
    pub frame_offset: u64,
    pub frames: VecDeque<Frame>,
}