microscope-memory 1.2.0

//! Criterion benchmarks for the Microscope Memory pipeline.

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use std::path::Path;

/// Create a temporary test environment with config pointing to fixture data.
fn setup_test_env() -> (tempfile::TempDir, microscope_memory::config::Config) {
    let tmp = tempfile::tempdir().expect("create temp dir");
    let output_dir = tmp.path().join("output");
    std::fs::create_dir_all(&output_dir).unwrap();

    let manifest_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let fixtures = manifest_dir.join("tests").join("fixtures");
    let layers_dir = fixtures.join("layers");

    let mut config = microscope_memory::config::Config::default();
    config.paths.layers_dir = layers_dir.to_string_lossy().to_string();
    config.paths.output_dir = output_dir.to_string_lossy().to_string();
    config.paths.temp_dir = tmp.path().join("tmp").to_string_lossy().to_string();
    config.memory_layers.layers = vec!["long_term".to_string(), "short_term".to_string()];
    config.embedding.provider = "mock".to_string();
    config.embedding.dim = 128;
    config.embedding.max_depth = 4;

    (tmp, config)
}

/// Build the index once and return the temp dir, config, and reader for reuse.
fn setup_built_env() -> (
    tempfile::TempDir,
    microscope_memory::config::Config,
    microscope_memory::MicroscopeReader,
) {
    let (tmp, config) = setup_test_env();
    microscope_memory::build::build(&config, true, true).expect("build");
    let reader = microscope_memory::MicroscopeReader::open(&config).expect("open reader");
    (tmp, config, reader)
}

// ─── Build pipeline ──────────────────────────────────────

fn bench_build_pipeline(c: &mut Criterion) {
    c.bench_function("build_pipeline", |b| {
        b.iter_with_setup(setup_test_env, |(_tmp, config)| {
            microscope_memory::build::build(black_box(&config), true, true).expect("build");
        });
    });
}

// ─── Text search (find_text) ─────────────────────────────

fn bench_find_text(c: &mut Criterion) {
    let (_tmp, _config, reader) = setup_built_env();

    let mut group = c.benchmark_group("find_text");
    group.bench_function("existing_term", |b| {
        b.iter(|| reader.find_text(black_box("Rust"), black_box(10)));
    });
    group.bench_function("missing_term", |b| {
        b.iter(|| reader.find_text(black_box("xyznonexistent123"), black_box(10)));
    });
    group.finish();
}

// ─── Spatial lookup (reader.look) ────────────────────────

fn bench_look(c: &mut Criterion) {
    let (_tmp, config, reader) = setup_built_env();

    let mut group = c.benchmark_group("spatial_look");
    for depth in [1u8, 2, 3] {
        group.bench_function(format!("depth_{}", depth), |b| {
            b.iter(|| {
                reader.look(
                    black_box(&config),
                    black_box(0.5),
                    black_box(0.5),
                    black_box(0.5),
                    black_box(depth),
                    black_box(5),
                )
            });
        });
    }
    group.finish();
}

// ─── MQL query (parse + execute) ─────────────────────────

fn bench_mql_query(c: &mut Criterion) {
    let (_tmp, config, reader) = setup_built_env();
    let append_path = Path::new(&config.paths.output_dir).join("append.bin");
    let appended = microscope_memory::read_append_log(&append_path);

    let mut group = c.benchmark_group("mql_query");
    group.bench_function("keyword_search", |b| {
        b.iter(|| {
            let q = microscope_memory::query::parse(black_box("\"Rust\""));
            microscope_memory::query::execute(&q, black_box(&reader), black_box(&appended))
        });
    });
    group.bench_function("depth_filter", |b| {
        b.iter(|| {
            let q = microscope_memory::query::parse(black_box("depth:3 \"memory\""));
            microscope_memory::query::execute(&q, black_box(&reader), black_box(&appended))
        });
    });
    group.finish();
}

// ─── CRC16 computation ──────────────────────────────────

fn bench_crc16(c: &mut Criterion) {
    let short_data = b"hello world";
    let medium_data = vec![0xABu8; 256];
    let long_data = vec![0xCDu8; 4096];

    let mut group = c.benchmark_group("crc16_ccitt");
    group.bench_function("short_11b", |b| {
        b.iter(|| microscope_memory::crc16_ccitt(black_box(short_data)));
    });
    group.bench_function("medium_256b", |b| {
        b.iter(|| microscope_memory::crc16_ccitt(black_box(&medium_data)));
    });
    group.bench_function("long_4096b", |b| {
        b.iter(|| microscope_memory::crc16_ccitt(black_box(&long_data)));
    });
    group.finish();
}

// ─── Content coords ─────────────────────────────────────

