import axios from 'axios';
import { useAuth } from '../auth'; // Импортируем функцию авторизации
import { isAccountBlocked } from './socketService'; // Импортируем проверку блокировки из socketService
import deviceSecurityService from './deviceSecurityService'; // Импортируем сервис безопасности устройств

// Создаем экземпляр Axios с базовым URL нашего API
// Настраиваем базовый URL в зависимости от окружения

// Храним токены отмены запросов для возможности отмены при блокировке
const cancelTokenSources = new Map();

// Проверка блокировки аккаунта из localStorage
const checkAccountBlockStatus = () => {
  try {
    const blockedInfo = localStorage.getItem('accountBlockedInfo');
    if (blockedInfo) {
      const blockedData = JSON.parse(blockedInfo);
      if (blockedData?.blocked === true) {
        console.warn('[API] Обнаружен заблокированный аккаунт, запросы невозможны');
        return true;
      }
    }

    // Проверяем также флаг из socketService
    if (isAccountBlocked && isAccountBlocked()) {
      console.warn('[API] Аккаунт заблокирован согласно socketService, запросы невозможны');
      return true;
    }

    // Проверяем блокировку устройства
    if (deviceSecurityService && deviceSecurityService.isDeviceBlocked()) {
      console.warn('[API] Устройство заблокировано, запросы невозможны');
      return true;
    }

    return false;
  } catch (e) {
    console.error('[API] Ошибка при проверке статуса блокировки:', e);
    return false;
  }
};

// Определяем базовый URL в зависимости от среды выполнения
const getBaseUrl = () => {
  // Всегда используем относительный путь /api.
  // В режиме разработки Vite dev server будет проксировать эти запросы согласно настройке server.proxy в vite.config.js.
  return '/api';
};

// Создаем экземпляр Axios
const apiClient = axios.create({
  baseURL: getBaseUrl(),
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json',
  },
});

// Интерсептор запросов для добавления токена авторизации и device fingerprint
apiClient.interceptors.request.use(
  async (config) => {
    // Проверяем блокировку перед отправкой запроса
    if (checkAccountBlockStatus()) {
      const error = new Error('Запрос отменен: аккаунт или устройство заблокированы');
      error.code = 'ACCOUNT_OR_DEVICE_BLOCKED';
      throw error;
    }

    // Добавляем токен авторизации
    const token = localStorage.getItem('userToken');
    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
    }

    // Добавляем device fingerprint и информацию об устройстве
    if (deviceSecurityService && deviceSecurityService.getCurrentFingerprint()) {
      const fingerprintHeaders = deviceSecurityService.injectFingerprintHeaders();
      Object.assign(config.headers, fingerprintHeaders);
    }

    // Создаем токен отмены для этого запроса
    const requestKey = `${config.method}-${config.url}`;
    const source = axios.CancelToken.source();
    config.cancelToken = source.token;
    cancelTokenSources.set(requestKey, source);

    console.log(`[API] Отправка ${config.method?.toUpperCase()} запроса:`, config.url);
    return config;
  },
  (error) => {
    console.error('[API] Ошибка в интерсепторе запросов:', error);
    return Promise.reject(error);
  }
);

// Интерсептор ответов для обработки ошибок
apiClient.interceptors.response.use(
  (response) => {
    // Удаляем источник токена отмены при успешном ответе
    const requestKey = `${response.config.method}-${response.config.url}`;
    cancelTokenSources.delete(requestKey);
    
    console.log(`[API] Успешный ответ от ${response.config.url}:`, response.status);
    return response;
  },
  async (error) => {
    // Удаляем источник токена отмены при ошибке
    if (error.config) {
      const requestKey = `${error.config.method}-${error.config.url}`;
      cancelTokenSources.delete(requestKey);
    }
    
    // Проверяем на блокировку устройства
    if (error.response && error.response.status === 403) {
      const errorData = error.response.data;
      
      // Проверка на блокировку устройства
      if (errorData && errorData.code === 'DEVICE_BLOCKED') {
        console.error('[API] Получено уведомление о блокировке устройства:', errorData);
        
        // Обрабатываем блокировку устройства через deviceSecurityService
        if (deviceSecurityService && typeof deviceSecurityService.handleDeviceBlock === 'function') {
          deviceSecurityService.handleDeviceBlock(errorData);
        }
        
        return Promise.reject(error);
      }
      
      // Проверка на признаки блокировки аккаунта в ответе
      if (errorData && (
          errorData.blocked === true || 
          errorData.message?.includes('заблокирован') || 
          errorData.message?.includes('blocked')
      )) {
        console.error('[API] Получено уведомление о блокировке аккаунта:', errorData);
        
        // Вызываем обработчик блокировки аккаунта
        setTimeout(() => {
          const { handleAccountBlocked } = useAuth();
          if (typeof handleAccountBlocked === 'function') {
            handleAccountBlocked(errorData);
          } else {
            console.error('[API] Функция handleAccountBlocked недоступна');
          }
        }, 100);
      }
    }

    // Проверяем на ошибку требования device fingerprint
    if (error.response && error.response.status === 400) {
      const errorData = error.response.data;
      if (errorData && errorData.code === 'DEVICE_FINGERPRINT_REQUIRED') {
        console.warn('[API] Требуется device fingerprint для запроса');
        
        // Пытаемся инициализировать систему безопасности устройств
        if (deviceSecurityService && typeof deviceSecurityService.initialize === 'function') {
          try {
            await deviceSecurityService.initialize();
            console.log('[API] Device fingerprint инициализирован, повторяем запрос');
            
            // Повторяем запрос с новым fingerprint
            const originalRequest = error.config;
            const fingerprintHeaders = deviceSecurityService.injectFingerprintHeaders();
            Object.assign(originalRequest.headers, fingerprintHeaders);
            
            return apiClient(originalRequest);
          } catch (initError) {
            console.error('[API] Не удалось инициализировать device fingerprint:', initError);
          }
        }
      }
    }

    // Обработка ошибки токена авторизации
    if (error.response && error.response.status === 401) {
      console.warn('[API] Ошибка авторизации, возможно токен истек');
      
      // Вызываем logout для очистки состояния
      setTimeout(() => {
        const { logout } = useAuth();
        if (typeof logout === 'function') {
          logout();
        }
      }, 100);
    }

    console.error(`[API] Ошибка запроса к ${error.config?.url}:`, error.response?.status, error.response?.data);
    return Promise.reject(error);
  }
);

