neovm-core 0.0.1

use super::*;

// -----------------------------------------------------------------------
// BookmarkManager unit tests
// -----------------------------------------------------------------------

#[test]
fn set_get_delete() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();

    let bm = Bookmark {
        name: "test".to_string(),
        filename: Some("/tmp/test.txt".to_string()),
        position: 42,
        front_context: Some("after".to_string()),
        rear_context: Some("before".to_string()),
        annotation: None,
        handler: None,
    };

    mgr.set("test", bm);
    assert!(mgr.get("test").is_some());
    assert_eq!(mgr.get("test").unwrap().position, 42);
    assert_eq!(
        mgr.get("test").unwrap().filename.as_deref(),
        Some("/tmp/test.txt")
    );

    assert!(mgr.delete("test"));
    assert!(mgr.get("test").is_none());
    assert!(!mgr.delete("test")); // already gone
}

#[test]
fn rename() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();

    let bm = Bookmark {
        name: "old".to_string(),
        filename: None,
        position: 10,
        front_context: None,
        rear_context: None,
        annotation: None,
        handler: None,
    };
    mgr.set("old", bm);

    assert!(mgr.rename("old", "new"));
    assert!(mgr.get("old").is_none());
    assert!(mgr.get("new").is_some());
    assert_eq!(mgr.get("new").unwrap().name, "new");
    assert_eq!(mgr.get("new").unwrap().position, 10);
}

#[test]
fn rename_nonexistent() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();
    assert!(!mgr.rename("nope", "whatever"));
}

#[test]
fn rename_collision() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();
    let bm1 = Bookmark {
        name: "a".to_string(),
        filename: None,
        position: 1,
        front_context: None,
        rear_context: None,
        annotation: None,
        handler: None,
    };
    let bm2 = Bookmark {
        name: "b".to_string(),
        filename: None,
        position: 2,
        front_context: None,
        rear_context: None,
        annotation: None,
        handler: None,
    };
    mgr.set("a", bm1);
    mgr.set("b", bm2);

    // Cannot rename a -> b when b already exists
    assert!(!mgr.rename("a", "b"));

    // Renaming to self is fine
    assert!(mgr.rename("a", "a"));
}

#[test]
fn all_names_sorted() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();

    for name in &["zebra", "alpha", "middle"] {
        let bm = Bookmark {
            name: name.to_string(),
            filename: None,
            position: 1,
            front_context: None,
            rear_context: None,
            annotation: None,
            handler: None,
        };
        mgr.set(name, bm);
    }

    let names = mgr.all_names();
    assert_eq!(names, vec!["alpha", "middle", "zebra"]);
}

#[test]
fn most_recent_tracking() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();

    for name in &["first", "second", "third"] {
        let bm = Bookmark {
            name: name.to_string(),
            filename: None,
            position: 1,
            front_context: None,
            rear_context: None,
            annotation: None,
            handler: None,
        };
        mgr.set(name, bm);
    }

    // Most recent should be "third"
    assert_eq!(mgr.recent_names()[0], "third");
    assert_eq!(mgr.recent_names()[1], "second");
    assert_eq!(mgr.recent_names()[2], "first");

    // Re-set "first" -> moves to front
    let bm = Bookmark {
        name: "first".to_string(),
        filename: None,
        position: 99,
        front_context: None,
        rear_context: None,
        annotation: None,
        handler: None,
    };
    mgr.set("first", bm);
    assert_eq!(mgr.recent_names()[0], "first");
}

