// TODO: Implement NLP features to re-enable these tests
// - detectIntent() method
// - Advanced NLP pattern matching
// - Natural language query parsing
// - Intent classification features
// Expected completion: 2-6 weeks

import { describe, it, expect, beforeEach, afterEach } from 'vitest'
import { Brainy } from '../../../src/brainy'
import { NaturalLanguageProcessor } from '../../../src/neural/naturalLanguageProcessor'
import { NounType } from '../../../src/types/graphTypes'

describe.skip('NaturalLanguageProcessor - SKIPPED: NLP features not yet implemented', () => {
  let brain: Brainy<any>
  let nlp: NaturalLanguageProcessor
  
  beforeEach(async () => {
    brain = new Brainy({ storage: { type: 'memory' } })
    await brain.init()
    nlp = new NaturalLanguageProcessor(brain)
    
    // Create a rich test dataset for NLP to work with
    await brain.add({
      data: 'John Smith is a senior software engineer at Google working on machine learning',
      type: NounType.Person,
      metadata: { 
        name: 'John Smith',
        role: 'engineer', 
        level: 'senior',
        company: 'Google',
        skills: ['JavaScript', 'Python', 'Machine Learning']
      }
    })
    
    await brain.add({
      data: 'Machine learning research paper on neural networks published in 2024',
      type: NounType.Document,
      metadata: {
        title: 'Advances in Neural Networks',
        category: 'research',
        year: 2024,
        topics: ['AI', 'neural networks', 'deep learning']
      }
    })
    
    await brain.add({
      data: 'TechCorp headquarters located in San Francisco California',
      type: NounType.Location,
      metadata: {
        company: 'TechCorp',
        city: 'San Francisco',
        state: 'CA',
        type: 'headquarters'
      }
    })
    
    await brain.add({
      data: 'Product launch event scheduled for December 2024',
      type: NounType.Event,
      metadata: {
        eventType: 'launch',
        date: '2024-12-01',
        status: 'scheduled'
      }
    })
    
    await brain.add({
      data: 'Python programming language used for data science and machine learning',
      type: NounType.Concept,
      metadata: {
        category: 'programming',
        uses: ['data science', 'machine learning', 'web development']
      }
    })
  })
  
  afterEach(async () => {
    await brain.close()
  })
  
  describe('processNaturalQuery - Core Functionality', () => {
    it('should process simple search queries', async () => {
      const query = 'Find machine learning papers'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      expect(result.similar || result.like).toBeDefined()
      
      // Should extract the search term
      const searchTerm = result.similar || result.like || ''
      expect(searchTerm.toString().toLowerCase()).toContain('machine learning')
    })
    
    it('should handle questions about entities', async () => {
      const query = 'What is John Smith working on?'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      // Should search for John Smith
      const hasSearch = result.similar || result.like || result.where
      expect(hasSearch).toBeDefined()
    })
    
    it('should extract location-based queries', async () => {
      const query = 'Find companies in San Francisco'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      // Should search for San Francisco
      const searchTerm = result.similar || result.like || ''
      expect(searchTerm.toString().toLowerCase()).toContain('san francisco')
    })
    
    it('should handle temporal queries', async () => {
      const query = 'Show me events in December 2024'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      // Should search for December 2024
      const searchTerm = result.similar || result.like || ''
      expect(searchTerm.toString().toLowerCase()).toContain('2024')
    })
    
    it('should process complex multi-part queries', async () => {
      const query = 'Find senior engineers at Google working on machine learning'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      // Should have search terms
      expect(result.similar || result.like).toBeDefined()
      
      // Might have metadata filters if sophisticated enough
      if (result.where) {
        expect(result.where).toBeDefined()
      }
    })
    
    it('should extract limit from queries', async () => {
      const query = 'Show me the top 5 machine learning papers'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      expect(result.limit).toBeDefined()
      expect(result.limit).toBeLessThanOrEqual(10) // Should extract a reasonable limit
    })
    
    it('should handle relationship queries', async () => {
      const query = 'What is connected to John Smith?'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      // Should search for John Smith with possible graph traversal
      const hasSearch = result.similar || result.like
      expect(hasSearch).toBeDefined()
      
      // Advanced: might have connected field
      if (result.connected) {
        expect(result.connected).toBeDefined()
      }
    })
  })
  
  describe('extract - Entity and Information Extraction', () => {
    it('should extract entities from text', async () => {
      const text = 'John Smith works at Google on machine learning projects'
      const extraction = await nlp.extract(text)
      
      expect(extraction).toBeDefined()
      expect(Array.isArray(extraction)).toBe(true)
      
      // Should find person and organization
      const entityTypes = extraction.map((e: any) => e.type)
      expect(entityTypes).toContain('person')
      expect(entityTypes).toContain('organization')
    })
    
    it('should extract topics and concepts', async () => {
      const text = 'This paper discusses neural networks, deep learning, and artificial intelligence'
      const extraction = await nlp.extract(text, { types: ['concept', 'topic'] })
      
      expect(extraction).toBeDefined()
      expect(Array.isArray(extraction)).toBe(true)
      
      // Should identify AI-related topics
      const allExtracted = JSON.stringify(extraction).toLowerCase()
      expect(allExtracted).toContain('neural')
    })
    
    it('should extract dates and times', async () => {
      const text = 'The meeting is scheduled for December 15, 2024 at 3:00 PM'
      const extraction = await nlp.extract(text, { types: ['date', 'time', 'event'] })
      
      expect(extraction).toBeDefined()
      // Should find date information
      const extracted = JSON.stringify(extraction)
      expect(extracted).toContain('2024')
    })
    
    it('should extract locations', async () => {
      const text = 'Our offices are in San Francisco, New York, and London'
      const extraction = await nlp.extract(text, { types: ['location', 'place'] })
      
      expect(extraction).toBeDefined()
      const extracted = JSON.stringify(extraction).toLowerCase()
      expect(extracted).toContain('san francisco')
    })
    
    it('should extract relationships', async () => {
      const text = 'John Smith manages the engineering team at Google'
      const extraction = await nlp.extract(text, { types: ['person', 'organization'] })
      
      expect(extraction).toBeDefined()
      // Should identify entities involved in relationship
      const extracted = JSON.stringify(extraction).toLowerCase()
      expect(extracted.includes('john') || extracted.includes('google')).toBe(true)
    })
  })
  
  describe('sentiment - Sentiment Analysis', () => {
    it('should analyze positive sentiment', async () => {
      const text = 'This is an excellent machine learning framework! Really impressive results.'
      const sentiment = await nlp.sentiment(text)
      
      expect(sentiment).toBeDefined()
      expect(sentiment.overall.score).toBeGreaterThan(0) // Positive score
      expect(sentiment.overall.label).toBe('positive')
    })
    
    it('should analyze negative sentiment', async () => {
      const text = 'This approach is terrible and the results are disappointing.'
      const sentiment = await nlp.sentiment(text)
      
      expect(sentiment).toBeDefined()
      expect(sentiment.overall.score).toBeLessThan(0) // Negative score
      expect(sentiment.overall.label).toBe('negative')
    })
    
    it('should analyze neutral sentiment', async () => {
      const text = 'The document contains information about machine learning.'
      const sentiment = await nlp.sentiment(text)
      
      expect(sentiment).toBeDefined()
      expect(Math.abs(sentiment.overall.score)).toBeLessThan(0.3) // Close to neutral
      expect(sentiment.overall.label).toBe('neutral')
    })
    
    it('should provide magnitude scores', async () => {
      const text = 'Machine learning is transforming technology'
      const sentiment = await nlp.sentiment(text)
      
      expect(sentiment).toBeDefined()
      expect(sentiment.overall.magnitude).toBeDefined()
      expect(sentiment.overall.magnitude).toBeGreaterThan(0)
      expect(sentiment.overall.magnitude).toBeLessThanOrEqual(10)
    })
  })
  
  describe('Query Pattern Recognition', () => {
    it('should recognize question patterns', async () => {
      const questions = [
        'What is machine learning?',
        'Who is John Smith?',
        'Where is Google located?',
        'When is the product launch?',
        'How does Python work?'
      ]
      
      for (const q of questions) {
        const result = await nlp.processNaturalQuery(q)
        expect(result).toBeDefined()
        // Should produce a search query
        expect(result.similar || result.like || result.where).toBeDefined()
      }
    })
    
    it('should recognize command patterns', async () => {
      const commands = [
        'Find all engineers',
        'Show me recent papers',
        'List upcoming events',
        'Get information about Google',
        'Search for machine learning'
      ]
      
      for (const cmd of commands) {
        const result = await nlp.processNaturalQuery(cmd)
        expect(result).toBeDefined()
        // Should have search criteria
        expect(result.similar || result.like || result.where).toBeDefined()
      }
    })
    
    it('should handle comparison queries', async () => {
      const query = 'Compare Python with JavaScript'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      // Should search for both terms
      const searchTerm = (result.similar || result.like || '').toString().toLowerCase()
      const hasTerms = searchTerm.includes('python') || searchTerm.includes('javascript')
      expect(hasTerms).toBe(true)
    })
  })
  
  describe('Advanced Features', () => {
    it('should handle ambiguous queries gracefully', async () => {
      const query = 'stuff about that thing'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      // Should still attempt to create a query
      expect(result).not.toBeNull()
    })
    
    it('should handle very long queries', async () => {
      const longQuery = 'Find ' + 'machine learning '.repeat(50) + 'papers'
      const result = await nlp.processNaturalQuery(longQuery)
      
      expect(result).toBeDefined()
      expect(result.limit).toBeDefined()
    })
    
    it('should handle empty queries', async () => {
      const result = await nlp.processNaturalQuery('')
      
      expect(result).toBeDefined()
      expect(result).toEqual({})
    })
    
    it('should handle special characters', async () => {
      const query = 'Find C++ and C# programming @Google'
      const result = await nlp.processNaturalQuery(query)
      
      expect(result).toBeDefined()
      expect(result.similar || result.like).toBeDefined()
    })
    
    it('should extract modifiers and preferences', async () => {
      const queries = [
        'Find the most recent papers',
        'Show the best engineers',
        'Get the latest news',
        'Find popular frameworks'
      ]
      
      for (const q of queries) {
        const result = await nlp.processNaturalQuery(q)
        expect(result).toBeDefined()
        
        // Might have boost or ordering
        if (result.boost) {
          expect(['recent', 'popular', 'verified']).toContain(result.boost)
        }
      }
    })
  })
  
  describe('Integration with Brainy', () => {
    it('should produce queries that work with brain.find()', async () => {
      const naturalQueries = [
        'Find machine learning papers',
        'Search for John Smith',
        'Get information about Python'
      ]
      
      for (const nq of naturalQueries) {
        const tripleQuery = await nlp.processNaturalQuery(nq)
        
        // Should be able to use with brain.find()
        const results = await brain.find(tripleQuery as any)
        
        expect(results).toBeDefined()
        expect(Array.isArray(results)).toBe(true)
      }
    })
    
    it('should work with complex real-world queries', async () => {
      const complexQuery = 'Find senior engineers at tech companies working on AI'
      const tripleQuery = await nlp.processNaturalQuery(complexQuery)
      
      expect(tripleQuery).toBeDefined()
      
      // Use with brain
      const results = await brain.find(tripleQuery as any)
      expect(results).toBeDefined()
      expect(Array.isArray(results)).toBe(true)
    })
    
    it('should handle entity extraction for brain operations', async () => {
      const text = 'John Smith is a talented engineer at Google'
      const extraction = await nlp.extract(text)
      
      // Could use extracted entities to create new entries
      if (extraction && extraction.length > 0) {
        for (const entity of extraction) {
          if (entity.type === 'person' && entity.text) {
            // Could add to brain
            const id = await brain.add({
              data: entity.text,
              type: NounType.Person,
              metadata: { extracted: true }
            })
            expect(id).toBeDefined()
            
            // Verify it was added
            const retrieved = await brain.get(id)
            expect(retrieved).toBeDefined()
          }
        }
      }
    })
  })
  
  describe('Performance', () => {
    it('should process queries quickly', async () => {
      const query = 'Find machine learning papers from 2024'
      
      const startTime = Date.now()
      const result = await nlp.processNaturalQuery(query)
      const duration = Date.now() - startTime
      
      expect(result).toBeDefined()
      expect(duration).toBeLessThan(200) // Should be fast
    })
    
    it('should handle multiple queries efficiently', async () => {
      const queries = Array(10).fill('Find AI research')
      
      const startTime = Date.now()
      const results = await Promise.all(
        queries.map(q => nlp.processNaturalQuery(q))
      )
      const duration = Date.now() - startTime
      
      expect(results).toHaveLength(10)
      expect(duration).toBeLessThan(500) // Should handle batch efficiently
    })
    
    it('should cache pattern matching for performance', async () => {
      const query = 'Find machine learning papers'
      
      // First call - might be slower
      const start1 = Date.now()
      await nlp.processNaturalQuery(query)
      const time1 = Date.now() - start1
      
      // Second call - should be faster due to caching
      const start2 = Date.now()
      await nlp.processNaturalQuery(query)
      const time2 = Date.now() - start2
      
      // Second should be similar or faster
      expect(time2).toBeLessThanOrEqual(time1 + 10)
    })
  })
})