use crate::disk::inode::Inode;
use std::ffi::{OsStr, OsString};
use std::os::unix::ffi::OsStrExt;

pub trait Block: Default + Clone {}

#[repr(C)]
#[derive(Clone)]
pub struct DataBlock(pub(crate) [u8; 4096]);

impl Default for DataBlock {
    fn default() -> Self {
        Self([0; 4096])
    }
}

impl Block for DataBlock {}

#[repr(C)]
#[derive(Clone)]
pub struct InodeBlock {
    pub(crate) inodes: [Inode; 16],
}

impl Default for InodeBlock {
    fn default() -> Self {
        Self {
            inodes: [
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
                Inode::empty(),
            ],
        }
    }
}

impl Block for InodeBlock {}

const FULL_MAP: u32 = 0b111_111_111_111_111;

#[repr(C)]
#[derive(Clone)]
pub struct DirectoryEntry {
    pub inode: u32,
    pub record_len: u16,
    pub name_len: u8,
    pub file_type: u8,
    pub name: [u8; 256],
}

impl DirectoryEntry {
    pub(crate) fn name(&self) -> OsString {
        let name = &self.name[0..self.name_len as usize];
        OsStr::from_bytes(name).to_os_string()
    }
}

impl Default for DirectoryEntry {
    fn default() -> Self {
        Self {
            inode: 0,
            record_len: 0,
            name_len: 0,
            file_type: 0x0,
            name: [0; 256],
        }
    }
}

#[repr(C)]
#[derive(Clone)]
pub struct DirectoryBlock {
    pub entries: [DirectoryEntry; 15],
    reserved: [u8; 136],
}

impl Default for DirectoryBlock {
    fn default() -> Self {
        Self {
            entries: [
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
                DirectoryEntry::default(),
            ],
            reserved: [0xFF; 136],
        }
    }
}

impl Block for DirectoryBlock {}

#[repr(C)]
#[derive(Clone)]
pub struct IndirectBlock {
    pub entries: [u32; 1024],
}

impl Default for IndirectBlock {
    fn default() -> Self {
        Self { entries: [0; 1024] }
    }
}

impl Block for IndirectBlock {}

#[repr(C)]
#[derive(Clone)]
pub struct DoubleIndirectBlock {
    pub indirect: [u32; 1024],
}

impl Default for DoubleIndirectBlock {
    fn default() -> Self {
        Self {
            indirect: [0; 1024],
        }
    }
}

impl Block for DoubleIndirectBlock {}

#[repr(C)]
#[derive(Clone)]
pub struct TripleIndirectBlock {
    pub double_indirect: [u32; 1024],
}

impl Default for TripleIndirectBlock {
    fn default() -> Self {
        Self {
            double_indirect: [0; 1024],
        }
    }
}

impl Block for TripleIndirectBlock {}