import { useToast } from './useToast'

export function useApi () {
  const { showSuccess, showError, showInfo } = useToast()
  const { public: publicConfig } = useRuntimeConfig()
  const API_BASE_URL = publicConfig.apiBaseUrl || 'http://localhost:3000'
  const parsedApiTimeout = Number(publicConfig.apiTimeout ?? 30000)
  const API_TIMEOUT = Number.isNaN(parsedApiTimeout) ? 30000 : parsedApiTimeout

  const apiCall = async (endpoint, options = {}) => {
    const url = `${API_BASE_URL}${endpoint}`
    const defaultOptions = {
      credentials: 'include',
      headers: {
        'Content-Type': 'application/json'
      }
    }

    // Ajouter un timeout à la requête
    const controller = new AbortController()
    const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT)

    try {
      const response = await fetch(url, {
        ...defaultOptions,
        ...options,
        headers: {
          ...defaultOptions.headers,
          ...options.headers
        },
        signal: controller.signal
      })

      clearTimeout(timeoutId)

      if (response.ok) {
        let data = null
        if (response.status !== 204) {
          const contentType = response.headers.get('content-type') || ''
          if (contentType.includes('application/json') || contentType.includes('application/ld+json') || contentType.includes('+json')) {
            const text = await response.text()
            data = text ? JSON.parse(text) : null
          } else {
            const text = await response.text()
            data = text || null
          }
        }
        return { success: true, data }
      } else {
        const contentType = response.headers.get('content-type') || ''
        let errorData = {}
        if (contentType.includes('application/json')) {
          errorData = await response.json().catch(() => ({}))
        } else {
          const text = await response.text().catch(() => '')
          errorData = text ? { message: text } : {}
        }
        const errorMessage = errorData.message || `Erreur ${response.status}: ${response.statusText}`
        showError(errorMessage)
        return { success: false, error: errorMessage, status: response.status }
      }
    } catch (error) {
      clearTimeout(timeoutId)
      const errorMessage = error.name === 'AbortError' ? 'Timeout de la requête' : error.message || 'Erreur réseau'
      showError(`Erreur réseau: ${errorMessage}`)
      return { success: false, error: errorMessage }
    }
  }

  const get = async (endpoint) => {
    return apiCall(endpoint, { method: 'GET' })
  }

  const post = async (endpoint, data) => {
    return apiCall(endpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/ld+json'
      },
      body: JSON.stringify(data)
    })
  }

  const patch = async (endpoint, data) => {
    return apiCall(endpoint, {
      method: 'PATCH',
      headers: {
        'Content-Type': 'application/merge-patch+json'
      },
      body: JSON.stringify(data)
    })
  }

  const del = async (endpoint) => {
    return apiCall(endpoint, { method: 'DELETE' })
  }

  return {
    apiCall,
    get,
    post,
    patch,
    delete: del
  }
}