//! The search connection has to *open* at the ceiling it was sized for.
//!
//! `db::schema`'s unit tests cover the arithmetic; this covers the wiring,
//! which is where it can silently do nothing: the ceiling is resolved inside
//! `open_search_reader` from a `sqlite_stat1` read and a process-global, and a
//! break anywhere along that path leaves a connection quietly running on the
//! read-only profile's 4 MiB with every test still green.
//!
//! Its own integration binary, with one `#[test]`, because it sets the
//! process-global key and cache override; see `tests/encrypted.rs`.

use quicksearch_core::db;
use quicksearch_core::db::schema::{
    recommended_search_cache_mib, SEARCH_CACHE_MAX_MIB, SEARCH_CACHE_PLAIN_MIB,
};
use quicksearch_core::testutil::{measurement_key, seed_index, Scratch, SeedSpec};

/// Enough rows that the recommendation clears the floor and is derived rather
/// than clamped: at 168 B/file, 16 MiB is reached around 100k. Seeded without
/// content: the FTS write is the slow part and this measures nothing about it.
const FILES: usize = 150_000;

fn spec() -> SeedSpec {
    SeedSpec {
        files: FILES,
        // No document bodies at all; `content_every` past `files` never fires.
        content_every: FILES + 1,
        commit_every: 25_000,
        dup_every: 2,
        dir_depth: 6,
        ..SeedSpec::default()
    }
}

/// `PRAGMA cache_size` reads back as the negative KiB it was set to.
fn cache_mib(conn: &rusqlite::Connection) -> i64 {
    let kib: i64 = conn
        .query_row("PRAGMA cache_size", [], |r| r.get(0))
        .unwrap();
    assert!(
        kib < 0,
        "cache_size came back as {} — a positive value is a *page* count, \
         which would mean the KiB form never reached SQLite",
        kib
    );
    -kib / 1024
}

#[test]
fn the_search_connection_opens_at_the_ceiling_it_was_sized_for() {
    let (_dir, path) = Scratch::db("searchcache");
    let db_path = path.to_string_lossy().into_owned();

    // --- keyed, automatic -------------------------------------------------
    db::set_process_key(Some(measurement_key()));
    db::set_search_cache_override(None);
    seed_index(&path, &spec());

    // Without stats there is nothing to derive from, so the floor is correct
    // and is what must come out.
    {
        let conn = db::open::open_search_reader(&db_path).unwrap();
        assert_eq!(
            cache_mib(&conn),
            recommended_search_cache_mib(0, true),
            "a never-analyzed index must fall back, not guess"
        );
    }

    // ANALYZE stands in for the `PRAGMA optimize` a real indexing run leaves
    // behind; from here the row count is readable and the ceiling tracks it.
    {
        let conn = db::open_existing(&db_path, true).unwrap();
        conn.execute_batch("ANALYZE;").unwrap();
    }
    let expected = recommended_search_cache_mib(FILES as i64, true);
    assert!(
        expected > recommended_search_cache_mib(0, true),
        "the corpus must be big enough to clear the floor, or this proves nothing"
    );
    {
        let conn = db::open::open_search_reader(&db_path).unwrap();
        assert_eq!(
            cache_mib(&conn),
            expected,
            "the derived ceiling did not reach the connection"
        );
    }

    // --- an explicit override wins, including past the automatic cap ------
    let big = SEARCH_CACHE_MAX_MIB * 2;
    db::set_search_cache_override(Some(big));
    {
        let conn = db::open::open_search_reader(&db_path).unwrap();
        assert_eq!(
            cache_mib(&conn),
            big,
            "an explicit ceiling must be applied verbatim, above the cap"
        );
    }
    db::set_search_cache_override(None);

    // --- plain, automatic -------------------------------------------------
    // Same corpus, no key: the sweep found no knee unencrypted, so this must
    // be flat regardless of how large the index is.
    let (_plain_dir, plain) = Scratch::db("searchcache-plain");
    db::set_process_key(None);
    seed_index(&plain, &spec());
    {
        let conn = db::open_existing(&plain.to_string_lossy(), true).unwrap();
        conn.execute_batch("ANALYZE;").unwrap();
    }
    {
        let conn = db::open::open_search_reader(&plain.to_string_lossy()).unwrap();
        assert_eq!(
            cache_mib(&conn),
            SEARCH_CACHE_PLAIN_MIB,
            "an unencrypted index must not grow its cache with the corpus"
        );
    }
}