braid-core 0.1.4

use crate::antimatter::antimatter::AntimatterCrdt;
use crate::antimatter::crdt_trait::PrunableCrdt;
use crate::antimatter::json_crdt::{JsonCrdt};
use crate::antimatter::messages::{Message, Patch};
use crate::antimatter::sequence_crdt::{self, SequenceElems, SequenceNode};
use crate::core::traits::NativeRuntime;
use serde_json::json;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

/// Mock CRDT for testing antimatter coordination layer.
#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
pub struct MockSequenceCrdt {
    content: String,
    seq: u64,
}

impl PrunableCrdt for MockSequenceCrdt {
    fn apply_patch(&mut self, patch: Patch) {
        self.seq += 1;
        let range = &patch.range;
        let content = patch.content.as_str().unwrap_or("");

        if range.contains(':') {
            let parts: Vec<&str> = range.split(':').collect();
            if parts.len() == 2 {
                if let (Ok(start), Ok(end)) = (parts[0].parse::<usize>(), parts[1].parse::<usize>())
                {
                    let start = start.min(self.content.len());
                    let end = end.min(self.content.len());
                    self.content = format!(
                        "{}{}{}",
                        &self.content[..start],
                        content,
                        &self.content[end..]
                    );
                }
            }
        } else if let Ok(pos) = range.parse::<usize>() {
            let pos = pos.min(self.content.len());
            self.content = format!(
                "{}{}{}",
                &self.content[..pos],
                content,
                &self.content[pos..]
            );
        }
    }

    fn prune(&mut self, _version: &str) {}

    fn get_next_seq(&self) -> u64 {
        self.seq
    }

    fn generate_braid(
        &self,
        _known_versions: &HashMap<String, bool>,
    ) -> Vec<(String, HashMap<String, bool>, Vec<Patch>)> {
        Vec::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_sequence_node_creation() {
        let node = SequenceNode::text("alice1", "hello");
        assert_eq!(node.version, Some("alice1".to_string()));
        assert!(matches!(node.elems, SequenceElems::String(ref s) if s == "hello"));
    }

    #[test]
    fn test_json_crdt_creation() {
        let crdt = JsonCrdt::new("alice");
        assert_eq!(crdt.id, "alice");
    }

    #[test]
    fn test_antimatter_creation() {
        let messages: Arc<Mutex<Vec<Message>>> = Arc::new(Mutex::new(Vec::new()));
        let msgs = messages.clone();

        let crdt = AntimatterCrdt::new(
            Some("alice".to_string()),
            MockSequenceCrdt::default(),
            Arc::new(move |msg| {
                msgs.lock().unwrap().push(msg);
            }),
            Arc::new(NativeRuntime),
        );

        assert_eq!(crdt.id, "alice");
    }
}