4NK_IA_front/src/services/folderApi.ts

/**
 * API pour la gestion des dossiers par hash
 */

const API_BASE_URL = '/api'

export interface FolderResult {
  fileHash: string
  document: {
    id: string
    fileName: string
    mimeType: string
    fileSize: number
    uploadTimestamp: number
  }
  classification: {
    documentType: string
    language: string
  }
  extraction: {
    text: {
      raw: string
      processed: string
    }
    entities: {
      persons: string[]
      addresses: string[]
      companies: string[]
    }
  }
  metadata: {
    quality: {
      globalConfidence: number
    }
  }
  status: {
    timestamp: number
  }
}

export interface FolderResponse {
  success: boolean
  folderHash: string
  results: FolderResult[]
  pending: Array<{
    fileHash: string
    folderHash: string
    timestamp: string
    status: string
  }>
  hasPending: boolean
  count: number
}

export interface CreateFolderResponse {
  success: boolean
  folderHash: string
  message: string
}

// Créer un nouveau dossier
export async function createFolder(): Promise<CreateFolderResponse> {
  const response = await fetch(`${API_BASE_URL}/folders`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
  })

  if (!response.ok) {
    throw new Error(`Erreur lors de la création du dossier: ${response.statusText}`)
  }

  return response.json()
}

// Créer le dossier par défaut avec les fichiers de test
export async function createDefaultFolder(): Promise<CreateFolderResponse> {
  const response = await fetch(`${API_BASE_URL}/folders/default`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
  })

  if (!response.ok) {
    throw new Error(`Erreur lors de la création du dossier par défaut: ${response.statusText}`)
  }

  return response.json()
}

// Utiliser le dossier par défaut existant (sans créer de nouveau dossier)
export async function getDefaultFolder(): Promise<CreateFolderResponse> {
  // Utiliser le dossier par défaut existant avec les fichiers de test
  return {
    success: true,
    folderHash: '7d99a85daf66a0081a0e881630e6b39b',
    message: 'Dossier par défaut récupéré',
  }
}

// Récupérer les résultats d'un dossier
export async function getFolderResults(folderHash: string): Promise<FolderResponse> {
  console.log(`[API] Appel getFolderResults pour le dossier: ${folderHash}`)
  console.log(`[API] API_BASE_URL: ${API_BASE_URL}`)
  console.log(`[API] URL complète: ${API_BASE_URL}/folders/${folderHash}/results`)

  try {
    // Créer un AbortController pour gérer le timeout
    const controller = new AbortController()
    const timeoutId = setTimeout(() => {
      console.log(`[API] Timeout après 10 secondes`)
      controller.abort()
    }, 10000)

    console.log(`[API] Début de la requête fetch...`)
    const url = `${API_BASE_URL}/folders/${folderHash}/results?t=${Date.now()}`
    console.log(`[API] URL finale: ${url}`)
    const response = await fetch(url, {
      signal: controller.signal,
      headers: {
        Accept: 'application/json',
        'Content-Type': 'application/json',
      },
    })

    clearTimeout(timeoutId)
    console.log(`[API] Réponse reçue:`, response.status, response.statusText)
    console.log(`[API] Headers:`, Object.fromEntries(response.headers.entries()))

    if (!response.ok) {
      console.error(`[API] Erreur HTTP:`, response.status, response.statusText)
      throw new Error(
        `Erreur lors de la récupération des résultats du dossier: ${response.statusText}`,
      )
    }

    console.log(`[API] Début du parsing JSON...`)
    const data = await response.json()
    console.log(`[API] Données reçues:`, data)
    console.log(`[API] Nombre de résultats:`, data.results?.length || 0)

    return data
  } catch (error) {
    if (error instanceof Error && error.name === 'AbortError') {
      console.error(`[API] Requête annulée (timeout)`)
      throw new Error('Timeout: La requête a pris trop de temps')
    }
    console.error(`[API] Erreur lors de l'appel API:`, error)
    throw error
  }
}

// Récupérer un fichier original depuis un dossier
export async function getFolderFile(folderHash: string, fileHash: string): Promise<Blob> {
  const response = await fetch(`${API_BASE_URL}/folders/${folderHash}/files/${fileHash}`)

  if (!response.ok) {
    throw new Error(`Erreur lors de la récupération du fichier: ${response.statusText}`)
  }

  return response.blob()
}

// Uploader un fichier dans un dossier
export async function uploadFileToFolder(file: File, folderHash: string): Promise<FolderResult> {
  const formData = new FormData()
  formData.append('document', file)
  formData.append('folderHash', folderHash)

  const response = await fetch(`${API_BASE_URL}/extract`, {
    method: 'POST',
    body: formData,
  })

  if (!response.ok) {
    throw new Error(`Erreur lors de l'upload: ${response.statusText}`)
  }

  return response.json()
}