import init, { VectorDB } from '@ruvector/wasm';

// 1. Initialize WASM module (one-time setup)
await init();

// 2. Create database with 384-dimensional vectors
const db = new VectorDB(
  384,        // dimensions
  'cosine',   // distance metric
  true        // enable HNSW index
);

// 3. Insert vectors with metadata
const embedding = new Float32Array(384).map(() => Math.random());
const id = db.insert(
  embedding,
  'doc_1',                          // optional ID
  { title: 'My Document', type: 'article' }  // optional metadata
);

// 4. Search for similar vectors
const query = new Float32Array(384).map(() => Math.random());
const results = db.search(query, 10);  // top 10 results

// 5. Process results
results.forEach(result => {
  console.log(`ID: ${result.id}`);
  console.log(`Score: ${result.score}`);
  console.log(`Metadata:`, result.metadata);
});

// main.js
import { WorkerPool } from '@ruvector/wasm/worker-pool';

const pool = new WorkerPool(
  '/worker.js',
  '/pkg/ruvector_wasm.js',
  {
    poolSize: navigator.hardwareConcurrency || 4,  // Auto-detect CPU cores
    dimensions: 384,
    metric: 'cosine',
    useHnsw: true
  }
);

// Initialize worker pool
await pool.init();

// Batch insert in parallel (non-blocking)
const vectors = generateVectors(10000, 384);
const ids = await pool.insertBatch(vectors);

// Parallel search across workers
const query = new Float32Array(384).map(() => Math.random());
const results = await pool.search(query, 100);

// Get pool statistics
const stats = pool.getStats();
console.log(`Workers: ${stats.busyWorkers}/${stats.poolSize} busy`);
console.log(`Queue: ${stats.queuedTasks} tasks waiting`);

// Cleanup when done
pool.terminate();

// worker.js - Web Worker implementation
importScripts('/pkg/ruvector_wasm.js');

const { VectorDB } = wasm_bindgen;

let db = null;

self.onmessage = async (e) => {
  const { type, data } = e.data;

  switch (type) {
    case 'init':
      await wasm_bindgen('/pkg/ruvector_wasm_bg.wasm');
      db = new VectorDB(data.dimensions, data.metric, data.useHnsw);
      self.postMessage({ type: 'ready' });
      break;

    case 'insert':
      const id = db.insert(data.vector, data.id, data.metadata);
      self.postMessage({ type: 'inserted', id });
      break;

    case 'search':
      const results = db.search(data.query, data.k);
      self.postMessage({ type: 'results', results });
      break;
  }
};

import { IndexedDBPersistence } from '@ruvector/wasm/indexeddb';
import init, { VectorDB } from '@ruvector/wasm';

await init();

// Create persistence layer
const persistence = new IndexedDBPersistence('my_vector_db', {
  version: 1,
  cacheSize: 1000,  // LRU cache for hot vectors
  batchSize: 100     // Batch size for bulk operations
});

await persistence.open();

// Create or restore VectorDB
const db = new VectorDB(384, 'cosine', true);

// Load existing data from IndexedDB (with progress)
await persistence.loadAll(async (progress) => {
  console.log(`Loading: ${progress.loaded}/${progress.total} vectors`);
  console.log(`Progress: ${(progress.percent * 100).toFixed(1)}%`);

  // Insert batch into VectorDB
  if (progress.vectors.length > 0) {
    const ids = db.insertBatch(progress.vectors);
    console.log(`Inserted ${ids.length} vectors`);
  }

  if (progress.complete) {
    console.log('Database fully loaded!');
  }
});

// Insert new vectors and save to IndexedDB
const vector = new Float32Array(384).map(() => Math.random());
const id = db.insert(vector, 'vec_123', { category: 'new' });

await persistence.save({
  id,
  vector,
  metadata: { category: 'new' }
});

// Batch save for better performance
const entries = [...]; // Your vector entries
await persistence.saveBatch(entries);

// Get storage statistics
const stats = await persistence.getStats();
console.log(`Total vectors: ${stats.totalVectors}`);
console.log(`Storage used: ${(stats.storageBytes / 1024 / 1024).toFixed(2)} MB`);
console.log(`Cache size: ${stats.cacheSize}`);
console.log(`Cache hit rate: ${(stats.cacheHitRate * 100).toFixed(2)}%`);

// Clear old data
await persistence.clear();

import init, { VectorDB } from '@ruvector/wasm';

await init();
const db = new VectorDB(384, 'cosine', true);

// Batch insert (10x faster than individual inserts)
const entries = [];
for (let i = 0; i < 10000; i++) {
  entries.push({
    vector: new Float32Array(384).map(() => Math.random()),
    id: `vec_${i}`,
    metadata: { index: i, batch: Math.floor(i / 100) }
  });
}

const ids = db.insertBatch(entries);
console.log(`Inserted ${ids.length} vectors in batch`);

// Multiple parallel searches
const queries = Array.from({ length: 100 }, () =>
  new Float32Array(384).map(() => Math.random())
);

const allResults = queries.map(query => db.search(query, 10));
console.log(`Completed ${allResults.length} searches`);

import init, { VectorDB } from '@ruvector/wasm';

await init();

// Reuse Float32Array buffers to reduce GC pressure
const buffer = new Float32Array(384);

// Insert with reused buffer
for (let i = 0; i < 1000; i++) {
  // Fill buffer with new data
  for (let j = 0; j < 384; j++) {
    buffer[j] = Math.random();
  }

  db.insert(buffer, `vec_${i}`, { index: i });

  // Buffer is copied internally, safe to reuse
}

// Check memory usage
const vectorCount = db.len();
const isEmpty = db.isEmpty();
const dimensions = db.dimensions;

console.log(`Vectors: ${vectorCount}, Dims: ${dimensions}`);

