tools/publish/src/rdf/ontology.rs

use crate::error;
use crate::rdf::vocab::gl;
use oxigraph::model::vocab::{rdf, rdfs, xsd};
use oxigraph::model::{LiteralRef, NamedNode, NamedNodeRef, NamedOrBlankNode, NamedOrBlankNodeRef, Term, TermRef, Triple, TripleRef};
use oxigraph::sparql::{QueryResults, SparqlEvaluator};
use std::collections::{BTreeMap, HashMap, HashSet};
use std::fmt::Display;
use std::path::{Path, PathBuf};
use std::sync::LazyLock;
use oxigraph::store::Store;
use tracing::debug_span;
use crate::rdf::{conversion, materialize};
use crate::rdf::conversion::LanguageCondition;

static PREFIXES: LazyLock<BTreeMap<String, String>> = LazyLock::new(|| {
    BTreeMap::from_iter([
        ("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"),
        ("rdfs", "http://www.w3.org/2000/01/rdf-schema#"),
        ("owl", "http://www.w3.org/2002/07/owl#"),
        ("xsd", "http://www.w3.org/2001/XMLSchema#"),
        ("ldp", "http://www.w3.org/ns/ldp#"),
        ("dc", "http://purl.org/dc/elements/1.1/"),
        ("posix", "http://www.w3.org/ns/posix/stat#"),
        (
            "ebucore",
            "http://www.ebu.ch/metadata/ontologies/ebucore/ebucore#",
        ),
        ("premis", "http://www.loc.gov/premis/rdf/v1#"),
        ("premis3", "http://www.loc.gov/premis/rdf/v3/"),
        ("dcterms", "http://purl.org/dc/terms/"),
        ("fedora", "http://fedora.info/definitions/v4/repository#"),
        ("rdaa", "http://rdaregistry.info/Elements/a/"),
        ("rdaad", "http://rdaregistry.info/Elements/a/datatype/"),
        ("rdac", "http://rdaregistry.info/Elements/c/"),
        ("rdae", "http://rdaregistry.info/Elements/e/"),
        ("rdai", "http://rdaregistry.info/Elements/i/"),
        ("rdam", "http://rdaregistry.info/Elements/m/"),
        ("rdan", "http://rdaregistry.info/Elements/n/"),
        ("rdap", "http://rdaregistry.info/Elements/p/"),
        ("rdat", "http://rdaregistry.info/Elements/t/"),
        ("rdaw", "http://rdaregistry.info/Elements/w/"),
        ("rdax", "http://rdaregistry.info/Elements/x/"),
        ("schema", "https://schema.org/"),
        ("quill", "http://fedora.quill.lan/rest/"),
        ("gl", "https://graphofliberty.org/2026/04/ont/"),
    ].map(|(k, v)| (k.to_string(), v.to_string())))
});

pub struct OntologyBuilder {
    path: Option<PathBuf>,
}

impl OntologyBuilder {
    pub fn with_path(mut self, path: impl AsRef<Path>) -> Self {
        let path = path.as_ref().to_owned();
        self.path = Some(path);
        self
    }

    pub fn build(self) -> error::Result<Ontology> {
        let mut store = if let Some(path) = self.path {
            Store::open(path)
        } else {
            Store::new()
        }?;

        let prefixes = PREFIXES
            .iter()
            .map(|(k, v)| (k.to_string(), v.to_string()))
            .collect::<HashMap<String, String>>();

        materialize::same_as(&mut store)?;
        materialize::super_properties(&mut store)?;
        materialize::super_classes(&mut store)?;
        debug_span!("Optimize Ontology").in_scope(|| store.optimize())?;

        // Full-text search index field names
        let fields = Self::fields(&store)?;

        let mut entities: HashMap<NamedNode, Entity> = HashMap::new();
        // All Entities have exactly one catalog ID.
        for quad in store.quads_for_pattern(None, Some(gl::CATALOG_ID), None, None)
            .filter_map(Result::ok) {
            let label = store.quads_for_pattern(Some(quad.subject.as_ref().into()), Some(rdfs::LABEL), None, None)
                .filter_map(Result::ok)
                .map(conversion::quad_into_term)
                .filter(|term| conversion::language_matches(term, &conversion::english()))
                .filter_map(conversion::term_into_string)
                .next();

            let comment = store.quads_for_pattern(Some(quad.subject.as_ref().into()), Some(rdfs::COMMENT), None, None)
                .filter_map(Result::ok)
                .map(conversion::quad_into_term)
                .filter(|term| conversion::language_matches(term, &conversion::english()))
                .filter_map(conversion::term_into_string)
                .next();

            if let Some(catalog_id) = conversion::term_to_u64(&quad.object) &&
                let NamedOrBlankNode::NamedNode(subject) = quad.subject &&
                let Some(label) = label {
                let mut properties = HashSet::new();
                for quad in store.quads_for_pattern(Some(subject.as_ref().into()), Some(gl::ASSOCIATED_PROPERTY), None, None)
                    .filter_map(Result::ok) {
                    if let Term::NamedNode(property) = quad.object {
                        properties.insert(property);
                    }
                }
                entities.insert(subject, Entity {
                    label,
                    comment,
                    catalog_id,
                    properties,
                });
            }
        }

        let mut indexed_by = HashMap::new();
        for quad in store.quads_for_pattern(None, Some(gl::INDEXED_BY_FIELD), None, None)
            .filter_map(Result::ok) {
            if let NamedOrBlankNode::NamedNode(subject) = quad.subject
                && let Term::NamedNode(field) = quad.object
            {
                indexed_by.insert(subject, field);
            }
        }

        Ok(Ontology {
            store,
            prefixes,
            fields,
            entities,
            indexed_by,
        })
    }

