// Read-only access abstraction for the memory store

use super::{capnp, index, types::*};
use super::Store;

// ---------------------------------------------------------------------------
// StoreView: read-only access trait for search and graph code.
// ---------------------------------------------------------------------------

pub trait StoreView {
    /// Iterate all nodes. Callback receives (key, content, weight).
    fn for_each_node<F: FnMut(&str, &str, f32)>(&self, f: F);

    /// Iterate all nodes with metadata. Callback receives (key, node_type, timestamp).
    fn for_each_node_meta<F: FnMut(&str, NodeType, i64)>(&self, f: F);

    /// Iterate all relations. Callback receives (source_key, target_key, strength, rel_type).
    fn for_each_relation<F: FnMut(&str, &str, f32, RelationType)>(&self, f: F);

    /// Node weight by key, or the default weight if missing.
    fn node_weight(&self, key: &str) -> f64;
}

impl StoreView for Store {
    fn for_each_node<F: FnMut(&str, &str, f32)>(&self, mut f: F) {
        let db = match self.db.as_ref() {
            Some(db) => db,
            None => return,
        };
        let keys = match index::all_keys(db) {
            Ok(keys) => keys,
            Err(_) => return,
        };
        for key in keys {
            if let Ok(Some(offset)) = index::get_offset(db, &key) {
                if let Ok(node) = capnp::read_node_at_offset(offset) {
                    f(&key, &node.content, node.weight);
                }
            }
        }
    }

    fn for_each_node_meta<F: FnMut(&str, NodeType, i64)>(&self, mut f: F) {
        let db = match self.db.as_ref() {
            Some(db) => db,
            None => return,
        };
        let keys = match index::all_keys(db) {
            Ok(keys) => keys,
            Err(_) => return,
        };
        for key in keys {
            if let Ok(Some(offset)) = index::get_offset(db, &key) {
                if let Ok(node) = capnp::read_node_at_offset(offset) {
                    f(&key, node.node_type, node.timestamp);
                }
            }
        }
    }

    fn for_each_relation<F: FnMut(&str, &str, f32, RelationType)>(&self, mut f: F) {
        for rel in &self.relations {
            if rel.deleted { continue; }
            f(&rel.source_key, &rel.target_key, rel.strength, rel.rel_type);
        }
    }

    fn node_weight(&self, key: &str) -> f64 {
        let cfg = crate::config::get();
        self.get_node(key)
            .ok()
            .flatten()
            .map(|n| n.weight as f64)
            .unwrap_or(cfg.default_node_weight)
    }
}