// Clean up when done
// JavaScript GC will handle WASM memory automatically

import { detectSIMD } from '@ruvector/wasm';

if (detectSIMD()) {
  console.log('SIMD acceleration available!');
  // Load SIMD-optimized build
  await import('@ruvector/wasm/pkg-simd/ruvector_wasm.js');
} else {
  console.log('Standard build');
  // Load standard build
  await import('@ruvector/wasm');
}

// Check for required features
const hasWASM = typeof WebAssembly !== 'undefined';
const hasWorkers = typeof Worker !== 'undefined';
const hasIndexedDB = typeof indexedDB !== 'undefined';

if (!hasWASM) {
  console.error('WebAssembly not supported');
  // Fallback to server-side processing
}

if (!hasWorkers) {
  console.warn('Web Workers not available, using main thread');
  // Use synchronous API
}

if (!hasIndexedDB) {
  console.warn('IndexedDB not available, data will not persist');
  // Use in-memory only
}

// Lazy load WASM module when needed
const loadVectorDB = async () => {
  const { default: init, VectorDB } = await import('@ruvector/wasm');
  await init();
  return VectorDB;
};

// Use in your application
button.addEventListener('click', async () => {
  const VectorDB = await loadVectorDB();
  const db = new VectorDB(384, 'cosine', true);
  // Use db...
});

// Semantic search with OpenAI embeddings
import init, { VectorDB } from '@ruvector/wasm';
import { Configuration, OpenAIApi } from 'openai';

await init();

const openai = new OpenAIApi(new Configuration({
  apiKey: process.env.OPENAI_API_KEY
}));

const db = new VectorDB(1536, 'cosine', true);  // OpenAI ada-002 = 1536 dims

// Index documents
const documents = [
  'The quick brown fox jumps over the lazy dog',
  'Machine learning is a subset of artificial intelligence',
  'WebAssembly enables high-performance web applications'
];

for (const [i, doc] of documents.entries()) {
  const response = await openai.createEmbedding({
    model: 'text-embedding-ada-002',
    input: doc
  });

  const embedding = new Float32Array(response.data.data[0].embedding);
  db.insert(embedding, `doc_${i}`, { text: doc });
}

// Search
const queryResponse = await openai.createEmbedding({
  model: 'text-embedding-ada-002',
  input: 'What is AI?'
});

const queryEmbedding = new Float32Array(queryResponse.data.data[0].embedding);
const results = db.search(queryEmbedding, 3);

results.forEach(result => {
  console.log(`${result.score.toFixed(4)}: ${result.metadata.text}`);
});

// Product recommendations that work offline
import init, { VectorDB } from '@ruvector/wasm';
import { IndexedDBPersistence } from '@ruvector/wasm/indexeddb';

await init();

const db = new VectorDB(128, 'cosine', true);
const persistence = new IndexedDBPersistence('product_recommendations');
await persistence.open();

// Load cached recommendations
await persistence.loadAll(async (progress) => {
  if (progress.vectors.length > 0) {
    db.insertBatch(progress.vectors);
  }
});

// Get recommendations based on user history
function getRecommendations(userHistory, k = 10) {
  // Compute user preference vector (average of liked items)
  const userVector = computeAverageEmbedding(userHistory);
  const recommendations = db.search(userVector, k);

  return recommendations.map(r => ({
    productId: r.id,
    score: r.score,
    ...r.metadata
  }));
}

// Add new products (syncs to IndexedDB)
async function addProduct(productId, embedding, metadata) {
  db.insert(embedding, productId, metadata);
  await persistence.save({ id: productId, vector: embedding, metadata });
}

// Browser-based RAG system
import init, { VectorDB } from '@ruvector/wasm';

await init();

const db = new VectorDB(768, 'cosine', true);  // BERT embeddings

// Index knowledge base
const knowledgeBase = loadKnowledgeBase();  // Your documents
for (const doc of knowledgeBase) {
  const embedding = await getBertEmbedding(doc.text);
  db.insert(embedding, doc.id, { text: doc.text, source: doc.source });
}

// RAG query function
async function ragQuery(question, llm) {
  // 1. Get question embedding
  const questionEmbedding = await getBertEmbedding(question);

  // 2. Retrieve relevant context
  const context = db.search(questionEmbedding, 5);

  // 3. Augment prompt with context
  const prompt = `
Context:
${context.map(r => r.metadata.text).join('\n\n')}

Question: ${question}

Answer based on the context above:
  `;

  // 4. Generate response
  const response = await llm.generate(prompt);

  return {
    answer: response,
    sources: context.map(r => r.metadata.source)
  };
}

// Ensure correct MIME type
// Add to server config (nginx):
// types {
//   application/wasm wasm;
// }

// Or use explicit fetch
const wasmUrl = new URL('./pkg/ruvector_wasm_bg.wasm', import.meta.url);
await init(await fetch(wasmUrl));

// For local development
// package.json
{
  "scripts": {
    "serve": "python3 -m http.server 8080 --bind 127.0.0.1"
  }
}

// Monitor memory usage
const stats = db.len();
const estimatedMemory = stats * dimensions * 4; // bytes

if (estimatedMemory > 100_000_000) { // 100MB
  console.warn('High memory usage, consider chunking');
}

// Use batch operations to reduce GC pressure
const BATCH_SIZE = 1000;
for (let i = 0; i < entries.length; i += BATCH_SIZE) {
  const batch = entries.slice(i, i + BATCH_SIZE);
  db.insertBatch(batch);
}

// Ensure worker script URL is correct
const workerUrl = new URL('./worker.js', import.meta.url);
const worker = new Worker(workerUrl, { type: 'module' });

// Handle worker errors
worker.onerror = (error) => {
  console.error('Worker error:', error);
};