/**
 * ProjectMemoryService Tests
 *
 * Tests for the high-level memory service.
 *
 * @module @agentkits/memory/__tests__/index.test
 */

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import * as fs from 'node:fs';
import * as path from 'node:path';
import { tmpdir } from 'node:os';
import {
  ProjectMemoryService,
  createProjectMemory,
  DEFAULT_NAMESPACES,
  MemoryEntry,
  createDefaultEntry,
} from '../index.js';

describe('ProjectMemoryService', () => {
  let service: ProjectMemoryService;
  let testDir: string;

  beforeEach(async () => {
    // Create temp directory for tests
    testDir = path.join(tmpdir(), `memory-test-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    service = new ProjectMemoryService({
      baseDir: testDir,
      dbFilename: 'test.db',
      cacheEnabled: false,
      enableVectorIndex: false,
      autoPersistInterval: 0,
    });
    await service.initialize();
  });

  afterEach(async () => {
    await service.shutdown();
    // Cleanup temp directory
    fs.rmSync(testDir, { recursive: true, force: true });
  });

  describe('Initialization', () => {
    it('should initialize successfully', async () => {
      const newService = new ProjectMemoryService({
        baseDir: path.join(testDir, 'init-test'),
        dbFilename: 'init.db',
      });

      await newService.initialize();
      const health = await newService.healthCheck();

      expect(health.status).toBe('healthy');
      await newService.shutdown();
    });

    it('should create directory if not exists', async () => {
      const newDir = path.join(testDir, 'new-dir');

      const newService = new ProjectMemoryService({
        baseDir: newDir,
        dbFilename: 'new.db',
      });

      await newService.initialize();
      expect(fs.existsSync(newDir)).toBe(true);

      await newService.shutdown();
    });

    it('should accept string as baseDir', async () => {
      const dir = path.join(testDir, 'string-dir');
      const newService = new ProjectMemoryService(dir);

      await newService.initialize();
      expect(fs.existsSync(dir)).toBe(true);

      await newService.shutdown();
    });
  });

  describe('Store and Retrieve', () => {
    it('should store entry via storeEntry convenience method', async () => {
      const entry = await service.storeEntry({
        key: 'test-key',
        content: 'Test content',
        namespace: 'test',
        tags: ['tag1'],
      });

      expect(typeof entry.id).toBe('string');
      expect(entry.id.length).toBeGreaterThan(0);
      expect(entry.key).toBe('test-key');
      expect(entry.content).toBe('Test content');
    });

    it('should get entry by id', async () => {
      const stored = await service.storeEntry({
        key: 'get-test',
        content: 'Content',
        namespace: 'test',
      });

      const retrieved = await service.get(stored.id);

      expect(retrieved).not.toBeNull();
      expect(retrieved!.id).toBe(stored.id);
    });

    it('should get entry by namespace and key', async () => {
      await service.storeEntry({
        key: 'ns-key-test',
        content: 'Content',
        namespace: 'my-namespace',
      });

      const retrieved = await service.getByKey('my-namespace', 'ns-key-test');

      expect(retrieved).not.toBeNull();
      expect(retrieved!.key).toBe('ns-key-test');
      expect(retrieved!.namespace).toBe('my-namespace');
    });

    it('should update entry', async () => {
      const stored = await service.storeEntry({
        key: 'update-test',
        content: 'Original',
        namespace: 'test',
      });

      const updated = await service.update(stored.id, { content: 'Updated' });

      expect(updated!.content).toBe('Updated');
    });

    it('should delete entry', async () => {
      const stored = await service.storeEntry({
        key: 'delete-test',
        content: 'To delete',
        namespace: 'test',
      });

      expect(await service.count()).toBe(1);

      const deleted = await service.delete(stored.id);
      expect(deleted).toBe(true);
      expect(await service.count()).toBe(0);
    });
  });

  describe('Query Operations', () => {
    beforeEach(async () => {
      await service.storeEntry({ key: 'p1', content: 'Pattern 1', namespace: 'patterns', tags: ['auth'] });
      await service.storeEntry({ key: 'p2', content: 'Pattern 2', namespace: 'patterns', tags: ['api'] });
      await service.storeEntry({ key: 'd1', content: 'Decision 1', namespace: 'decisions', tags: ['db'] });
    });

    it('should query all entries', async () => {
      const results = await service.query({ type: 'hybrid', limit: 10 });
      expect(results.length).toBe(3);
    });

    it('should query by namespace', async () => {
      const results = await service.query({ type: 'hybrid', namespace: 'patterns', limit: 10 });
      expect(results.length).toBe(2);
    });

    it('should use getByNamespace convenience method', async () => {
      const results = await service.getByNamespace('patterns');
      expect(results.length).toBe(2);
    });
  });

  describe('Get or Create', () => {
    it('should create entry if not exists', async () => {
      const entry = await service.getOrCreate('test-ns', 'new-key', () => ({
        key: 'new-key',
        content: 'New content',
        namespace: 'test-ns',
      }));

      expect(entry.content).toBe('New content');
    });

    it('should return existing entry if exists', async () => {
      await service.storeEntry({
        key: 'existing-key',
        content: 'Existing content',
        namespace: 'test-ns',
      });

      const entry = await service.getOrCreate('test-ns', 'existing-key', () => ({
        key: 'existing-key',
        content: 'New content',
        namespace: 'test-ns',
      }));

      expect(entry.content).toBe('Existing content');
    });
  });

  describe('Session Management', () => {
    it('should start session', async () => {
      const session = await service.startSession();

      expect(typeof session.id).toBe('string');
      expect(session.id.length).toBeGreaterThan(0);
      expect(session.status).toBe('active');
      expect(typeof session.startedAt).toBe('number');
      expect(session.startedAt).toBeGreaterThan(0);
    });

    it('should get current session', async () => {
      expect(service.getCurrentSession()).toBeNull();

      await service.startSession();
      const current = service.getCurrentSession();

      expect(current).not.toBeNull();
      expect(current!.status).toBe('active');
    });

    it('should create checkpoint', async () => {
      await service.startSession();
      await service.checkpoint('Test checkpoint');

      const session = service.getCurrentSession();
      expect(session!.lastCheckpoint).toBe('Test checkpoint');
    });

    it('should throw error when checkpoint without session', async () => {
      await expect(service.checkpoint('Test')).rejects.toThrow('No active session');
    });

    it('should end session', async () => {
      await service.startSession();
      const ended = await service.endSession('Session summary');

      expect(ended).not.toBeNull();
      expect(ended!.status).toBe('completed');
      expect(ended!.summary).toBe('Session summary');
      expect(typeof ended!.endedAt).toBe('number');
      expect(ended!.endedAt).toBeGreaterThan(0);
    });

    it('should add session id to entries', async () => {
      const session = await service.startSession();

      const entry = await service.storeEntry({
        key: 'session-entry',
        content: 'Content',
        namespace: 'test',
      });

      expect(entry.sessionId).toBe(session.id);
    });

    it('should get recent sessions', async () => {
      await service.startSession();
      await service.endSession('Session 1');

      await service.startSession();
      await service.endSession('Session 2');

      const sessions = await service.getRecentSessions();
      expect(sessions.length).toBeGreaterThanOrEqual(2);
    });
  });

  describe('Namespace Operations', () => {
    beforeEach(async () => {
      await service.storeEntry({ key: 'ns1-1', content: 'C1', namespace: 'ns1' });
      await service.storeEntry({ key: 'ns1-2', content: 'C2', namespace: 'ns1' });
      await service.storeEntry({ key: 'ns2-1', content: 'C3', namespace: 'ns2' });
    });

    it('should list namespaces', async () => {
      const namespaces = await service.listNamespaces();
      expect(namespaces).toContain('ns1');
      expect(namespaces).toContain('ns2');
    });

    it('should count by namespace', async () => {
      const count = await service.count('ns1');
      expect(count).toBe(2);
    });

    it('should clear namespace', async () => {
      const cleared = await service.clearNamespace('ns1');
      expect(cleared).toBe(2);
      expect(await service.count('ns1')).toBe(0);
      expect(await service.count('ns2')).toBe(1);
    });
  });

  describe('Bulk Operations', () => {
    it('should bulk insert entries', async () => {
      const entries = [
        createDefaultEntry({ key: 'b1', content: 'C1', namespace: 'bulk' }),
        createDefaultEntry({ key: 'b2', content: 'C2', namespace: 'bulk' }),
      ];

      await service.bulkInsert(entries);
      expect(await service.count('bulk')).toBe(2);
    });

    it('should bulk delete entries', async () => {
      const e1 = await service.storeEntry({ key: 'bd1', content: 'C1', namespace: 'bd' });
      const e2 = await service.storeEntry({ key: 'bd2', content: 'C2', namespace: 'bd' });

      const deleted = await service.bulkDelete([e1.id, e2.id]);
      expect(deleted).toBe(2);
      expect(await service.count('bd')).toBe(0);
    });
  });

  describe('Statistics and Health', () => {
    it('should get stats', async () => {
      await service.storeEntry({ key: 's1', content: 'C1', namespace: 'ns1' });
      await service.storeEntry({ key: 's2', content: 'C2', namespace: 'ns2' });

      const stats = await service.getStats();

      expect(stats.totalEntries).toBe(2);
      expect(typeof stats.entriesByNamespace).toBe('object');
      expect(stats.entriesByNamespace).not.toBeNull();
    });

    it('should health check', async () => {
      const health = await service.healthCheck();

      expect(health.status).toBe('healthy');
      expect(typeof health.components).toBe('object');
      expect(health.components).not.toBeNull();
    });
  });

  describe('Events', () => {
    it('should emit entry:stored event', async () => {
      const listener = vi.fn();
      service.on('entry:stored', listener);

      await service.storeEntry({ key: 'event-test', content: 'Content', namespace: 'test' });

      expect(listener).toHaveBeenCalled();
    });

    it('should emit session:started event', async () => {
      const listener = vi.fn();
      service.on('session:started', listener);

      await service.startSession();

      expect(listener).toHaveBeenCalled();
    });

    it('should emit session:ended event', async () => {
      const listener = vi.fn();
      service.on('session:ended', listener);

      await service.startSession();
      await service.endSession();

      expect(listener).toHaveBeenCalled();
    });
  });
});

describe('createProjectMemory factory', () => {
  let testDir: string;

  beforeEach(() => {
    testDir = path.join(tmpdir(), `factory-test-${Date.now()}`);
  });

  afterEach(() => {
    fs.rmSync(testDir, { recursive: true, force: true });
  });

  it('should create memory service with defaults', async () => {
    const service = createProjectMemory(testDir);
    await service.initialize();

    expect(fs.existsSync(testDir)).toBe(true);

    await service.shutdown();
  });

  it('should accept options', async () => {
    const service = createProjectMemory(testDir, {
      cacheEnabled: false,
      verbose: true,
    });

    await service.initialize();
    await service.shutdown();
  });
});

describe('DEFAULT_NAMESPACES', () => {
  it('should have all required namespaces', () => {
    expect(DEFAULT_NAMESPACES.CONTEXT).toBe('context');
    expect(DEFAULT_NAMESPACES.ACTIVE).toBe('active-context');
    expect(DEFAULT_NAMESPACES.SESSION).toBe('session-state');
    expect(DEFAULT_NAMESPACES.PROGRESS).toBe('progress');
    expect(DEFAULT_NAMESPACES.PATTERNS).toBe('patterns');
    expect(DEFAULT_NAMESPACES.DECISIONS).toBe('decisions');
    expect(DEFAULT_NAMESPACES.ERRORS).toBe('errors');
  });
});

describe('ProjectMemoryService with embeddings', () => {
  let service: ProjectMemoryService;
  let testDir: string;
  const mockEmbeddingGenerator = vi.fn().mockImplementation(async (content: string) => {
    // Simple mock embedding based on content length
    const embedding = new Float32Array(8);
    for (let i = 0; i < 8; i++) {
      embedding[i] = (content.charCodeAt(i % content.length) / 255) - 0.5;
    }
    return embedding;
  });

  beforeEach(async () => {
    testDir = path.join(tmpdir(), `embedding-test-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    service = new ProjectMemoryService({
      baseDir: testDir,
      dbFilename: 'test.db',
      cacheEnabled: true,
      enableVectorIndex: true,
      dimensions: 8,
      embeddingGenerator: mockEmbeddingGenerator,
    });
    await service.initialize();
  });

  afterEach(async () => {
    await service.shutdown();
    fs.rmSync(testDir, { recursive: true, force: true });
    vi.clearAllMocks();
  });

  it('should generate embeddings when storing entries', async () => {
    await service.storeEntry({
      key: 'embed-test',
      content: 'Test content for embedding',
      namespace: 'test',
    });

    expect(mockEmbeddingGenerator).toHaveBeenCalledWith('Test content for embedding');
  });

  it('should perform semantic search', async () => {
    await service.storeEntry({
      key: 'auth-pattern',
      content: 'Use JWT for authentication',
      namespace: 'patterns',
    });

    await service.storeEntry({
      key: 'db-pattern',
      content: 'Use PostgreSQL for database',
      namespace: 'patterns',
    });

    const results = await service.semanticSearch('authentication', 5);
    expect(results.length).toBeGreaterThan(0);
  });

  it('should throw error for semantic search without embedding generator', async () => {
    const noEmbedService = new ProjectMemoryService({
      baseDir: path.join(testDir, 'no-embed'),
      dbFilename: 'test.db',
    });
    await noEmbedService.initialize();

    await expect(noEmbedService.semanticSearch('test', 5)).rejects.toThrow(
      'Embedding generator not configured'
    );

    await noEmbedService.shutdown();
  });

  it('should use sqlite-vec for vector search', async () => {
    await service.storeEntry({
      key: 'v1',
      content: 'First vector content',
      namespace: 'vectors',
    });

    await service.storeEntry({
      key: 'v2',
      content: 'Second vector content',
      namespace: 'vectors',
    });

    const embedding = await mockEmbeddingGenerator('First');
    const results = await service.search(embedding, { k: 2 });

    expect(results.length).toBeLessThanOrEqual(2);
  });

  it('should update embedding when content changes', async () => {
    const entry = await service.storeEntry({
      key: 'update-embed',
      content: 'Original content',
      namespace: 'test',
    });

    const callsBefore = mockEmbeddingGenerator.mock.calls.length;

    await service.update(entry.id, { content: 'Updated content' });

    // Should have generated new embedding for updated content
    expect(mockEmbeddingGenerator.mock.calls.length).toBeGreaterThan(callsBefore);
  });

  it('should handle embedding generator failure gracefully', async () => {
    const failingGenerator = vi.fn().mockRejectedValue(new Error('Embedding failed'));
    const failService = new ProjectMemoryService({
      baseDir: path.join(testDir, 'fail-embed'),
      dbFilename: 'test.db',
      embeddingGenerator: failingGenerator,
      verbose: true,
    });
    await failService.initialize();

    // Should not throw, just log warning
    const entry = await failService.storeEntry({
      key: 'fail-test',
      content: 'Content that will fail embedding',
      namespace: 'test',
    });

    expect(typeof entry.id).toBe('string');
    expect(entry.id.length).toBeGreaterThan(0);
    await failService.shutdown();
  });

  it('should remove from vector index when deleting', async () => {
    const entry = await service.storeEntry({
      key: 'delete-vector',
      content: 'Content to delete',
      namespace: 'test',
    });

    // Verify entry exists in vector search
    const embedding = await mockEmbeddingGenerator('Content to delete');
    const beforeDelete = await service.search(embedding, { k: 5 });
    const foundBefore = beforeDelete.some(r => r.entry.id === entry.id);
    expect(foundBefore).toBe(true);

    await service.delete(entry.id);

    // Entry should no longer be found
    const afterDelete = await service.search(embedding, { k: 5 });
    const foundAfter = afterDelete.some(r => r.entry.id === entry.id);
    expect(foundAfter).toBe(false);
  });

  it('should apply threshold in search results', async () => {
    await service.storeEntry({
      key: 'similar',
      content: 'Very similar content',
      namespace: 'test',
    });

    await service.storeEntry({
      key: 'different',
      content: 'Completely different words here',
      namespace: 'test',
    });

    const embedding = await mockEmbeddingGenerator('Very similar');
    const results = await service.search(embedding, { k: 10, threshold: 0.9 });

    // High threshold should filter out dissimilar results
    expect(results.length).toBeLessThanOrEqual(2);
  });

  it('should include vector search info in getStats', async () => {
    await service.storeEntry({
      key: 'stats-test',
      content: 'Content for stats',
      namespace: 'test',
    });

    const stats = await service.getStats();
    // With sqlite-vec, vector stats are included in backend stats
    expect(stats.totalEntries).toBeGreaterThanOrEqual(1);
  });

  it('should include cache stats in getStats', async () => {
    await service.storeEntry({
      key: 'cache-test',
      content: 'Content for cache',
      namespace: 'test',
    });

    // Trigger a cache hit
    await service.get((await service.query({ type: 'hybrid', limit: 1 }))[0].id);

    const stats = await service.getStats();
    expect(typeof stats.cacheStats).toBe('object');
    expect(stats.cacheStats).not.toBeNull();
  });
});

describe('ProjectMemoryService with cache', () => {
  let service: ProjectMemoryService;
  let testDir: string;

  beforeEach(async () => {
    testDir = path.join(tmpdir(), `cache-test-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    service = new ProjectMemoryService({
      baseDir: testDir,
      dbFilename: 'test.db',
      cacheEnabled: true,
      cacheSize: 100,
      cacheTtl: 60000,
    });
    await service.initialize();
  });

  afterEach(async () => {
    await service.shutdown();
    fs.rmSync(testDir, { recursive: true, force: true });
  });

  it('should cache entries on get', async () => {
    const entry = await service.storeEntry({
      key: 'cache-hit',
      content: 'Cached content',
      namespace: 'test',
    });

    // First get populates cache
    const first = await service.get(entry.id);
    expect(first).not.toBeNull();

    // Second get should hit cache
    const second = await service.get(entry.id);
    expect(second).not.toBeNull();
    expect(second!.id).toBe(first!.id);
  });

  it('should cache entries on getByKey', async () => {
    await service.storeEntry({
      key: 'cache-key',
      content: 'Cached by key',
      namespace: 'ns',
    });

    // First get populates cache
    const first = await service.getByKey('ns', 'cache-key');
    expect(first).not.toBeNull();

    // Second get should hit cache
    const second = await service.getByKey('ns', 'cache-key');
    expect(second).not.toBeNull();
  });

  it('should update cache on update', async () => {
    const entry = await service.storeEntry({
      key: 'update-cache',
      content: 'Original',
      namespace: 'test',
    });

    await service.update(entry.id, { content: 'Updated' });

    const retrieved = await service.get(entry.id);
    expect(retrieved!.content).toBe('Updated');
  });

  it('should invalidate cache on delete', async () => {
    const entry = await service.storeEntry({
      key: 'delete-cache',
      content: 'To delete',
      namespace: 'test',
    });

    // Populate cache
    await service.get(entry.id);

    // Delete
    await service.delete(entry.id);

    // Should not find in cache or backend
    const retrieved = await service.get(entry.id);
    expect(retrieved).toBeNull();
  });

  it('should invalidate cache pattern on clearNamespace', async () => {
    await service.storeEntry({ key: 'c1', content: 'C1', namespace: 'clear-ns' });
    await service.storeEntry({ key: 'c2', content: 'C2', namespace: 'clear-ns' });
    await service.storeEntry({ key: 'k1', content: 'K1', namespace: 'keep-ns' });

    await service.clearNamespace('clear-ns');

    expect(await service.count('clear-ns')).toBe(0);
    expect(await service.count('keep-ns')).toBe(1);
  });
});

describe('ProjectMemoryService error handling', () => {
  it('should throw error when not initialized', async () => {
    const service = new ProjectMemoryService({
      baseDir: path.join(tmpdir(), 'not-init-test'),
    });

    await expect(service.get('some-id')).rejects.toThrow('not initialized');
    await expect(service.query({ type: 'hybrid', limit: 10 })).rejects.toThrow('not initialized');
  });

  it('should handle shutdown with active session', async () => {
    const testDir = path.join(tmpdir(), `session-shutdown-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    const service = new ProjectMemoryService({ baseDir: testDir });
    await service.initialize();

    await service.startSession();

    // Shutdown should end the session automatically
    await service.shutdown();

    // Verify session was ended
    expect(service.getCurrentSession()).toBeNull();

    fs.rmSync(testDir, { recursive: true, force: true });
  });

  it('should handle double initialization', async () => {
    const testDir = path.join(tmpdir(), `double-init-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    const service = new ProjectMemoryService({ baseDir: testDir });
    await service.initialize();
    await service.initialize(); // Should not throw

    await service.shutdown();
    fs.rmSync(testDir, { recursive: true, force: true });
  });

  it('should handle double shutdown', async () => {
    const testDir = path.join(tmpdir(), `double-shutdown-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    const service = new ProjectMemoryService({ baseDir: testDir });
    await service.initialize();
    await service.shutdown();
    await service.shutdown(); // Should not throw

    fs.rmSync(testDir, { recursive: true, force: true });
  });

  it('should return null when ending non-existent session', async () => {
    const testDir = path.join(tmpdir(), `no-session-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    const service = new ProjectMemoryService({ baseDir: testDir });
    await service.initialize();

    const result = await service.endSession('summary');
    expect(result).toBeNull();

    await service.shutdown();
    fs.rmSync(testDir, { recursive: true, force: true });
  });

  it('should handle delete of non-existent entry', async () => {
    const testDir = path.join(tmpdir(), `delete-none-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    const service = new ProjectMemoryService({ baseDir: testDir });
    await service.initialize();

    const result = await service.delete('non-existent-id');
    expect(result).toBe(false);

    await service.shutdown();
    fs.rmSync(testDir, { recursive: true, force: true });
  });

  it('should handle getRecentSessions with invalid JSON', async () => {
    const testDir = path.join(tmpdir(), `invalid-session-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    const service = new ProjectMemoryService({ baseDir: testDir });
    await service.initialize();

    // Store invalid session data
    await service.storeEntry({
      key: 'session:invalid',
      content: 'not valid json {{{',
      namespace: DEFAULT_NAMESPACES.SESSION,
      tags: ['session'],
    });

    // Should filter out invalid entries
    const sessions = await service.getRecentSessions();
    expect(sessions.every(s => s.id !== undefined)).toBe(true);

    await service.shutdown();
    fs.rmSync(testDir, { recursive: true, force: true });
  });
});

describe('createEmbeddingMemory factory', () => {
  let testDir: string;

  beforeEach(() => {
    testDir = path.join(tmpdir(), `embed-factory-${Date.now()}`);
  });

  afterEach(() => {
    fs.rmSync(testDir, { recursive: true, force: true });
  });

  it('should create memory service with embedding support', async () => {
    const { createEmbeddingMemory } = await import('../index.js');

    const mockGenerator = vi.fn().mockResolvedValue(new Float32Array(128));

    const service = createEmbeddingMemory(testDir, mockGenerator, 128);
    await service.initialize();

    // Store an entry to trigger embedding generation
    await service.storeEntry({
      key: 'embed-test',
      content: 'Test content',
      namespace: 'test',
    });

    expect(mockGenerator).toHaveBeenCalled();

    await service.shutdown();
  });
});

/**
 * STRICT TESTS - Bug Catchers
 *
 * These tests verify actual behavior, not just that "something exists".
 * They catch real bugs and ensure data integrity.
 */
describe('Strict Data Integrity Tests', () => {
  let service: ProjectMemoryService;
  let testDir: string;

  beforeEach(async () => {
    testDir = path.join(tmpdir(), `strict-test-${Date.now()}`);
    fs.mkdirSync(testDir, { recursive: true });

    service = new ProjectMemoryService({
      baseDir: testDir,
      dbFilename: 'test.db',
      cacheEnabled: false,
    });
    await service.initialize();
  });

  afterEach(async () => {
    await service.shutdown();
    fs.rmSync(testDir, { recursive: true, force: true });
  });

  describe('Concurrent Operations', () => {
    it('should not lose data on concurrent writes', async () => {
      const count = 50;
      const promises = Array.from({ length: count }, (_, i) =>
        service.storeEntry({
          key: `concurrent-${i}`,
          content: `Data ${i}`,
          namespace: 'test',
        })
      );

      await Promise.all(promises);
      const totalCount = await service.count();
      expect(totalCount).toBe(count);
    });

    it('should handle concurrent reads and writes', async () => {
      // Pre-populate
      await service.storeEntry({
        key: 'read-write-test',
        content: 'Initial',
        namespace: 'test',
      });

      const writePromises = Array.from({ length: 10 }, (_, i) =>
        service.storeEntry({
          key: `write-${i}`,
          content: `Write ${i}`,
          namespace: 'test',
        })
      );

      const readPromises = Array.from({ length: 10 }, () =>
        service.getByKey('test', 'read-write-test')
      );

      const results = await Promise.all([...writePromises, ...readPromises]);

      // All reads should return the same entry
      const reads = results.slice(10);
      reads.forEach((entry) => {
        expect(entry).not.toBeNull();
        expect(entry!.key).toBe('read-write-test');
      });
    });
  });

  describe('Unicode and Special Characters', () => {
    it('should preserve unicode content exactly', async () => {
      const testCases = [
        { name: 'emoji', content: '🎉🚀💻🔥✨' },
        { name: 'chinese', content: '中文测试内容' },
        { name: 'japanese', content: '日本語のテスト' },
        { name: 'korean', content: '한국어 테스트' },
        { name: 'mixed', content: 'Hello 世界 🌍 مرحبا' },
        { name: 'special', content: 'Tab\tNewline\nCarriage\rReturn' },
        { name: 'quotes', content: 'Single\' Double" Backtick`' },
        { name: 'sql-injection-attempt', content: "'; DROP TABLE memories; --" },
      ];

      for (const { name, content } of testCases) {
        const entry = await service.storeEntry({
          key: `unicode-${name}`,
          content,
          namespace: 'test',
        });

        const retrieved = await service.get(entry.id);
        expect(retrieved!.content).toBe(content);
      }
    });

    it('should handle null bytes gracefully', async () => {
      const content = 'Before\0After';
      const entry = await service.storeEntry({
        key: 'null-byte',
        content,
        namespace: 'test',
      });

      const retrieved = await service.get(entry.id);
      // SQLite may handle null bytes differently, so we check it doesn't crash
      expect(retrieved).not.toBeNull();
    });
  });

  describe('Boundary Conditions', () => {
    it('should handle empty content', async () => {
      const entry = await service.storeEntry({
        key: 'empty-content',
        content: '',
        namespace: 'test',
      });

      const retrieved = await service.get(entry.id);
      expect(retrieved!.content).toBe('');
    });

    it('should handle very long keys', async () => {
      const longKey = 'k'.repeat(1000);
      const entry = await service.storeEntry({
        key: longKey,
        content: 'Content',
        namespace: 'test',
      });

      const retrieved = await service.getByKey('test', longKey);
      expect(retrieved!.key).toBe(longKey);
    });

    it('should handle large content (100KB)', async () => {
      const largeContent = 'x'.repeat(100_000);
      const entry = await service.storeEntry({
        key: 'large-content',
        content: largeContent,
        namespace: 'test',
      });

      const retrieved = await service.get(entry.id);
      expect(retrieved!.content.length).toBe(100_000);
    });

    it('should handle many tags', async () => {
      const tags = Array.from({ length: 100 }, (_, i) => `tag-${i}`);
      const entry = await service.storeEntry({
        key: 'many-tags',
        content: 'Content',
        namespace: 'test',
        tags,
      });

      const retrieved = await service.get(entry.id);
      expect(retrieved!.tags).toHaveLength(100);
      expect(retrieved!.tags).toContain('tag-50');
    });
  });

  describe('Data Consistency', () => {
    it('should increment version on update', async () => {
      const entry = await service.storeEntry({
        key: 'version-test',
        content: 'v1',
        namespace: 'test',
      });

      expect(entry.version).toBe(1);

      const updated1 = await service.update(entry.id, { content: 'v2' });
      expect(updated1!.version).toBe(2);

      const updated2 = await service.update(entry.id, { content: 'v3' });
      expect(updated2!.version).toBe(3);
    });

    it('should update timestamp on modification', async () => {
      const entry = await service.storeEntry({
        key: 'timestamp-test',
        content: 'Original',
        namespace: 'test',
      });

      const originalUpdatedAt = entry.updatedAt;

      // Wait a bit to ensure timestamp difference
      await new Promise((r) => setTimeout(r, 10));

      const updated = await service.update(entry.id, { content: 'Modified' });
      expect(updated!.updatedAt).toBeGreaterThan(originalUpdatedAt);
    });

    it('should preserve createdAt on update', async () => {
      const entry = await service.storeEntry({
        key: 'created-at-test',
        content: 'Original',
        namespace: 'test',
      });

      const originalCreatedAt = entry.createdAt;

      await service.update(entry.id, { content: 'Modified' });
      const retrieved = await service.get(entry.id);

      expect(retrieved!.createdAt).toBe(originalCreatedAt);
    });
  });

  describe('Query Correctness', () => {
    beforeEach(async () => {
      // Setup test data
      await service.storeEntry({ key: 'a1', content: 'Auth pattern', namespace: 'patterns', tags: ['auth', 'security'] });
      await service.storeEntry({ key: 'a2', content: 'API error', namespace: 'errors', tags: ['api'] });
      await service.storeEntry({ key: 'a3', content: 'Database decision', namespace: 'decisions', tags: ['db'] });
    });

    it('should return correct count after operations', async () => {
      expect(await service.count()).toBe(3);

      await service.storeEntry({ key: 'a4', content: 'New', namespace: 'test' });
      expect(await service.count()).toBe(4);

      const entries = await service.query({ type: 'hybrid', namespace: 'patterns', limit: 10 });
      await service.delete(entries[0].id);
      expect(await service.count()).toBe(3);
    });

    it('should correctly filter by namespace', async () => {
      const patterns = await service.getByNamespace('patterns');
      expect(patterns.length).toBe(1);
      expect(patterns[0].key).toBe('a1');

      const errors = await service.getByNamespace('errors');
      expect(errors.length).toBe(1);
      expect(errors[0].key).toBe('a2');
    });

    it('should return empty array for non-existent namespace', async () => {
      const results = await service.getByNamespace('non-existent');
      expect(results).toEqual([]);
    });
  });

  describe('Delete Behavior', () => {
    it('should return false when deleting non-existent entry', async () => {
      const deleted = await service.delete('non-existent-id');
      expect(deleted).toBe(false);
    });

    it('should actually remove entry on delete', async () => {
      const entry = await service.storeEntry({
        key: 'delete-me',
        content: 'Temporary',
        namespace: 'test',
      });

      await service.delete(entry.id);

      const retrieved = await service.get(entry.id);
      expect(retrieved).toBeNull();

      const byKey = await service.getByKey('test', 'delete-me');
      expect(byKey).toBeNull();
    });

    it('should clear namespace correctly', async () => {
      await service.storeEntry({ key: 'k1', content: 'C1', namespace: 'clear-ns' });
      await service.storeEntry({ key: 'k2', content: 'C2', namespace: 'clear-ns' });
      await service.storeEntry({ key: 'k3', content: 'C3', namespace: 'keep-ns' });

      const cleared = await service.clearNamespace('clear-ns');
      expect(cleared).toBe(2);

      const remaining = await service.getByNamespace('clear-ns');
      expect(remaining).toHaveLength(0);

      const kept = await service.getByNamespace('keep-ns');
      expect(kept).toHaveLength(1);
    });
  });
});