import axios from 'axios'
import { useToast } from 'vue-toastification'
import router from '@/router'

// Configuration de l'URL de base selon l'environnement
const getBaseURL = () => {
  // Récupérer l'environnement depuis les variables Vite
  const environment = import.meta.env.VITE_ENVIRONMENT || 'local'
  
  // Log de debug pour l'environnement
  console.log(`🌍 Frontend - Environnement détecté: ${environment}`)
  console.log(`🔗 API URL: ${import.meta.env.VITE_API_URL}`)
  console.log(`🔧 VITE_ENVIRONMENT: ${import.meta.env.VITE_ENVIRONMENT}`)
  console.log(`🔧 NODE_ENV: ${import.meta.env.NODE_ENV}`)
  
  // Utiliser directement la variable d'environnement VITE_API_URL
  // qui est déjà configurée correctement pour chaque environnement
  const apiUrl = import.meta.env.VITE_API_URL
  
  if (!apiUrl) {
    console.warn('⚠️ VITE_API_URL non définie, utilisation de la valeur par défaut')
    // Valeurs par défaut selon l'environnement
    switch (environment) {
      case 'production':
        return 'https://api.lediscord.com'
      case 'development':
        return 'https://api-dev.lediscord.com' // API externe HTTPS en développement
      case 'local':
      default:
        return 'http://localhost:8000'
    }
  }
  
  console.log(`🎯 URL finale utilisée: ${apiUrl}`)
  return apiUrl
}

