use crate::disk::block::InodeBlock;
use crate::disk::inode::{Inode, InodeMode, INODE_SIZE};
use crate::{utils, AyaFS};
use and_then_some::BoolExt;
use log::debug;

impl AyaFS {
    pub(crate) fn create_inode(
        &mut self,
        permissions: u16,
        mode: InodeMode,
        uid: u32,
        gid: u32,
        flags: u32,
    ) -> Option<usize> {
        debug!("create inode");
        self.inode_bitmap.allocate().map(|inode_index| {
            debug!("creating inode");
            self.get_inode_mut(inode_index).map(|inode| {
                *inode = Inode::make_inode(
                    permissions,
                    mode,
                    uid,
                    gid,
                    utils::time_now(),
                    flags,
                    0,
                    0,
                    0,
                );
            });
            debug!("inode created");
            inode_index
        })
    }

    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]
                })
        })
    }
}