fn bench_content_coords(c: &mut Criterion) {
    let mut group = c.benchmark_group("content_coords");
    group.bench_function("hash_only", |b| {
        b.iter(|| {
            microscope_memory::content_coords(
                black_box("Rust memory system benchmark test"),
                black_box("long_term"),
            )
        });
    });
    group.bench_function("blended_w0.5", |b| {
        b.iter(|| {
            microscope_memory::content_coords_blended(
                black_box("Rust memory system benchmark test"),
                black_box("long_term"),
                black_box(0.5),
            )
        });
    });
    group.bench_function("blended_w0.0", |b| {
        b.iter(|| {
            microscope_memory::content_coords_blended(
                black_box("Rust memory system benchmark test"),
                black_box("long_term"),
                black_box(0.0),
            )
        });
    });
    group.finish();
}

// ─── Append log read/write ──────────────────────────────

fn bench_append_log(c: &mut Criterion) {
    let mut group = c.benchmark_group("append_log");

    group.bench_function("store_and_read_cycle", |b| {
        b.iter_with_setup(
            || {
                let (tmp, config) = setup_test_env();
                microscope_memory::build::build(&config, true, true).expect("build");
                (tmp, config)
            },
            |(_tmp, config)| {
                microscope_memory::store_memory(
                    black_box(&config),
                    black_box("Benchmark test memory entry about quantum computing"),
                    black_box("long_term"),
                    black_box(5),
                )
                .expect("store");
                let append_path = Path::new(&config.paths.output_dir).join("append.bin");
                let entries = microscope_memory::read_append_log(black_box(&append_path));
                assert!(!entries.is_empty());
            },
        );
    });

    group.bench_function("read_existing", |b| {
        // Setup: build and store one entry, then benchmark reads only
        let (_tmp, config) = setup_test_env();
        microscope_memory::build::build(&config, true, true).expect("build");
        microscope_memory::store_memory(
            &config,
            "Benchmark pre-stored memory entry",
            "long_term",
            5,
        )
        .expect("store");
        let append_path = Path::new(&config.paths.output_dir).join("append.bin");

        b.iter(|| {
            let entries = microscope_memory::read_append_log(black_box(&append_path));
            assert!(!entries.is_empty());
        });
    });

    group.finish();
}

// ─── Candle embedding device selection ─────────────────

#[cfg(all(not(target_arch = "wasm32"), feature = "embeddings"))]
fn bench_embedding_device(c: &mut Criterion) {
    use candle_core::Device;

    let mut group = c.benchmark_group("embedding_device");

    group.bench_function("cpu_explicit", |b| {
        b.iter(|| {
            let _device = black_box(Device::Cpu);
        });
    });

    group.bench_function("cuda_if_available_false", |b| {
        b.iter(|| {
            let _device = black_box(Device::cuda_if_available(0).unwrap_or(Device::Cpu));
        });
    });

    group.bench_function("cuda_lazy_with_gpu_request", |b| {
        b.iter(|| {
            // This mirrors the lazy GPU activation in embeddings.rs:
            // if use_gpu is true, try CUDA(0); fall back to CPU.
            let device = if let Ok(d) = Device::cuda_if_available(0) {
                d
            } else {
                Device::Cpu
            };
            let _ = black_box(device);
        });
    });

    group.finish();
}

#[cfg(not(all(not(target_arch = "wasm32"), feature = "embeddings")))]
fn bench_embedding_device(_c: &mut Criterion) {}

criterion_group!(
    benches,
    bench_build_pipeline,
    bench_find_text,
    bench_look,
    bench_mql_query,
    bench_crc16,
    bench_content_coords,
    bench_append_log,
);
criterion_main!(benches, cognitive_benches);

// ─── Morphogenesis benchmarks ────────────────────────────

fn bench_morphogenesis_growth(c: &mut Criterion) {
    use microscope_memory::morphogenesis::*;

    let mut group = c.benchmark_group("morphogenesis");

    group.bench_function("mycelium_growth", |b| {
        b.iter(|| {
            let seed = Seed::new("bench", 0.0, 0.0, 0.0, "service");
            let field = MorphogenField::new();
            let config = GrowthConfig::mycelium_default();
            let org = mycelium_growth(black_box(&seed), black_box(&field), black_box(&config));
            black_box(org.nodes.len());
        });
    });

    group.bench_function("capillary_growth", |b| {
        b.iter(|| {
            let seed = Seed::new("bench", 0.0, 0.0, 0.0, "gateway");
            let field = MorphogenField::new();
            let config = GrowthConfig::capillary_default();
            let org = capillary_growth(black_box(&seed), black_box(&field), black_box(&config));
            black_box(org.nodes.len());
        });
    });

    group.bench_function("fractal_growth", |b| {
        b.iter(|| {
            let seed = Seed::new("bench", 0.0, 0.0, 0.0, "service");
            let field = MorphogenField::new();
            let config = GrowthConfig::fractal_lsystem_default();
            let org = fractal_growth(black_box(&seed), black_box(&field), black_box(&config));
            black_box(org.nodes.len());
        });
    });

    group.bench_function("slime_mold_growth", |b| {
        b.iter(|| {
            let seed = Seed::new("bench", 0.0, 0.0, 0.0, "router");
            let field = MorphogenField::new();
            let config = GrowthConfig::slime_mold_default();
            let org = slime_mold_growth(black_box(&seed), black_box(&field), black_box(&config));
            black_box(org.nodes.len());
        });
    });

    group.finish();
}

