mdict-rs 0.1.0

use std::path::Path;
use std::sync::Arc;

use crate::core::{DecodedKeyEntry, MdictFile};
use crate::error::Result;
use crate::types::{ContainerKind, Header, OpenOptions};

/// Opened `.mdd` resource dictionary file.
#[derive(Debug)]
pub struct MddFile {
    inner: MdictFile,
}

/// A decoded MDD key/resource pair.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MddResource {
    pub key: String,
    pub data: Vec<u8>,
}

impl MddFile {
    /// Opens an MDD file with default options.
    pub fn open(path: impl AsRef<Path>) -> Result<Self> {
        Self::open_with_options(path, OpenOptions::default())
    }

    /// Opens an MDD file with explicit options.
    pub fn open_with_options(path: impl AsRef<Path>, options: OpenOptions) -> Result<Self> {
        Ok(Self {
            inner: MdictFile::open(path, ContainerKind::Mdd, &options)?,
        })
    }

    /// Returns the parsed top-level header metadata.
    pub fn header(&self) -> &Header {
        &self.inner.header
    }

    /// Returns the number of resource entries declared by the file.
    pub fn len(&self) -> u64 {
        self.inner.len()
    }

    /// Performs a lazy lookup for a single resource key.
    pub fn lookup(&self, key: &str) -> Result<Option<MddResource>> {
        let Some((block_index, entry_index, entries)) = self.inner.find_entry(key)? else {
            return Ok(None);
        };
        let entry = &entries[entry_index];
        let end = self.inner.record_end(block_index, entry_index, &entries)?;
        let data = self.inner.read_record_span(entry.record_start, end)?;
        Ok(Some(MddResource {
            key: entry.key.clone(),
            data,
        }))
    }

    pub fn entries(&self) -> MddEntryIter<'_> {
        MddEntryIter::new(self)
    }
}

/// Lazy iterator over decoded MDD resources.
pub struct MddEntryIter<'a> {
    file: &'a MddFile,
    block_index: usize,
    entry_index: usize,
    current_block: Option<Arc<Vec<DecodedKeyEntry>>>,
}

impl<'a> MddEntryIter<'a> {
    fn new(file: &'a MddFile) -> Self {
        Self {
            file,
            block_index: 0,
            entry_index: 0,
            current_block: None,
        }
    }
}

impl Iterator for MddEntryIter<'_> {
    type Item = Result<MddResource>;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            if self.block_index >= self.file.inner.key_block_count() {
                return None;
            }

            if self.current_block.is_none() {
                match self.file.inner.decode_key_block(self.block_index) {
                    Ok(entries) => {
                        self.current_block = Some(entries);
                        self.entry_index = 0;
                    }
                    Err(error) => return Some(Err(error)),
                }
            }

            let entries = self.current_block.as_ref().unwrap();
            if self.entry_index >= entries.len() {
                self.block_index += 1;
                self.current_block = None;
                continue;
            }

            let entry = &entries[self.entry_index];
            let result = (|| -> Result<MddResource> {
                let end =
                    self.file
                        .inner
                        .record_end(self.block_index, self.entry_index, entries)?;
                let data = self.file.inner.read_record_span(entry.record_start, end)?;
                Ok(MddResource {
                    key: entry.key.clone(),
                    data,
                })
            })();
            self.entry_index += 1;
            return Some(result);
        }
    }
}