#[test]
fn serialize_deserialize() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();

    let bm1 = Bookmark {
        name: "alpha".to_string(),
        filename: Some("/home/test/file.el".to_string()),
        position: 100,
        front_context: Some("(defun".to_string()),
        rear_context: Some(";;".to_string()),
        annotation: Some("Important function".to_string()),
        handler: None,
    };
    let bm2 = Bookmark {
        name: "beta".to_string(),
        filename: None,
        position: 1,
        front_context: None,
        rear_context: None,
        annotation: None,
        handler: Some("my-handler".to_string()),
    };
    mgr.set("alpha", bm1);
    mgr.set("beta", bm2);

    let data = mgr.save_to_string();
    assert!(!data.is_empty());

    // Load into a fresh manager
    let mut mgr2 = BookmarkManager::new();
    mgr2.load_from_string(&data);

    let names = mgr2.all_names();
    assert_eq!(names, vec!["alpha", "beta"]);

    let a = mgr2.get("alpha").unwrap();
    assert_eq!(a.position, 100);
    assert_eq!(a.filename.as_deref(), Some("/home/test/file.el"));
    assert_eq!(a.front_context.as_deref(), Some("(defun"));
    assert_eq!(a.rear_context.as_deref(), Some(";;"));
    assert_eq!(a.annotation.as_deref(), Some("Important function"));
    assert!(a.handler.is_none());

    let b = mgr2.get("beta").unwrap();
    assert_eq!(b.position, 1);
    assert!(b.filename.is_none());
    assert_eq!(b.handler.as_deref(), Some("my-handler"));
}

#[test]
fn load_empty_string() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();
    let bm = Bookmark {
        name: "test".to_string(),
        filename: None,
        position: 1,
        front_context: None,
        rear_context: None,
        annotation: None,
        handler: None,
    };
    mgr.set("test", bm);

    mgr.load_from_string("");
    assert!(mgr.all_names().is_empty());
}

#[test]
fn modified_flag() {
    crate::test_utils::init_test_tracing();
    let mut mgr = BookmarkManager::new();
    assert!(!mgr.is_modified());

    let bm = Bookmark {
        name: "test".to_string(),
        filename: None,
        position: 1,
        front_context: None,
        rear_context: None,
        annotation: None,
        handler: None,
    };
    mgr.set("test", bm);
    assert!(mgr.is_modified());

    mgr.mark_saved();
    assert!(!mgr.is_modified());

    mgr.delete("test");
    assert!(mgr.is_modified());
}

// -----------------------------------------------------------------------
// Builtin-level tests
// -----------------------------------------------------------------------

fn set_current_buffer_file(eval: &mut super::super::eval::Context, path: &str) {
    if let Some(buffer) = eval.buffers.current_buffer_mut() {
        buffer.file_name = Some(path.to_string());
    }
}

#[test]
fn test_builtin_bookmark_set_and_jump() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/test.el");

    // bookmark-set
    let result = builtin_bookmark_set(&mut eval, vec![Value::string("my-bookmark")]);
    assert!(result.is_ok());
    assert!(result.unwrap().is_nil());

    // bookmark-jump returns alist
    let result = builtin_bookmark_jump(&mut eval, vec![Value::string("my-bookmark")]);
    assert!(result.is_ok());
    let alist = result.unwrap();
    assert!(alist.is_list());

    // bookmark-jump on nonexistent -> error
    let result = builtin_bookmark_jump(&mut eval, vec![Value::string("nope")]);
    assert!(result.is_err());
}

#[test]
fn test_builtin_bookmark_jump_permissive_designators() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();

    // nil designator is a dedicated error in GNU Emacs.
    let nil_result = builtin_bookmark_jump(&mut eval, vec![Value::NIL]);
    assert!(nil_result.is_err());

    // Non-string designators are tolerated and return nil.
    let int_result = builtin_bookmark_jump(&mut eval, vec![Value::fixnum(1)]);
    assert!(int_result.unwrap().is_nil());

    let list_result =
        builtin_bookmark_jump(&mut eval, vec![Value::list(vec![Value::symbol("foo")])]);
    assert!(list_result.unwrap().is_nil());

    // Optional second argument is accepted.
    let missing_with_flag =
        builtin_bookmark_jump(&mut eval, vec![Value::string("missing"), Value::T]);
    assert!(missing_with_flag.is_err());
}

#[test]
fn test_builtin_bookmark_delete() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/delete.el");

    // Set a bookmark
    builtin_bookmark_set(&mut eval, vec![Value::string("del-me")]).unwrap();

    // Delete it (returns nil) and verify side effect.
    let result = builtin_bookmark_delete(&mut eval, vec![Value::string("del-me")]);
    assert!(result.is_ok());
    assert!(result.unwrap().is_nil());
    assert!(eval.bookmarks.get("del-me").is_none());

    // Delete again -> nil (not found).
    let result = builtin_bookmark_delete(&mut eval, vec![Value::string("del-me")]);
    assert!(result.is_ok());
    assert!(result.unwrap().is_nil());

    // Non-string payloads are accepted and return nil.
    let result = builtin_bookmark_delete(&mut eval, vec![Value::fixnum(1)]);
    assert!(result.is_ok());
    assert!(result.unwrap().is_nil());

    // Optional second argument is accepted.
    let result = builtin_bookmark_delete(&mut eval, vec![Value::fixnum(1), Value::T]);
    assert!(result.is_ok());
    assert!(result.unwrap().is_nil());
}

