import { afterEach, beforeEach, describe, expect, it } from "bun:test";
import { cleanupTestDb, clearTestEnv, createTestDb, setTestEnv } from "./setup.js";

const TEST_DB = "test-vector.db";

describe("MCP Handlers Module", () => {
  beforeEach(() => {
    setTestEnv();
    cleanupTestDb(TEST_DB);
  });

  afterEach(() => {
    cleanupTestDb(TEST_DB);
    clearTestEnv();
  });

  it("should validate embedding dimension correctly", () => {
    const testVectors = [
      { dim: 3, valid: true },
      { dim: 2, valid: false },
      { dim: 4, valid: false },
    ];

    const EMBEDDING_DIM = Number(process.env.VEC_DIM ?? 3);
    
    testVectors.forEach(({ dim, valid }) => {
      const vector = new Array(dim).fill(0.5);
      const isValid = vector.length === EMBEDDING_DIM;
      expect(isValid).toBe(valid);
    });
  });

  it("should handle search results with all required fields", () => {
    const db = createTestDb(TEST_DB);

    db.exec(`
      CREATE TABLE if not exists items (
        id INTEGER PRIMARY KEY,
        content TEXT,
        path TEXT,
        created_at TEXT DEFAULT (datetime('now')),
        updated_at TEXT DEFAULT (datetime('now'))
      );
    `);

    const stmt = db.prepare(`
      INSERT INTO items (content, path) VALUES (?, ?)
    `);
    stmt.run("test content", "/test/path");

    const results = db
      .prepare(`
        SELECT content, path, created_at, updated_at
        FROM items
        WHERE id = ?
      `)
      .all(1);

    expect(results.length).toBe(1);
    const result = results[0];
    expect(result.content).toBe("test content");
    expect(result.path).toBe("/test/path");
    expect(result.created_at).toBeTruthy();
    expect(result.updated_at).toBeTruthy();

    db.close();
  });

  it("should insert item and return id", () => {
    const db = createTestDb(TEST_DB);

    db.exec(`
      CREATE TABLE if not exists items (
        id INTEGER PRIMARY KEY,
        content TEXT,
        path TEXT,
        created_at TEXT DEFAULT (datetime('now')),
        updated_at TEXT DEFAULT (datetime('now'))
      );
      DELETE FROM items;
    `);

    const stmt = db.prepare(`
      INSERT INTO items (content, path) VALUES (?, ?)
    `);
    stmt.run("inserted content", "/inserted/path");

    const items = db.prepare("SELECT * FROM items").all();
    expect(items.length).toBe(1);
    expect(items[0].content).toBe("inserted content");
    expect(items[0].path).toBe("/inserted/path");

    db.close();
  });

  it("should perform similarity search", () => {
    const db = createTestDb(TEST_DB);

    db.exec(`
      CREATE TABLE if not exists items (
        id INTEGER PRIMARY KEY,
        content TEXT,
        path TEXT,
        created_at TEXT DEFAULT (datetime('now')),
        updated_at TEXT DEFAULT (datetime('now'))
      );
      DELETE FROM items;
    `);

    const stmt = db.prepare("INSERT INTO items (content) VALUES (?)");
    stmt.run("item 1");
    stmt.run("item 2");
    stmt.run("item 3");

    const items = db.prepare("SELECT * FROM items").all();
    expect(items.length).toBe(3);

    db.close();
  });

  it("should handle empty results gracefully", () => {
    const db = createTestDb(TEST_DB);

    db.exec(`
      CREATE TABLE if not exists items (
        id INTEGER PRIMARY KEY,
        content TEXT,
        path TEXT,
        created_at TEXT DEFAULT (datetime('now')),
        updated_at TEXT DEFAULT (datetime('now'))
      );
    `);

    const results = db
      .prepare("SELECT * FROM items WHERE content LIKE ?")
      .all("%nonexistent%");

    expect(results).toEqual([]);

    db.close();
  });

  it("should preserve timestamps across operations", () => {
    const db = createTestDb(TEST_DB);

    db.exec(`
      CREATE TABLE if not exists items (
        id INTEGER PRIMARY KEY,
        content TEXT,
        path TEXT,
        created_at TEXT DEFAULT (datetime('now')),
        updated_at TEXT DEFAULT (datetime('now'))
      );
    `);

    const stmt = db.prepare("INSERT INTO items (content) VALUES (?)");
    stmt.run("test");

    const items = db.prepare("SELECT created_at, updated_at FROM items").all();
    expect(items[0].created_at).toBeTruthy();
    expect(items[0].updated_at).toBeTruthy();
    expect(items[0].created_at).toMatch(/\d{4}-\d{2}-\d{2}/);

    db.close();
  });
});