fn bench_morphogenesis_evaluate_fitness(c: &mut Criterion) {
    use microscope_memory::morphogenesis::*;

    let seed = Seed::new("bench", 0.0, 0.0, 0.0, "service");
    let field = MorphogenField::new();
    let config = GrowthConfig::mycelium_default();
    let organism = mycelium_growth(&seed, &field, &config);

    c.bench_function("evaluate_fitness", |b| {
        b.iter(|| {
            let result =
                evaluate_fitness(black_box(&organism), black_box(&FitnessObjective::Balanced));
            black_box(result.score);
        });
    });
}

// ─── Executive benchmarks ────────────────────────────────

fn bench_executive_schedule(c: &mut Criterion) {
    use microscope_memory::executive::Executive;

    let exec = Executive::new();
    exec.register_module("test1", "Test Module 1", 100, 0.5, vec![]);
    exec.register_module("test2", "Test Module 2", 200, 0.3, vec![]);
    exec.register_module("test3", "Test Module 3", 50, 0.8, vec![]);

    c.bench_function("executive_schedule", |b| {
        b.iter(|| {
            let plan = exec.schedule();
            black_box(plan.module_order.len());
        });
    });

    c.bench_function("executive_cycle", |b| {
        b.iter(|| {
            let executed = exec.cycle();
            black_box(executed.len());
        });
    });
}

// ─── Pattern Recognition benchmarks ──────────────────────

fn bench_pattern_recognition(c: &mut Criterion) {
    use microscope_memory::pattern_recognition::*;

    let recognizer = PatternRecognizer::new();

    let elements: Vec<String> = (0..100).map(|i| format!("word_{}", i % 20)).collect();

    c.bench_function("find_sequences", |b| {
        b.iter(|| {
            let patterns = recognizer.find_sequences(black_box(&elements), black_box("bench"));
            black_box(patterns.len());
        });
    });

    // Structural motifs
    let edges: Vec<(String, String, f64)> = (0..50)
        .map(|i| {
            (
                format!("node_{}", i),
                format!("node_{}", (i + 1) % 50),
                rand::random::<f64>(),
            )
        })
        .collect();

    c.bench_function("find_motifs", |b| {
        b.iter(|| {
            let patterns = recognizer.find_motifs(black_box(&edges), black_box("bench"));
            black_box(patterns.len());
        });
    });
}

// ─── Planner benchmarks ──────────────────────────────────

fn bench_planning(c: &mut Criterion) {
    use microscope_memory::planning::Planner;

    let planner = Planner::new();
    let goal_id = planner.add_goal("learn", "Learn about Rust", 100, None);

    c.bench_function("decompose_goal", |b| {
        b.iter(|| {
            let subs = planner.decompose_goal(black_box(goal_id));
            black_box(subs.len());
        });
    });

    c.bench_function("create_plan", |b| {
        b.iter(|| {
            let plan = planner.create_plan(black_box(goal_id));
            black_box(plan.actions.len());
        });
    });
}

// ─── Autopoiesis benchmarks ──────────────────────────────

fn bench_autopoiesis(c: &mut Criterion) {
    use microscope_memory::autopoiesis::AutopoiesisEngine;

    let engine = AutopoiesisEngine::new();
    engine.register_template(
        "test_tmpl",
        "test_module",
        "fn hello() { println!(\"{{name}}\"); }",
        vec!["name".to_string()],
        "Test template",
    );

    c.bench_function("autopoiesis_generate_template", |b| {
        b.iter(|| {
            let mut vars = std::collections::HashMap::new();
            vars.insert("name".to_string(), "world".to_string());
            let code = engine.generate_from_template(black_box("test_tmpl"), black_box(&vars));
            black_box(code);
        });
    });

    c.bench_function("autopoiesis_propose_mutation", |b| {
        b.iter(|| {
            let id = engine.propose_mutation(
                black_box("bench_mut"),
                black_box(microscope_memory::autopoiesis::MutationType::Modification),
                black_box("test_module"),
                black_box("fn test() {}"),
                black_box("benchmark"),
                black_box("system"),
            );
            black_box(id);
        });
    });
}

criterion_group!(
    cognitive_benches,
    bench_morphogenesis_growth,
    bench_embedding_device,
    bench_morphogenesis_evaluate_fitness,
    bench_executive_schedule,
    bench_pattern_recognition,
    bench_planning,
    bench_autopoiesis,
);