use crate::disk::block::{DirectoryBlock, DirectoryEntry, InodeBlock};
use crate::disk::inode::{Inode, INODE_SIZE};
use crate::{utils, AyaFS};
use and_then_some::BoolExt;
use libc::{c_int, EISDIR, ENOENT, ENOTDIR};

impl AyaFS {
    pub(crate) fn create_file(
        &mut self,
        permissions: u16,
        uid: u32,
        gid: u32,
        flags: u32,
    ) -> Option<(usize, &Inode)> {
        self.inode_bitmap.allocate().map(|inode_index| {
            self.get_inode_mut(inode_index).map(|inode| {
                *inode = Inode::file(permissions, uid, gid, utils::time_now(), flags, 0, 0, 0);
            });
            (inode_index, self.get_inode(inode_index).unwrap())
        })
    }

    /// 根目录的 parent_inode_number 传入 None, 会直接以自己作为 .. 的 inode number
    pub(crate) fn create_directory(
        &mut self,
        permissions: u16,
        uid: u32,
        gid: u32,
        flags: u32,
        parent_inode_number: Option<u32>,
    ) -> Option<(usize, &Inode)> {
        self.inode_bitmap.allocate().map(|inode_index| {
            // 创建 Inode
            let mut new_inode =
                Inode::directory(permissions, uid, gid, utils::time_now(), flags, 0, 0, 0);
            // 分配第一个 direct block
            (new_inode.direct[0], _) = self.allocate_block_for(&mut new_inode).unwrap();
            new_inode.size = 2;
            // 在 direct block 里分配 . 和 ..
            if let Some(directory_block) =
                self.get_block_mut::<DirectoryBlock>(new_inode.direct[0] as usize)
            {
                let dot = '.'.to_ascii_lowercase() as u8;
                // add dot entry
                directory_block.block.entries[0] = DirectoryEntry {
                    inode: inode_index as u32,
                    record_len: 264,
                    name_len: 1,
                    file_type: 0x2,
                    name: [0; 256],
                };
                directory_block.block.entries[0].name[0] = dot;

                // add dot dot entry
                directory_block.block.entries[1] = DirectoryEntry {
                    inode: parent_inode_number.unwrap_or(inode_index as u32),
                    record_len: 264,
                    name_len: 2,
                    file_type: 0x2,
                    name: [0; 256],
                };
                directory_block.block.entries[1].name[0] = dot;
                directory_block.block.entries[1].name[1] = dot;
            }
            // 把 inode 放到指定位置
            self.get_inode_mut(inode_index).map(|inode| {
                *inode = new_inode;
            });

            (inode_index, self.get_inode(inode_index).unwrap())
        })
    }
    
    pub(crate) fn remove_file(&mut self, inode_index: usize) -> Result<bool, c_int> {
        if self.inode_bitmap.query(inode_index) {
            self.inode_bitmap.deallocate(inode_index);
            let (block_index, offset) = self.locate_inode(inode_index);
            if let Some(cached_block) = self.cached_inodes.get_block::<InodeBlock>(block_index) {
                let inode = cached_block.block.inodes[offset / INODE_SIZE].clone();
                if !inode.is_file() {
                    return Err(EISDIR);
                }
                self.deallocate_all_blocks_for(&inode).unwrap();
            }
            Ok(true)
        } else {
            Err(ENOENT)
        }
    }
    
    pub(crate) fn remove_dir(&mut self, inode_index: usize) -> Result<bool, c_int> {
        if self.inode_bitmap.query(inode_index) {
            self.inode_bitmap.deallocate(inode_index);
            let (block_index, offset) = self.locate_inode(inode_index);
            if let Some(cached_block) = self.cached_inodes.get_block::<InodeBlock>(block_index) {
                let inode = cached_block.block.inodes[offset / INODE_SIZE].clone();
                if !inode.is_dir() {
                    return Err(ENOTDIR);
                }
                // TODO 递归删除所有下面的 direntry 里的 inode, 注意排除 . 和 ..
            }
            Ok(true)
        } else {
            Err(ENOENT)
        }
    }

    pub(crate) fn remove_inode(&mut self, inode_index: usize) -> bool {
        if self.inode_bitmap.query(inode_index) {
            self.inode_bitmap.deallocate(inode_index);
            let (block_index, offset) = self.locate_inode(inode_index);
            if let Some(cached_block) = self.cached_inodes.get_block::<InodeBlock>(block_index) {
                let inode = &cached_block.block.inodes[offset / INODE_SIZE].clone();

                if inode.is_file() {
                    self.deallocate_all_blocks_for(inode).unwrap();
                } else if inode.is_dir() {
                    // TODO 把 dir 下所有子目录 remove 掉
                } else {
                    unimplemented!("only file and dir are implemented!");
                }
            }
            true
        } else {
            false
        }
    }

    pub(crate) fn update_inode(&mut self, inode_index: usize, inode: Inode) -> bool {
        if self.inode_bitmap.query(inode_index) {
            let (block_index, offset) = self.locate_inode(inode_index);
            if let Some(cached_block) = self.cached_inodes.get_block_mut::<InodeBlock>(block_index)
            {
                cached_block.block.inodes[offset / INODE_SIZE] = inode;
            }
            true
        } else {
            false
        }
    }

    pub(crate) fn get_inode(&mut self, inode_index: usize) -> Option<&Inode> {
        self.inode_bitmap.query(inode_index).and_then(|| {
            let (block_index, offset) = self.locate_inode(inode_index);
            self.cached_inodes
                .get_block::<InodeBlock>(block_index)
                .map(|cached_block| &cached_block.block.inodes[offset / INODE_SIZE])
        })
    }

    pub(crate) fn get_inode_mut(&mut self, inode_index: usize) -> Option<&mut Inode> {
        self.inode_bitmap.query(inode_index).and_then(|| {
            let (block_index, offset) = self.locate_inode(inode_index);
            self.cached_inodes
                .get_block_mut::<InodeBlock>(block_index)
                .map(|cached_block| {
                    cached_block.dirty = true; // 保守一些, 只要返回了 &mut Inode 这个页一定标记为脏
                    &mut cached_block.block.inodes[offset / INODE_SIZE]
                })
        })
    }

    pub(crate) fn peek_inode(&self, inode_index: usize) -> Option<&Inode> {
        self.inode_bitmap.query(inode_index).and_then(|| {
            let (block_index, offset) = self.locate_inode(inode_index);
            self.cached_inodes
                .peek_block::<InodeBlock>(block_index)
                .map(|cached_block| &cached_block.block.inodes[offset / INODE_SIZE])
        })
    }

    pub(crate) fn peek_inode_mut(&mut self, inode_index: usize) -> Option<&mut Inode> {
        self.inode_bitmap.query(inode_index).and_then(|| {
            let (block_index, offset) = self.locate_inode(inode_index);
            self.cached_inodes
                .peek_block_mut::<InodeBlock>(block_index)
                .map(|cached_block| {
                    cached_block.dirty = true; // 保守一些, 只要返回了 &mut Inode 这个页一定标记为脏
                    &mut cached_block.block.inodes[offset / INODE_SIZE]
                })
        })
    }
}