    fn fields(store: &Store) -> error::Result<HashMap<NamedNode, IndexField>> {
        let query = SparqlEvaluator::new()
            .with_prefix("rdfs", "http://www.w3.org/2000/01/rdf-schema#")?
            .with_prefix("gl", "https://graphofliberty.org/2026/04/ont/")?
            .parse_query(
                r#"SELECT DISTINCT ?subject ?name ?label {
    GRAPH ?graph {
        ?subject a gl:IndexDocumentField ;
        gl:fieldName ?name ;
        gl:fieldLabel ?label .
        FILTER (langMATCHES(LANG(?label), "en") || !hasLANG(?label))
    }
}"#)?;

        let mut results = HashMap::new();
        if let QueryResults::Solutions(solutions) = query.on_store(store).execute()?
        {
            for solution in solutions.filter_map(Result::ok) {
                let subject = solution.get("subject").and_then(conversion::term_to_named_node);
                let name = solution.get("name").and_then(conversion::term_as_str);
                let label = solution.get("label").and_then(conversion::term_as_str);

                if let Some(subject) = subject && let Some(name) = name {
                    let field = IndexField {
                        name: name.to_string(),
                        label: label.map(|l| l.to_string()),
                    };
                    results.insert(subject.to_owned(), field);
                }
            }
        }
        Ok(results)
    }

    /*fn subclass_of(dataset: &Dataset, class: NamedNodeRef<'_>) -> impl Iterator<Item = NamedNode> {
        let query = SparqlEvaluator::new()
            .parse_query(
                format!(
                    "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?class {{
    ?class (rdfs:subClassOf|^rdfs:subClassOf)* {class} .
}}"
                )
                    .as_str(),
            )
            .expect("Unable to parse subclass_of query");

        if let QueryResults::Solutions(solutions) =
            query.on_queryable_dataset(dataset).execute().unwrap()
        {
            solutions.filter_map(Result::ok).filter_map(|solution| {
                if let Some(Term::NamedNode(class)) = solution.get("class") {
                    Some(class.clone())
                } else {
                    None
                }
            })
        } else {
            unreachable!()
        }
    }*/
}

#[derive(Clone, Debug)]
pub struct LabeledIri {
    pub iri: NamedNode,
    pub label: Option<String>,
    pub comment: Option<String>,
}

impl PartialEq for LabeledIri {
    fn eq(&self, other: &Self) -> bool {
        self.iri == other.iri
    }
}

impl Display for LabeledIri {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.label.clone().unwrap_or_default())
    }
}

#[derive(Clone, Debug)]
pub struct Entity {
    pub label: String,
    pub comment: Option<String>,
    pub catalog_id: u64,
    pub properties: HashSet<NamedNode>,
}

#[derive(Clone, Debug)]
pub struct IndexField {
    pub name: String,
    pub label: Option<String>,
}

pub struct Ontology {
    store: Store,
    prefixes: HashMap<String, String>,

    // Resource (Property or Class) -> Rust Type
    //iri_info: HashMap<NamedNode, IriInformation>,

    // NamedIndividual of class IndexField -> Rust Type
    fields: HashMap<NamedNode, IndexField>,

    // NamedIndividual of class Entity -> Rust Type
    entities: HashMap<NamedNode, Entity>,

    // Property -> NamedIndividual of class IndexField
    indexed_by: HashMap<NamedNode, NamedNode>,
}

impl Ontology {
    pub fn builder() -> OntologyBuilder {
        OntologyBuilder {
            path: None,
        }
    }

    pub fn prefixes(&self) -> &BTreeMap<String, String> {
        &*PREFIXES
    }

    pub fn abbreviate(&self, node: NamedNodeRef<'_>) -> String {
        for (prefix_name, prefix_iri) in &self.prefixes {
            if let Some(local_name) = node.as_str().strip_prefix(prefix_iri) {
                return if local_name.is_empty() {
                    format!("{prefix_name}:")
                } else {
                    format!("{prefix_name}:{local_name}")
                };
            }
        }
        node.as_str().to_string()
    }