#[test]
fn test_builtin_bookmark_rename() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/rename.el");

    builtin_bookmark_set(&mut eval, vec![Value::string("old-name")]).unwrap();

    // Rename
    let result = builtin_bookmark_rename(
        &mut eval,
        vec![Value::string("old-name"), Value::string("new-name")],
    );
    assert!(result.is_ok());

    // Old name gone, new name exists.
    assert!(eval.bookmarks.get("old-name").is_none());
    assert!(eval.bookmarks.get("new-name").is_some());
}

#[test]
fn test_builtin_bookmark_rename_permissive_designators() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/rename-permissive.el");
    builtin_bookmark_set(&mut eval, vec![Value::string("old-name")]).unwrap();

    // One-arg calls fall back to prompt behavior in batch mode and error.
    let one_arg = builtin_bookmark_rename(&mut eval, vec![Value::string("old-name")]);
    assert!(one_arg.is_err());

    // Non-cons old payloads signal wrong-type in this compatibility path.
    let ints = builtin_bookmark_rename(&mut eval, vec![Value::fixnum(1), Value::fixnum(2)]);
    assert!(ints.is_err());

    // Cons/list old payloads with non-string NEW are tolerated and return nil.
    let list_ok = builtin_bookmark_rename(
        &mut eval,
        vec![
            Value::list(vec![Value::symbol("a")]),
            Value::list(vec![Value::symbol("b")]),
        ],
    );
    assert!(list_ok.unwrap().is_nil());

    // Cons/list old payloads with string NEW error on invalid bookmark designator.
    let list_str = builtin_bookmark_rename(
        &mut eval,
        vec![
            Value::list(vec![Value::symbol("a")]),
            Value::string("new-name"),
        ],
    );
    assert!(list_str.is_err());

    // String path still renames when the source bookmark exists.
    let rename_ok = builtin_bookmark_rename(
        &mut eval,
        vec![Value::string("old-name"), Value::string("new-name")],
    );
    assert!(rename_ok.is_ok());
    assert!(eval.bookmarks.get("old-name").is_none());
    assert!(eval.bookmarks.get("new-name").is_some());
}

#[test]
fn test_builtin_bookmark_all_names() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/all-names.el");
    builtin_bookmark_set(&mut eval, vec![Value::string("z-bookmark")]).unwrap();
    builtin_bookmark_set(&mut eval, vec![Value::string("a-bookmark")]).unwrap();

    let result = builtin_bookmark_all_names(&mut eval, vec![]).unwrap();
    let names = super::super::value::list_to_vec(&result).unwrap();
    assert_eq!(names.len(), 2);
    assert_eq!(names[0].as_str(), Some("a-bookmark"));
    assert_eq!(names[1].as_str(), Some("z-bookmark"));
}

#[test]
fn test_builtin_bookmark_get_filename() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/file.el");
    builtin_bookmark_set(&mut eval, vec![Value::string("with-file")]).unwrap();

    let found = builtin_bookmark_get_filename(&mut eval, vec![Value::string("with-file")]).unwrap();
    assert_eq!(found.as_str(), Some("/tmp/file.el"));

    let missing = builtin_bookmark_get_filename(&mut eval, vec![Value::string("missing")]).unwrap();
    assert!(missing.is_nil());
}

#[test]
fn test_builtin_bookmark_get_position() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/position.el");
    builtin_bookmark_set(&mut eval, vec![Value::string("at-point")]).unwrap();

    let found = builtin_bookmark_get_position(&mut eval, vec![Value::string("at-point")]).unwrap();
    assert_eq!(found.as_int(), Some(0));

    let missing = builtin_bookmark_get_position(&mut eval, vec![Value::string("missing")]).unwrap();
    assert!(missing.is_nil());
}