// Функция для отмены всех активных запросов (при блокировке)
const cancelActiveRequests = () => {
  cancelTokenSources.forEach((source, key) => {
    source.cancel(`Запрос ${key} отменен из-за блокировки`);
    console.log(`[API] Запрос ${key} отменен`);
  });
  cancelTokenSources.clear();
};

// Функция для явной установки токена аутентификации
const setAuthToken = (token) => {
  if (token) {
    apiClient.defaults.headers.common['Authorization'] = `Bearer ${token}`;
  } else {
    delete apiClient.defaults.headers.common['Authorization'];
  }
};

// Экспортируем функции для конкретных эндпоинтов
export default {
  // Добавляем новые утилитарные методы
  cancelActiveRequests,
  setAuthToken,
  checkAccountBlockStatus,
  
  register(userData) {
    return apiClient.post('/auth/register', userData);
  },
  login(credentials) {
    return apiClient.post('/auth/login', credentials);
  },
  getMe() { // Для получения данных пользователя
    return apiClient.get('/auth/me');
  },
  updateUserProfile(profileData) { 
    console.log('[API] Отправка запроса на обновление профиля:', profileData);
    return apiClient.put('/users/profile', profileData);
  },
  getSuggestions() {
    return apiClient.get('/users/suggestions');
  },
  likeUser(userId) {
    return apiClient.post(`/actions/like/${userId}`);
  },
  passUser(userId) {
    return apiClient.post(`/actions/pass/${userId}`);
  },
  uploadUserProfilePhoto(formData) {
    return apiClient.post('/users/profile/photo', formData, {
      headers: {
        'Content-Type': 'multipart/form-data', // Важно для FormData
      },
    });
  },
  // Новые методы для управления фотографиями
  setMainPhoto(photoId) {
    return apiClient.put(`/users/profile/photo/${photoId}/set-main`);
  },
  deletePhoto(photoId) {
    return apiClient.delete(`/users/profile/photo/${photoId}`);
  },
  getUserConversations() {
    return apiClient.get('/conversations'); // GET /api/conversations
  },
  getMessagesForConversation(conversationId) {
    return apiClient.get(`/conversations/${conversationId}/messages`); // GET /api/conversations/:id/messages
  },
  deleteMessage(conversationId, messageId) {
    return apiClient.delete(`/conversations/${conversationId}/messages/${messageId}`);
  },
  editMessage(conversationId, messageId, newText) {
    return apiClient.put(`/conversations/${conversationId}/messages/${messageId}`, { text: newText });
  },
  
  // Новый метод для получения профиля пользователя по ID
  getUserById(userId) {
    return apiClient.get(`/users/${userId}`);
  },
  
  // Новый метод для получения статистики пользователя
  getUserStats() {
    return apiClient.get('/users/stats');
  },
  
  // Новый метод для записи просмотра профиля
  recordProfileView(userId, source = 'other') {
    return apiClient.post(`/users/${userId}/view`, { source });
  },
  
  // Методы для работы с жалобами
  createReport(reportData) {
    return apiClient.post('/reports', reportData);
  },
  
  // Админские методы для жалоб
  getReports(params = {}) {
    return apiClient.get('/admin/reports', { params });
  },
  getReportById(reportId) {
    return apiClient.get(`/admin/reports/${reportId}`);
  },
  reviewReport(reportId, reviewData) {
    return apiClient.put(`/admin/reports/${reportId}/review`, reviewData);
  },
  blockUser(userId, blockData) {
    return apiClient.post(`/admin/users/${userId}/block`, blockData);
  },
  unblockUser(userId, reason) {
    return apiClient.post(`/admin/users/${userId}/unblock`, { reason });
  },
  
  // Новые методы для управления блокировками устройств
  checkDeviceBlock(deviceData) {
    return apiClient.post('/security/check-device', deviceData);
  },
  reportSuspiciousActivity(activityData) {
    return apiClient.post('/security/report-suspicious', activityData);
  },
  getBlockedDevices(params = {}) {
    return apiClient.get('/admin/blocked-devices', { params });
  },
  getBlockedDeviceDetails(deviceId) {
    return apiClient.get(`/admin/blocked-devices/${deviceId}`);
  },
  blockDevice(deviceData) {
    return apiClient.post('/admin/block-device', deviceData);
  },
  unblockDevice(deviceFingerprint, reason) {
    return apiClient.post('/admin/unblock-device', { deviceFingerprint, reason });
  }
};