import test from 'ava';
import { VectorDB } from '../index.js';
import { mkdtempSync, rmSync } from 'fs';
import { tmpdir } from 'os';
import { join } from 'path';

// Helper to create temp directory
function createTempDir() {
  return mkdtempSync(join(tmpdir(), 'ruvector-test-'));
}

// Helper to cleanup temp directory
function cleanupTempDir(dir) {
  try {
    rmSync(dir, { recursive: true, force: true });
  } catch (e) {
    console.warn('Failed to cleanup temp dir:', e.message);
  }
}

test('VectorDB - version check', (t) => {
  const { version } = require('../index.js');
  t.is(typeof version, 'function');
  t.is(typeof version(), 'string');
  t.regex(version(), /^\d+\.\d+\.\d+/);
});

test('VectorDB - hello function', (t) => {
  const { hello } = require('../index.js');
  t.is(typeof hello, 'function');
  t.is(hello(), 'Hello from Ruvector Node.js bindings!');
});

test('VectorDB - constructor with options', (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    distanceMetric: 'Euclidean',
    storagePath: join(tempDir, 'test.db'),
  });

  t.truthy(db);
  t.is(typeof db.insert, 'function');
  t.is(typeof db.search, 'function');
});

test('VectorDB - withDimensions factory', (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = VectorDB.withDimensions(128);
  t.truthy(db);
});

test('VectorDB - insert single vector', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  const id = await db.insert({
    vector: new Float32Array([1.0, 2.0, 3.0]),
    metadata: { text: 'test vector' },
  });

  t.is(typeof id, 'string');
  t.truthy(id.length > 0);
});

test('VectorDB - insert with custom ID', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  const customId = 'custom-vector-123';
  const id = await db.insert({
    id: customId,
    vector: new Float32Array([1.0, 2.0, 3.0]),
  });

  t.is(id, customId);
});

test('VectorDB - insert batch', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  const ids = await db.insertBatch([
    { vector: new Float32Array([1.0, 0.0, 0.0]) },
    { vector: new Float32Array([0.0, 1.0, 0.0]) },
    { vector: new Float32Array([0.0, 0.0, 1.0]) },
  ]);

  t.is(ids.length, 3);
  t.truthy(ids.every((id) => typeof id === 'string' && id.length > 0));
});

test('VectorDB - search exact match', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    distanceMetric: 'Euclidean',
    storagePath: join(tempDir, 'test.db'),
    hnswConfig: null, // Use flat index for testing
  });

  await db.insert({
    id: 'v1',
    vector: new Float32Array([1.0, 0.0, 0.0]),
  });

  await db.insert({
    id: 'v2',
    vector: new Float32Array([0.0, 1.0, 0.0]),
  });

  const results = await db.search({
    vector: new Float32Array([1.0, 0.0, 0.0]),
    k: 2,
  });

  t.truthy(Array.isArray(results));
  t.truthy(results.length >= 1);
  t.is(results[0].id, 'v1');
  t.true(results[0].score < 0.01);
});

test('VectorDB - search with metadata filter', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  await db.insert({
    vector: new Float32Array([1.0, 0.0, 0.0]),
    metadata: { category: 'A' },
  });

  await db.insert({
    vector: new Float32Array([0.9, 0.1, 0.0]),
    metadata: { category: 'B' },
  });

  const results = await db.search({
    vector: new Float32Array([1.0, 0.0, 0.0]),
    k: 10,
    filter: { category: 'A' },
  });

  t.truthy(results.length >= 1);
  t.is(results[0].metadata?.category, 'A');
});

test('VectorDB - get by ID', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  const id = await db.insert({
    vector: new Float32Array([1.0, 2.0, 3.0]),
    metadata: { text: 'test' },
  });

  const entry = await db.get(id);
  t.truthy(entry);
  t.deepEqual(Array.from(entry.vector), [1.0, 2.0, 3.0]);
  t.is(entry.metadata?.text, 'test');
});