#[test]
fn test_builtin_bookmark_get_annotation() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/annotation.el");
    builtin_bookmark_set(&mut eval, vec![Value::string("with-note")]).unwrap();
    builtin_bookmark_set_annotation(
        &mut eval,
        vec![Value::string("with-note"), Value::string("note")],
    )
    .unwrap();

    let found =
        builtin_bookmark_get_annotation(&mut eval, vec![Value::string("with-note")]).unwrap();
    assert_eq!(found.as_str(), Some("note"));

    let missing =
        builtin_bookmark_get_annotation(&mut eval, vec![Value::string("missing")]).unwrap();
    assert!(missing.is_nil());
}

#[test]
fn test_builtin_bookmark_set_annotation() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    set_current_buffer_file(&mut eval, "/tmp/set-annotation.el");
    builtin_bookmark_set(&mut eval, vec![Value::string("entry")]).unwrap();

    let set_result = builtin_bookmark_set_annotation(
        &mut eval,
        vec![Value::string("entry"), Value::string("note")],
    )
    .unwrap();
    assert_eq!(set_result.as_str(), Some("note"));

    let got = builtin_bookmark_get_annotation(&mut eval, vec![Value::string("entry")]).unwrap();
    assert_eq!(got.as_str(), Some("note"));

    let missing = builtin_bookmark_set_annotation(
        &mut eval,
        vec![Value::string("missing"), Value::string("note")],
    )
    .unwrap();
    assert!(missing.is_nil());
}

#[test]
fn test_builtin_bookmark_save_load() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();
    let save_file = "/tmp/neovm-bookmark-save-load.data";

    set_current_buffer_file(&mut eval, "/file1.el");
    builtin_bookmark_set(&mut eval, vec![Value::string("bm1")]).unwrap();
    set_current_buffer_file(&mut eval, "/file2.el");
    builtin_bookmark_set(&mut eval, vec![Value::string("bm2")]).unwrap();

    // Save to an explicit file path.
    let result = builtin_bookmark_save(
        &mut eval,
        vec![Value::NIL, Value::string(save_file.to_string())],
    );
    assert!(result.is_ok());
    assert!(result.unwrap().is_nil());

    // Clear and load
    eval.bookmarks = BookmarkManager::new();
    let result = builtin_bookmark_load(&mut eval, vec![Value::string(save_file.to_string())]);
    assert!(result.is_ok());
    let load_message = result.unwrap();
    assert_eq!(
        load_message.as_str(),
        Some("Loading bookmarks from /tmp/neovm-bookmark-save-load.data...done")
    );

    // Verify restored bookmark payloads.
    let bm1 = eval.bookmarks.get("bm1").expect("bm1 restored");
    assert_eq!(bm1.filename.as_deref(), Some("/file1.el"));

    let bm2 = eval.bookmarks.get("bm2").expect("bm2 restored");
    assert_eq!(bm2.filename.as_deref(), Some("/file2.el"));

    // NO-MSG suppresses the loading message.
    let result = builtin_bookmark_load(
        &mut eval,
        vec![Value::string(save_file.to_string()), Value::NIL, Value::T],
    );
    assert!(result.is_ok());
    assert!(result.unwrap().is_nil());
}

#[test]
fn test_wrong_arg_count() {
    crate::test_utils::init_test_tracing();
    use super::super::eval::Context;

    let mut eval = Context::new();

    // bookmark-set needs between 1 and 2 args.
    let result = builtin_bookmark_set(&mut eval, vec![]);
    assert!(result.is_err());
    let result = builtin_bookmark_set(
        &mut eval,
        vec![Value::string("name"), Value::NIL, Value::NIL],
    );
    assert!(result.is_err());

    // bookmark-jump requires at least one argument.
    let result = builtin_bookmark_jump(&mut eval, vec![]);
    assert!(result.is_err());

    // bookmark-delete requires at least one argument.
    let result = builtin_bookmark_delete(&mut eval, vec![]);
    assert!(result.is_err());

    // bookmark-rename with one arg errors in batch mode.
    let result = builtin_bookmark_rename(&mut eval, vec![Value::string("x")]);
    assert!(result.is_err());
}