/**
 * Tests end-to-end du pipeline complet
 */

import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import request from 'supertest'
import fs from 'fs'
import path from 'path'

let app
beforeAll(async () => {
  const serverModule = await import('../backend/server.js')
  app = serverModule.default
})

describe('Pipeline E2E', () => {
  let testFolderHash
  let testFileHash

  beforeAll(async () => {
    // Créer un dossier de test
    testFolderHash = 'test-e2e-' + Date.now()
  })

  afterAll(async () => {
    // Nettoyer les fichiers de test
    if (testFolderHash) {
      const cachePath = path.join('cache', testFolderHash)
      if (fs.existsSync(cachePath)) {
        fs.rmSync(cachePath, { recursive: true, force: true })
      }
    }
  })

  describe('Pipeline complet', () => {
    it('devrait traiter un document de bout en bout', async () => {
      // 1. Upload d'un document
      const uploadResponse = await request(app)
        .post('/api/extract')
        .attach('document', 'tests/fixtures/sample-cni.jpg')
        .field('folderHash', testFolderHash)
        .expect(200)

      expect(uploadResponse.body).toHaveProperty('success', true)
      testFileHash = uploadResponse.body.fileHash

      // 2. Vérifier l'extraction
      expect(uploadResponse.body).toHaveProperty('extraction')
      expect(uploadResponse.body.extraction).toHaveProperty('entities')
      expect(uploadResponse.body.extraction.entities).toHaveProperty('persons')

      // 3. Attendre le traitement
      await new Promise(resolve => setTimeout(resolve, 5000))

      // 4. Vérifier les résultats du dossier
      const resultsResponse = await request(app)
        .get(`/api/folders/${testFolderHash}/results`)
        .expect(200)

      expect(resultsResponse.body).toHaveProperty('documents')
      expect(resultsResponse.body.documents.length).toBeGreaterThan(0)

      // 5. Tester l'enrichissement
      const enrichResponse = await request(app)
        .post(`/api/folders/${testFolderHash}/files/${testFileHash}/enrich/person`)
        .expect(200)

      expect(enrichResponse.body).toHaveProperty('success', true)

      // 6. Vérifier le statut d'enrichissement
      await new Promise(resolve => setTimeout(resolve, 3000))

      const statusResponse = await request(app)
        .get(`/api/folders/${testFolderHash}/files/${testFileHash}/enrich/person/status`)
        .expect(200)

      expect(statusResponse.body).toHaveProperty('state')
      expect(['running', 'done', 'error']).toContain(statusResponse.body.state)
    })

    it('devrait gérer les erreurs de traitement', async () => {
      // Test avec un fichier corrompu
      const response = await request(app)
        .post('/api/extract')
        .attach('document', 'tests/fixtures/corrupted-file.jpg')
        .field('folderHash', testFolderHash)

      // Peut retourner 200 avec un traitement partiel ou 400 avec une erreur
      expect([200, 400]).toContain(response.status)
    })
  })

  describe('Performance', () => {
    it('devrait traiter les documents dans un délai raisonnable', async () => {
      const startTime = Date.now()

      const response = await request(app)
        .post('/api/extract')
        .attach('document', 'tests/fixtures/sample-document.pdf')
        .field('folderHash', testFolderHash)
        .expect(200)

      const duration = Date.now() - startTime

      expect(duration).toBeLessThan(30000) // 30 secondes max
      expect(response.body).toHaveProperty('success', true)
    })
  })
})