natter/src/intermediate/registry.rs

use std::collections::HashMap;
use std::marker::PhantomData;
use std::sync::Arc;
use std::sync::Mutex;

// use super::ast_node::IntoIAstNode;
use crate::error::CustomError;
use organic::types::Element;
use organic::types::Object;

use super::ast_node::IAstNode;
use super::ast_node::IntoIAstNode;
use super::RefRegistry;

type IdCounter = u16;

pub(crate) struct Registry<'orig, 'parse> {
    id_counter: IdCounter,
    targets: HashMap<&'parse str, String>,
    footnote_ids: Vec<(Option<&'parse str>, Vec<IAstNode>)>,
    _phantom: PhantomData<&'orig ()>,
}

impl<'orig, 'parse> Registry<'orig, 'parse> {
    pub(crate) fn new() -> Registry<'orig, 'parse> {
        Registry {
            id_counter: 0,
            targets: HashMap::new(),
            footnote_ids: Vec::new(),
            _phantom: PhantomData,
        }
    }

    pub(crate) fn get_target<'reg>(&'reg mut self, body: &'parse str) -> &'reg String {
        self.targets.entry(body).or_insert_with(|| {
            self.id_counter += 1;
            format!("target_{}", self.id_counter)
        })
    }

    pub(crate) fn get_footnote_ids(&self) -> impl Iterator<Item = (usize, &Vec<IAstNode>)> {
        self.footnote_ids
            .iter()
            .map(|(_label, definition)| definition)
            .enumerate()
    }
}

/// Get a 0-indexed ID for a footnote.
///
/// This needs to be incremented to be 1-indexed for render.
pub(crate) async fn get_footnote_reference_id<'orig, 'parse>(
    registry: RefRegistry<'orig, 'parse>,
    label: Option<&'parse str>,
    definition: &'orig Vec<Object<'parse>>,
) -> Result<usize, CustomError> {
    if let None = label {
        // If it has no label then it must always get a new ID.
        let contents = convert_reference_contents(registry.clone(), definition).await?;
        let pos = {
            let mut registry = registry.lock().unwrap();
            registry.footnote_ids.push((None, contents));
            registry.footnote_ids.len() - 1
        };
        return Ok(pos);
    }

    let existing_index = registry
        .lock()
        .unwrap()
        .footnote_ids
        .iter()
        .position(|(id, _definition)| *id == label);
    if let Some(existing_id) = existing_index {
        if !definition.is_empty() {
            let contents = convert_reference_contents(registry.clone(), definition).await?;
            let mut registry = registry.lock().unwrap();
            let entry = registry
                .footnote_ids
                .get_mut(existing_id)
                .expect("If-statement proves this to be Some.");
            entry.1 = contents;
        }
        Ok(existing_id)
    } else {
        let contents = convert_reference_contents(registry.clone(), definition).await?;
        let pos = {
            let mut registry = registry.lock().unwrap();
            registry.footnote_ids.push((label, contents));
            registry.footnote_ids.len() - 1
        };
        Ok(pos)
    }
}

/// Update the definition to a footnote but do not mark it as referenced.
pub(crate) async fn register_footnote_definition<'orig, 'parse>(
    registry: RefRegistry<'orig, 'parse>,
    label: &'parse str,
    definition: &'orig Vec<Element<'parse>>,
) -> Result<(), CustomError> {
    let has_existing: bool = {
        let mut registry = registry.lock().unwrap();
        registry
            .footnote_ids
            .iter_mut()
            .any(|(id, _definition)| *id == Some(label))
    };
    if !has_existing {
        return Ok(());
    }
    let contents = convert_definition_contents(registry.clone(), definition).await?;
    let mut registry = registry.lock().unwrap();
    if let Some((_existing_id, existing_definition)) = registry
        .footnote_ids
        .iter_mut()
        .find(|(id, _definition)| *id == Some(label))
    {
        *existing_definition = contents;
    }
    Ok(())
}

async fn convert_reference_contents<'orig, 'parse>(
    registry: RefRegistry<'orig, 'parse>,
    contents: &'orig Vec<Object<'parse>>,
) -> Result<Vec<IAstNode>, CustomError> {
    let contents = {
        let mut ret = Vec::new();
        for obj in contents.iter() {
            ret.push(obj.into_ast_node(registry.clone()).await?);
        }
        ret
    };

    Ok(contents)
}

async fn convert_definition_contents<'orig, 'parse>(
    registry: RefRegistry<'orig, 'parse>,
    contents: &'orig Vec<Element<'parse>>,
) -> Result<Vec<IAstNode>, CustomError> {
    let contents = {
        let mut ret = Vec::new();
        for obj in contents.iter() {
            ret.push(obj.into_ast_node(registry.clone()).await?);
        }
        ret
    };

    Ok(contents)
}