frontend/src/services/apiClient.js

import axios from 'axios';
import cookieService from '../services/cookieService';

// Create axios instance with default config
const API_BASE_URL = import.meta.env.VITE_API_URL ||
  (import.meta.env.VITE_NODE_ENV === 'production' ?
    'http://46.62.218.169' :
    'http://localhost:5000');
console.log('API_BASE_URL:', API_BASE_URL);

// Ensure API_BASE_URL ends with /api for consistency
const normalizedBaseUrl = API_BASE_URL.endsWith('/api') ? API_BASE_URL : `${API_BASE_URL}/api`;

const apiClient = axios.create({
  baseURL: normalizedBaseUrl,
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json',
  },
  withCredentials: true, // Send cookies with requests
});

// Request interceptor to add auth token
apiClient.interceptors.request.use(
  async (config) => {
    // Enhanced logging for debugging
    const isDevelopment = import.meta.env.VITE_NODE_ENV === 'development';
    if (isDevelopment) {
      console.log('🚀 [API Request]', {
        method: config.method?.toUpperCase(),
        url: config.baseURL + config.url,
        headers: config.headers,
        data: config.data
      });

      // Special logging for auth requests to verify field transformation
      if (config.url?.includes('/auth/register')) {
        console.log('🔐 [Auth Register] Request data verification:', {
          hasConfirmPassword: 'confirmPassword' in (config.data || {}),
          hasConfirmPassword: 'confirm_password' in (config.data || {}),
          dataKeys: Object.keys(config.data || {}),
          fullData: config.data
        });
      }
    }

    // Get token from cookie service with fallback to localStorage
    let token = null;
    try {
      const tokens = await cookieService.getAuthTokens();
      token = tokens?.accessToken;
    } catch (error) {
      console.warn('🍪 [Cookie] Error getting auth tokens, trying localStorage:', error.message);
      token = localStorage.getItem('token');
    }

    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
      if (isDevelopment) {
        console.log('🔑 [Token] Added token to request headers');
      }
    } else {
      if (isDevelopment) {
        console.log('🔑 [Token] No token found for request');
      }
    }

    return config;
  },
  (error) => {
    console.error('❌ [API Request Error]', error);
    return Promise.reject(error);
  }
);

// Response interceptor to handle token refresh and errors
apiClient.interceptors.response.use(
  (response) => {
    // Enhanced logging for debugging
    const isDevelopment = import.meta.env.VITE_NODE_ENV === 'development';
    if (isDevelopment) {
      console.log('✅ [API Response]', {
        status: response.status,
        method: response.config.method?.toUpperCase(),
        url: response.config.baseURL + response.config.url,
        data: response.data
      });
    }
    return response;
  },
  async (error) => {
    const isDevelopment = import.meta.env.VITE_NODE_ENV === 'development';
    const originalRequest = error.config;

    // Enhanced error logging
    if (isDevelopment) {
      console.error('❌ [API Response Error]', {
        status: error.response?.status,
        method: originalRequest?.method?.toUpperCase(),
        url: originalRequest ? originalRequest.baseURL + originalRequest.url : 'unknown',
        message: error.message,
        response: error.response?.data,
        headers: error.response?.headers
      });
    }

    // Handle 401 Unauthorized errors
    if (error.response?.status === 401) {
      if (isDevelopment) {
        console.log('🔐 [Auth] 401 error detected, attempting token refresh');
      }

      // If we haven't retried this request yet
      if (!originalRequest._retry) {
        originalRequest._retry = true;

        try {
          // Clear all authentication data
          await cookieService.clearAuthTokens();
          localStorage.removeItem('token');

          if (isDevelopment) {
            console.log('🔐 [Auth] Cleared all authentication data');
          }

          // Redirect to login page
          const currentPath = window.location.pathname;
          if (currentPath !== '/login' && currentPath !== '/register') {
            if (isDevelopment) {
              console.log('🔐 [Auth] Redirecting to login page');
            }
            window.location.href = '/login';
          }

        } catch (refreshError) {
          if (isDevelopment) {
            console.error('🔐 [Auth] Error during token refresh:', refreshError);
          }

          // Even if refresh fails, clear auth data
          await cookieService.clearAuthTokens();
          localStorage.removeItem('token');
          window.location.href = '/login';

          return Promise.reject(refreshError);
        }
      }
    }

    // Handle network errors
    if (!error.response) {
      if (isDevelopment) {
        console.error('🌐 [Network] No response received:', {
          url: originalRequest?.baseURL + originalRequest?.url,
          message: error.message
        });
      }

      // You might want to implement offline mode here
      // For now, just reject the error
      return Promise.reject(error);
    }

    return Promise.reject(error);
  }
);

export default apiClient;