// Package engram basic test.
//
// NOTE: This test requires the FFI shared library to be compiled first:
//
//	cargo build --package engram-ffi --release
//
// Then run:
//
//	DYLD_LIBRARY_PATH=../../target/release go test ./...
//	# or on Linux:
//	LD_LIBRARY_PATH=../../target/release go test ./...
package engram

import (
	"os"
	"path/filepath"
	"testing"
)

// TestOpenClose verifies that a database can be opened and closed without errors.
func TestOpenClose(t *testing.T) {
	dir := t.TempDir()
	db, err := Open(filepath.Join(dir, "test-engram"))
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	defer db.Close()

	n, err := db.NodeCount()
	if err != nil {
		t.Fatalf("NodeCount: %v", err)
	}
	if n != 0 {
		t.Errorf("expected 0 nodes, got %d", n)
	}
}

// TestPutGetNode verifies node storage and retrieval roundtrip.
func TestPutGetNode(t *testing.T) {
	dir := t.TempDir()
	db, err := Open(filepath.Join(dir, "test-engram"))
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	defer db.Close()

	input := &NodeInput{
		Content:    "Spreading activation is the core retrieval mechanism",
		NodeType:   "Concept",
		Tier:       "Semantic",
		Importance: 0.9,
		Embedding:  []float32{0.1, 0.2, 0.3, 0.4},
	}

	id, err := db.PutNode(input)
	if err != nil {
		t.Fatalf("PutNode: %v", err)
	}
	if id == "" {
		t.Fatal("expected non-empty UUID")
	}

	node, err := db.GetNode(id)
	if err != nil {
		t.Fatalf("GetNode: %v", err)
	}
	if node == nil {
		t.Fatal("expected node, got nil")
	}
	if node.Content != input.Content {
		t.Errorf("content mismatch: got %q, want %q", node.Content, input.Content)
	}
}

// TestNodeCount verifies node count increments.
func TestNodeCount(t *testing.T) {
	dir := t.TempDir()
	db, err := Open(filepath.Join(dir, "test-engram"))
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	defer db.Close()

	for i := 0; i < 3; i++ {
		_, err := db.PutNode(&NodeInput{
			Content:   "node content",
			Embedding: []float32{float32(i), 0.0, 0.0},
		})
		if err != nil {
			t.Fatalf("PutNode[%d]: %v", i, err)
		}
	}

	n, err := db.NodeCount()
	if err != nil {
		t.Fatalf("NodeCount: %v", err)
	}
	if n != 3 {
		t.Errorf("expected 3 nodes, got %d", n)
	}
}

// TestDecay verifies salience decay runs without error.
func TestDecay(t *testing.T) {
	dir := t.TempDir()
	db, err := Open(filepath.Join(dir, "test-engram"))
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	defer db.Close()

	_, err = db.PutNode(&NodeInput{
		Content:   "test node",
		Embedding: []float32{1.0, 0.0},
	})
	if err != nil {
		t.Fatalf("PutNode: %v", err)
	}

	updated, err := db.Decay(0.95)
	if err != nil {
		t.Fatalf("Decay: %v", err)
	}
	if updated == 0 {
		t.Error("expected at least one node to be decayed")
	}
}

// ensure test file exists (compile guard)
var _ = os.DevNull