test('VectorDB - get non-existent ID', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  const entry = await db.get('non-existent-id');
  t.is(entry, null);
});

test('VectorDB - delete', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  const id = await db.insert({
    vector: new Float32Array([1.0, 2.0, 3.0]),
  });

  const deleted = await db.delete(id);
  t.true(deleted);

  const entry = await db.get(id);
  t.is(entry, null);
});

test('VectorDB - delete non-existent', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  const deleted = await db.delete('non-existent-id');
  t.false(deleted);
});

test('VectorDB - len and isEmpty', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  t.true(await db.isEmpty());
  t.is(await db.len(), 0);

  await db.insert({ vector: new Float32Array([1, 2, 3]) });
  t.false(await db.isEmpty());
  t.is(await db.len(), 1);

  await db.insert({ vector: new Float32Array([4, 5, 6]) });
  t.is(await db.len(), 2);
});

test('VectorDB - cosine similarity', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    distanceMetric: 'Cosine',
    storagePath: join(tempDir, 'test.db'),
  });

  await db.insert({
    id: 'v1',
    vector: new Float32Array([1.0, 0.0, 0.0]),
  });

  await db.insert({
    id: 'v2',
    vector: new Float32Array([0.5, 0.5, 0.0]),
  });

  const results = await db.search({
    vector: new Float32Array([1.0, 0.0, 0.0]),
    k: 2,
  });

  t.truthy(results.length >= 1);
  t.is(results[0].id, 'v1');
});

test('VectorDB - HNSW index configuration', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 128,
    storagePath: join(tempDir, 'test.db'),
    hnswConfig: {
      m: 16,
      efConstruction: 100,
      efSearch: 50,
      maxElements: 10000,
    },
  });

  // Insert some vectors
  const vectors = Array.from({ length: 10 }, (_, i) =>
    new Float32Array(128).fill(0).map((_, j) => (i + j) * 0.01)
  );

  const ids = await db.insertBatch(
    vectors.map((vector) => ({ vector }))
  );

  t.is(ids.length, 10);

  const results = await db.search({
    vector: vectors[0],
    k: 5,
  });

  t.truthy(results.length >= 1);
});

test('VectorDB - memory stress test', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 128,
    storagePath: join(tempDir, 'test.db'),
  });

  // Insert 1000 vectors in batches
  const batchSize = 100;
  const totalVectors = 1000;

  for (let i = 0; i < totalVectors / batchSize; i++) {
    const batch = Array.from({ length: batchSize }, (_, j) => ({
      vector: new Float32Array(128).fill(0).map((_, k) => Math.random()),
    }));

    await db.insertBatch(batch);
  }

  const count = await db.len();
  t.is(count, totalVectors);

  // Search should still work
  const results = await db.search({
    vector: new Float32Array(128).fill(0).map(() => Math.random()),
    k: 10,
  });

  t.is(results.length, 10);
});

test('VectorDB - concurrent operations', async (t) => {
  const tempDir = createTempDir();
  t.teardown(() => cleanupTempDir(tempDir));

  const db = new VectorDB({
    dimensions: 3,
    storagePath: join(tempDir, 'test.db'),
  });

  // Insert vectors concurrently
  const promises = Array.from({ length: 50 }, (_, i) =>
    db.insert({
      vector: new Float32Array([i, i + 1, i + 2]),
    })
  );

  const ids = await Promise.all(promises);
  t.is(ids.length, 50);
  t.is(new Set(ids).size, 50); // All IDs should be unique

  // Search concurrently
  const searchPromises = Array.from({ length: 10 }, () =>
    db.search({
      vector: new Float32Array([1, 2, 3]),
      k: 5,
    })
  );

  const results = await Promise.all(searchPromises);
  t.is(results.length, 10);
  results.forEach((r) => t.truthy(r.length >= 1));
});