    pub fn expand(&self, prefixed_iri: &str) -> Option<NamedNode> {
        let (prefix, name) = prefixed_iri.split_once(':')?;
        self.prefixes
            .get(prefix)
            .map(|base| NamedNode::new_unchecked(format!("{base}{name}")))
    }

    pub fn field_for_property(&self, property: &NamedNode) -> Option<&IndexField> {
        self.indexed_by.get(property)
            .and_then(|node| self.fields.get(node))
    }

    pub fn fields_for_class(&self, class: &NamedNode) -> Vec<&IndexField> {
        self.entities.get(class)
            .and_then(|entity| {
                entity.properties.iter()
                    .map(|property| self.field_for_property(property))
                    .filter(Option::is_some)
                    .collect()
            }).unwrap_or(Vec::new())
    }

    pub fn catalog_id(&self, class: &NamedNode) -> Option<u64> {
        self.entities
            .get(class)
            .map(|entity| entity.catalog_id)
    }

    pub fn individuals(&self, class: &NamedNode) -> impl Iterator<Item = NamedNode> {
        self.store
            .quads_for_pattern(None, Some(rdf::TYPE), Some(class.into()), None)
            .filter_map(Result::ok)
            .filter_map(|quad|
                if let NamedOrBlankNode::NamedNode(subject) = quad.subject {
                    Some(subject)
                } else { None })
    }

    pub fn info(&self, iri: &NamedNode, language: &LanguageCondition) -> LabeledIri {
        let label = self.store.quads_for_pattern(Some(iri.as_ref().into()), Some(rdfs::LABEL), None, None)
            .filter_map(Result::ok)
            .map(conversion::quad_into_term)
            .filter(|term| conversion::language_matches(term, language))
            .filter_map(conversion::term_into_string)
            .next();

        let comment = self.store.quads_for_pattern(Some(iri.as_ref().into()), Some(rdfs::COMMENT), None, None)
            .filter_map(Result::ok)
            .map(conversion::quad_into_term)
            .filter(|term| conversion::language_matches(term, language))
            .filter_map(conversion::term_into_string)
            .next();

        LabeledIri {
            iri: iri.clone(),
            label,
            comment,
        }
    }

    pub fn labeled_entity(&self, class: &NamedNode) -> Option<LabeledIri> {
        self.entities.get(class)
            .map(|entity| LabeledIri {
                iri: class.to_owned(),
                label: Some(entity.label.to_owned()),
                comment: entity.comment.to_owned(),
            })
    }

    pub fn labeled_entities(&self) -> impl Iterator<Item = LabeledIri> {
        self.entities.iter()
            .map(|(iri, entity)| LabeledIri {
                iri: iri.to_owned(),
                label: Some(entity.label.to_owned()),
                comment: entity.comment.to_owned(),
            })
    }

    pub fn datatypes(&self) -> impl Iterator<Item = NamedNode> {
        self.store
            .quads_for_pattern(
                None,
                Some(rdf::TYPE),
                Some(TermRef::NamedNode(rdfs::DATATYPE)),
                None,
            )
            .filter_map(Result::ok)
            .filter_map(|quad| match quad.subject {
                NamedOrBlankNode::NamedNode(subject) => Some(subject),
                _ => None,
            })
    }

    pub fn is_read_only<'a>(&self, triple: impl Into<TripleRef<'a>>) -> bool {
        let triple = triple.into();
        let true_term = TermRef::Literal(LiteralRef::new_typed_literal("true", xsd::BOOLEAN));

        let subject = match (triple.predicate, triple.object) {
            (rdf::TYPE, TermRef::NamedNode(class)) => class,
            (predicate, _) => predicate,
        };

        self.store
            .quads_for_pattern(Some(NamedOrBlankNodeRef::NamedNode(subject)), Some(gl::READ_ONLY), Some(true_term), None)
            .filter_map(Result::ok)
            .count() >= 1
    }

    pub fn template_triples<'a>(
        &'a self,
        class: NamedNodeRef<'a>,
        subject: NamedNodeRef<'_>,
    ) -> Option<impl Iterator<Item = Triple>> {
        if let Some(quad) = self
            .store
            .quads_for_pattern(
                Some(NamedOrBlankNodeRef::NamedNode(class)),
                Some(gl::TEMPLATE),
                None,
                None,
            )
            .filter_map(Result::ok)
            .next()
        {
            if let Term::BlankNode(blank_node) = quad.object {
                let iter = self
                    .store
                    .quads_for_pattern(Some(NamedOrBlankNodeRef::BlankNode(blank_node.as_ref())), None, None, None)
                    .filter_map(Result::ok)
                    .map(Triple::from)
                    .map(move |mut triple| {
                        triple.subject = NamedOrBlankNode::NamedNode(subject.into_owned());
                        triple
                    });
                Some(iter)
            } else {
                None
            }
        } else {
            None
        }
    }
}