// Configuration de l'instance axios
const instance = axios.create({
  baseURL: getBaseURL(),
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// Log de la configuration
console.log(`🚀 Axios configuré avec l'URL de base: ${getBaseURL()}`)

// Request interceptor
instance.interceptors.request.use(
  config => {
    const token = localStorage.getItem('token')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
      // Log détaillé en développement
      if (import.meta.env.DEV) {
        console.log(`📤 Requête ${config.method?.toUpperCase()} vers: ${config.url}`, {
          hasToken: !!token,
          tokenLength: token.length,
          tokenPreview: token.substring(0, 20) + '...'
        })
      }
    } else {
      // Log si pas de token
      if (import.meta.env.DEV) {
        console.warn(`⚠️ Requête ${config.method?.toUpperCase()} vers: ${config.url} - Pas de token`)
      }
    }
    
    // Augmenter le timeout pour les requêtes POST/PUT avec FormData (uploads)
    if ((config.method === 'POST' || config.method === 'PUT') && config.data instanceof FormData) {
      config.timeout = 120000 // 2 minutes pour les uploads
      
      // IMPORTANT: Supprimer le Content-Type pour laisser le navigateur définir le multipart/form-data avec la boundary
      // Axios peut avoir mis 'application/json' par défaut ou on peut l'avoir mis manuellement
      if (config.headers && config.headers['Content-Type']) {
        delete config.headers['Content-Type']
      }
    }
    
    return config
  },
  error => {
    console.error('❌ Erreur dans l\'intercepteur de requête:', error)
    return Promise.reject(error)
  }
)

// Response interceptor
instance.interceptors.response.use(
  response => {
    // Log des réponses en développement
    if (import.meta.env.DEV) {
      console.log(`📥 Réponse ${response.status} de: ${response.config.url}`)
    }
    return response
  },
  error => {
    const toast = useToast()
    
    // Log détaillé des erreurs
    console.error('❌ Erreur API:', {
      status: error.response?.status,
      statusText: error.response?.statusText,
      url: error.config?.url,
      method: error.config?.method,
      data: error.response?.data,
      headers: error.response?.headers,
      requestHeaders: error.config?.headers
    })
    
    // Log supplémentaire pour les erreurs 401/403/422
    if ([401, 403, 422].includes(error.response?.status)) {
      const token = localStorage.getItem('token')
      console.error(`🔍 Diagnostic erreur ${error.response?.status}:`, {
        hasToken: !!token,
        tokenLength: token?.length,
        url: error.config?.url,
        method: error.config?.method,
        validationErrors: error.response?.data?.detail
      })
    }
    
    if (error.response?.status === 401) {
      // Ne pas déconnecter automatiquement sur les requêtes POST/PUT avec FormData
      // car les erreurs peuvent être dues à des problèmes réseau temporaires sur mobile
      const isFormDataUpload = error.config?.data instanceof FormData || 
                               (error.config?.method === 'POST' || error.config?.method === 'PUT')
      
      // Ne pas rediriger si on est déjà sur une page d'auth
      const currentRoute = router.currentRoute.value
      if (!currentRoute.path.includes('/login') && !currentRoute.path.includes('/register')) {
        // Pour les uploads, ne déconnecter que si c'est vraiment une erreur d'authentification
        // (pas juste une erreur réseau qui se manifeste comme 401)
        if (!isFormDataUpload || error.response?.data?.detail?.includes('credentials') || error.response?.data?.detail?.includes('token')) {
          localStorage.removeItem('token')
          router.push('/login')
          toast.error('Session expirée, veuillez vous reconnecter')
        } else {
          // Pour les uploads, juste afficher une erreur sans déconnecter
          toast.error('Erreur lors de l\'upload. Veuillez réessayer.')
        }
      }
    } else if (error.response?.status === 403) {
      toast.error('Accès non autorisé')
    } else if (error.response?.status === 500) {
      toast.error('Erreur serveur, veuillez réessayer plus tard')
    } else if (error.code === 'ECONNABORTED') {
      toast.error('Délai d\'attente dépassé, veuillez réessayer')
    } else if (!error.response) {
      toast.error('Erreur de connexion, vérifiez votre connexion internet')
    }
    
    return Promise.reject(error)
  }
)

export default instance

// Fonction utilitaire pour construire les URLs des médias
export function getMediaUrl(path) {
  if (!path) return null
  if (typeof path !== 'string') return path
  if (path.startsWith('http')) return path
  
  const baseUrl = getBaseURL()
  
  // Déjà un chemin uploads complet
  if (path.startsWith('/uploads/')) {
    return `${baseUrl}${path}`
  }
  
  // Chemins relatifs issus de l'API (ex: /avatars/..., /vlogs/..., /albums/...)
  if (path.startsWith('/')) {
    return `${baseUrl}/uploads${path}`
  }
  
  // Fallback
  return `${baseUrl}/uploads/${path}`
}

// Fonction utilitaire pour obtenir l'environnement actuel
export function getCurrentEnvironment() {
  return import.meta.env.VITE_ENVIRONMENT || 'local'
}

// Fonction utilitaire pour vérifier si on est en production
export function isProduction() {
  return getCurrentEnvironment() === 'production'
}

// Fonction utilitaire pour vérifier si on est en développement
export function isDevelopment() {
  return getCurrentEnvironment() === 'development'
}

// Fonction utilitaire pour vérifier si on est en local
export function isLocal() {
  return getCurrentEnvironment() === 'local'
}

// Fonction utilitaire pour obtenir l'URL de l'API
export function getApiUrl() {
  return import.meta.env.VITE_API_URL || getBaseURL()
}

// Fonction utilitaire pour obtenir l'URL de l'application
export function getAppUrl() {
  return import.meta.env.VITE_APP_URL || window.location.origin
}

// Fonction utilitaire pour upload de FormData via fetch natif
// (contourne les problèmes d'axios avec FormData sur certains navigateurs/mobiles)
export async function uploadFormData(endpoint, formData) {
  const token = localStorage.getItem('token')
  const apiUrl = getApiUrl()
  
  const response = await fetch(`${apiUrl}${endpoint}`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`
      // Ne PAS mettre Content-Type, fetch le gère automatiquement avec FormData
    },
    body: formData
  })

  if (!response.ok) {
    const errorData = await response.json().catch(() => ({}))
    const error = new Error(errorData.detail || 'Erreur lors de l\'upload')
    error.response = { status: response.status, data: errorData }
    throw error
  }

  return await response.json()
}
