use crate::pager::Pager;
use crate::row;
use crate::row::Row;
use crate::row::Serialize;
use std::mem::size_of;
use std::ops::DerefMut;

const PAGE_SIZE: usize = 4096;

pub struct Table {
    num_rows: usize,
    pager: Pager,
}

impl Table {
    pub fn new() -> Self {
        Self {
            num_rows: 0,
            pager: Pager::new(PAGE_SIZE),
        }
    }

    pub fn append_row(&mut self, row: Vec<u8>) {
        let row_size = size_of::<row::Row>();
        let page_num = self.num_rows / self.rows_per_page(row_size);
        let row_offset = self.num_rows % self.rows_per_page(row_size);

        let page = self.pager.get_mut_or_alloc(page_num);

        let byte_offset = row_offset * row_size;

        page.deref_mut()
            .splice(byte_offset..byte_offset + row_size, row);
        self.num_rows += 1;
    }

    pub fn row(&mut self, row_num: usize) -> Row {
        let row_size = size_of::<row::Row>();
        let page_num = row_num / self.rows_per_page(row_size);
        let row_offset = row_num % self.rows_per_page(row_size);
        let byte_offset = row_offset * row_size;

        let page = self.pager.get_mut_or_alloc(page_num);

        Row::deserialize(&page[byte_offset..byte_offset + row_size]).unwrap()
    }

    #[inline]
    fn rows_per_page(&self, row_size: usize) -> usize {
        PAGE_SIZE / row_size
    }

    pub fn get_rows(&mut self) -> Vec<Row> {
        let mut rows: Vec<Row> = Vec::with_capacity(self.num_rows);
        for i in 0..self.num_rows {
            rows.push(self.row(i))
        }

        rows
    }
}