pub fn new() -> Result<Self> {

        let base_offset = host::input_offset();

        let base = base_offset as *const u8;

        let (buffer, header) = unsafe {

            let header_slice = core::slice::from_raw_parts(base, GLOBAL_HEADER_SIZE);

            let header = GlobalHeader::from_bytes(header_slice).ok_or(Error::InvalidMagic)?;

            let total_size =

                (header.strings_pool_offset - base_offset + header.strings_pool_size) as usize;

            let buffer = core::slice::from_raw_parts(base, total_size);

            (buffer, header)

        Ok(Self {

            buffer,

            header,

            base_offset,

        })

    }

    pub fn context_type(&self) -> Result<ContextType> {

        ContextType::try_from(self.header.context_type).map_err(|()| Error::InvalidEntityType)

    }

    pub fn primary_entity_type(&self) -> Result<EntityType> {

        EntityType::try_from(self.header.primary_entity_type).map_err(|()| Error::InvalidEntityType)

    }

    pub fn entity_count(&self) -> u32 {

        self.header.input_entity_count

    }

    pub fn primary_entity_idx(&self) -> u32 {

        self.header.primary_entity_idx

    }

    fn strings_pool(&self) -> &[u8] {

        let offset = (self.header.strings_pool_offset - self.base_offset) as usize;

        let size = self.header.strings_pool_size as usize;

        self.buffer.get(offset..offset + size).unwrap_or_default()

    }

    fn entity_header_offset(&self, idx: u32) -> Result<usize> {

        if idx >= self.header.input_entity_count {

            return Err(Error::EntityNotFound);

        }

        let offset = (self.header.entities_offset - self.base_offset) as usize

            + idx as usize * ENTITY_HEADER_SIZE;

        if offset + ENTITY_HEADER_SIZE > self.buffer.len() {

            return Err(Error::InvalidHeader);

        }

        Ok(offset)

    }

    pub fn entity(&self, idx: u32) -> Result<EntityRef<'_>> {

        let offset = self.entity_header_offset(idx)?;

        let header_bytes = &self.buffer[offset..offset + ENTITY_HEADER_SIZE];

        let header = EntityHeader::from_bytes(header_bytes).ok_or(Error::InvalidHeader)?;

        let data_offset = (header.data_offset - self.base_offset) as usize;

        let data_size = header.data_size as usize;

        let data = self

            .buffer

            .get(data_offset..data_offset + data_size)

            .ok_or(Error::InvalidHeader)?;

        Ok(EntityRef {

            header,

            data,

            strings_pool: self.strings_pool(),

        })

    }

    pub fn primary(&self) -> Result<EntityRef<'_>> {

        self.entity(self.header.primary_entity_idx)

    }

    pub fn primary_transaction(&self) -> Result<Transaction> {

        self.primary()?.as_transaction()

    }

    pub fn transaction(&self, idx: u32) -> Result<Transaction> {

        self.entity(idx)?.as_transaction()

    }

    pub fn split(&self, idx: u32) -> Result<Split> {

        self.entity(idx)?.as_split()

    }

    pub fn tag(&self, idx: u32) -> Result<Tag<'_>> {

        self.entity(idx)?.as_tag()

    }

    pub fn splits_for(&self, parent_idx: u32) -> impl Iterator<Item = Result<Split>> + '_ {

        let count = self.header.input_entity_count;

        (0..count).filter_map(move |idx| {

            let entity = match self.entity(idx) {

                Ok(e) => e,

                Err(e) => return Some(Err(e)),

            if entity.header.parent_idx == parent_idx as i32 {

                match entity.entity_type() {

                    Ok(EntityType::Split) => Some(entity.as_split()),

                    Ok(_) => None,

                    Err(e) => Some(Err(e)),

                None

        })

    }

    pub fn tags_for(&self, parent_idx: u32) -> impl Iterator<Item = Result<Tag<'_>>> + '_ {

        let count = self.header.input_entity_count;

        (0..count).filter_map(move |idx| {

            let entity = match self.entity(idx) {

                Ok(e) => e,

                Err(e) => return Some(Err(e)),

            if entity.header.parent_idx == parent_idx as i32 {

                match entity.entity_type() {

                    Ok(EntityType::Tag) => Some(entity.as_tag()),

                    Ok(_) => None,

                    Err(e) => Some(Err(e)),

                None

        })

    }