/**
 * Hybrid Search VFS Integration Tests
 *
 * Verifies that hybrid search works correctly with VFS entities:
 * file content is searchable by default, and `excludeVFS` filters
 * VFS entities out of results.
 */

import { describe, it, expect, beforeEach, afterEach } from 'vitest'
import { Brainy } from '../../src/brainy'
import { NounType } from '../../src/types/graphTypes'
import * as fs from 'fs'
import * as path from 'path'
import * as os from 'os'

describe('Hybrid Search with VFS', () => {
  let brain: Brainy<any>
  let testDir: string

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

    brain = new Brainy({ requireSubtype: false,
      storage: {
        type: 'filesystem',
        options: { basePath: testDir }
      }
    })
    await brain.init()
  })

  afterEach(async () => {
    await brain.close()
    // Cleanup test directory
    try {
      fs.rmSync(testDir, { recursive: true, force: true })
    } catch (e) {
      // Ignore cleanup errors
    }
  })

  it('should include VFS file content in hybrid search', async () => {
    // Write a file via VFS
    const vfs = brain.vfs
    await vfs.writeFile('/docs/readme.txt', 'This is a readme file with important information')

    // Search should find VFS content
    const results = await brain.find({
      query: 'readme important',
      limit: 10
    })

    // VFS entities should appear in results
    expect(results.length).toBeGreaterThan(0)
  })

  it('should exclude VFS with excludeVFS flag in hybrid search', async () => {
    // Add regular entity
    const entityId = await brain.add({
      data: 'regular document about readme files',
      type: NounType.Document,
      metadata: { source: 'api' }
    })

    // Write VFS file
    await brain.vfs.writeFile('/readme.md', 'VFS readme content')

    // Search with excludeVFS should only find regular entity
    const results = await brain.find({
      query: 'readme',
      excludeVFS: true,
      limit: 10
    })

    expect(results.some(r => r.id === entityId)).toBe(true)
    // VFS entities should be excluded
    expect(results.every(r => !r.metadata?.vfsType)).toBe(true)
  })
})
