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 des requêtes en développement
    if (import.meta.env.DEV) {
      console.log(`📤 Requête ${config.method?.toUpperCase()} vers: ${config.url}`)
    }
    
    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
    })
    
    if (error.response?.status === 401) {
      // 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')) {
        localStorage.removeItem('token')
        router.push('/login')
        toast.error('Session expirée, veuillez vous reconnecter')
      }
    } 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
}