import api from './api';

// Типы данных
export interface Category {
  id: number;
  name: string;
  slug: string;
  parent_id: number | null;
  order: number;
  is_active: boolean;
  products_count?: number;
  subcategories?: Category[];
}

export interface Collection {
  id: number;
  name: string;
  slug: string;
  description: string | null;
  is_active: boolean;
}

export interface ProductImage {
  id: number;
  url: string;
  is_primary: boolean;
  product_id: number;
  image_url?: string; // URL изображения с сервера
}

export interface ProductVariant {
  id: number;
  name: string;
  sku: string;
  price: number;
  discount_price: number | null;
  stock: number;
  is_active: boolean;
  product_id: number;
}

export interface Product {
  id: number;
  name: string;
  slug: string;
  description: string;
  is_active: boolean;
  category_id: number;
  collection_id: number | null;
  category?: Category;
  collection?: Collection;
  images?: ProductImage[];
  variants?: ProductVariant[];
}

// Сервисы для работы с коллекциями
export const collectionService = {
  // Получить все коллекции
  getCollections: async (): Promise<Collection[]> => {
    const response = await api.get('/catalog/collections');
    return response.data.collections;
  },

  // Создать новую коллекцию
  createCollection: async (collection: Omit<Collection, 'id'>): Promise<Collection> => {
    const response = await api.post('/catalog/collections', collection);
    return response.data.collection;
  },

  // Обновить коллекцию
  updateCollection: async (id: number, collection: Partial<Collection>): Promise<Collection> => {
    const response = await api.put(`/catalog/collections/${id}`, collection);
    return response.data.collection;
  },

  // Удалить коллекцию
  deleteCollection: async (id: number): Promise<void> => {
    await api.delete(`/catalog/collections/${id}`);
  }
};

// Сервисы для работы с категориями
export const categoryService = {
  // Получить все категории в виде дерева
  getCategories: async (): Promise<Category[]> => {
    const response = await api.get('/catalog/categories');
    return response.data;
  },

  // Создать новую категорию
  createCategory: async (category: Omit<Category, 'id'>): Promise<Category> => {
    const response = await api.post('/catalog/categories', category);
    return response.data;
  },

  // Обновить категорию
  updateCategory: async (id: number, category: Partial<Category>): Promise<Category> => {
    const response = await api.put(`/catalog/categories/${id}`, category);
    return response.data;
  },

  // Удалить категорию
  deleteCategory: async (id: number): Promise<void> => {
    await api.delete(`/catalog/categories/${id}`);
  }
};

// Сервисы для работы с товарами
export const productService = {
  // Получить список товаров с фильтрацией
  getProducts: async (params?: {
    skip?: number;
    limit?: number;
    category_id?: number;
    collection_id?: number;
    search?: string;
    min_price?: number;
    max_price?: number;
    is_active?: boolean;
    include_variants?: boolean;
  }): Promise<Product[]> => {
    try {
      console.log('Запрос продуктов с параметрами:', params);
      const response = await api.get('/catalog/products', { 
        params: {
          ...params,
          include_variants: true
        } 
      });
      console.log('Ответ API:', response.data);
      
      // Проверяем, что получили массив продуктов
      if (!Array.isArray(response.data)) {
        console.error('Ответ API не является массивом:', response.data);
        return [];
      }
      
      // Формируем базовый URL для изображений
      const baseUrl = process.env.NEXT_PUBLIC_API_URL || 'http://127.0.0.1:8000/api';
      const apiBaseUrl = baseUrl.replace(/\/api$/, ''); // Убираем '/api' в конце, если есть
      
      // Обрабатываем URL изображений для каждого продукта
      const productsWithFixedImages = response.data.map((product: Product) => {
        if (product.images && Array.isArray(product.images)) {
          product.images = product.images.map(img => ({
            ...img,
            url: img.url && img.url.startsWith('http') 
              ? img.url 
              : img.url 
                ? `${apiBaseUrl}${img.url}` 
                : img.image_url 
                  ? `${apiBaseUrl}${img.image_url}` 
                  : '/placeholder-image.jpg'
          }));
        }
        
        console.log(`Обработанный продукт ${product.name} (ID: ${product.id}):`, product);
        console.log(`Изображения:`, product.images);
        
        return product;
      });
      
      return productsWithFixedImages;
    } catch (error) {
      console.error('Ошибка при получении продуктов:', error);
      throw error;
    }
  },

  // Получить детали товара по ID
  getProductById: async (id: number): Promise<Product> => {
    try {
      console.log(`Запрос данных продукта с ID: ${id}`);
      const response = await api.get(`/catalog/products/${id}`);
      console.log('Ответ API:', response.data);
      
      // Проверяем структуру ответа
      if (!response.data) {
        throw new Error('Пустой ответ от API');
      }
      
      let product: Product;
      
      // Формируем базовый URL для изображений
      const baseUrl = process.env.NEXT_PUBLIC_API_URL || 'http://127.0.0.1:8000/api';
      const apiBaseUrl = baseUrl.replace(/\/api$/, ''); // Убираем '/api' в конце, если есть
      
      // Если ответ содержит вложенный объект product
      if (response.data.product) {
        product = response.data.product;
        
        // Добавляем изображения из ответа
        if (response.data.images && Array.isArray(response.data.images)) {
          product.images = response.data.images.map(img => ({
            id: img.id,
            url: `${apiBaseUrl}${img.image_url}`,
            is_primary: img.is_primary,
            product_id: img.product_id
          }));
        }
        
        // Добавляем варианты из ответа
        if (response.data.variants && Array.isArray(response.data.variants)) {
          product.variants = response.data.variants;
        }
        
        // Добавляем коллекцию из ответа
        if (response.data.collection) {
          product.collection = response.data.collection;
        }
      } else {
        // Если структура ответа другая, используем как есть
        product = response.data;
        
        // Преобразуем URL изображений, если они есть
        if (product.images && Array.isArray(product.images)) {
          product.images = product.images.map(img => ({
            ...img,
            url: img.url.startsWith('http') ? img.url : `${apiBaseUrl}${img.url}`
          }));
        }
      }
      
      // Проверяем, что получили корректный объект продукта
      if (!product || !product.id) {
        throw new Error('Некорректные данные продукта в ответе API');
      }
      
      console.log('Обработанные данные продукта:', product);
      return product;
    } catch (error) {
      console.error('Ошибка при получении продукта:', error);
      throw error;
    }
  },

  // Получить детали товара по slug
  getProductBySlug: async (slug: string): Promise<Product> => {
    try {
      console.log(`Запрос данных продукта с slug: ${slug}`);
      
      // Проверяем, что slug не пустой
      if (!slug) {
        console.error('Ошибка: slug не может быть пустым');
        throw new Error('Slug не может быть пустым');
      }
      
      try {
        const response = await api.get(`/catalog/products/slug/${slug}`);
        console.log('Ответ API:', response.data);
        
        // Проверяем структуру ответа
        if (!response.data) {
          throw new Error('Пустой ответ от API');
        }
        
        let product: Product;
        
        // Формируем базовый URL для изображений
        const baseUrl = process.env.NEXT_PUBLIC_API_URL || 'http://127.0.0.1:8000/api';
        const apiBaseUrl = baseUrl.replace(/\/api$/, ''); // Убираем '/api' в конце, если есть
        
        // Если ответ содержит вложенный объект product
        if (response.data.product) {
          product = response.data.product;
          
          // Добавляем изображения из ответа
          if (response.data.images && Array.isArray(response.data.images)) {
            product.images = response.data.images.map(img => ({
              id: img.id,
              url: `${apiBaseUrl}${img.image_url}`,
              is_primary: img.is_primary,
              product_id: img.product_id
            }));
          }
          
          // Добавляем варианты из ответа
          if (response.data.variants && Array.isArray(response.data.variants)) {
            product.variants = response.data.variants;
          }
          
          // Добавляем коллекцию из ответа
          if (response.data.collection) {
            product.collection = response.data.collection;
          }
        } else {
          // Если структура ответа другая, используем как есть
          product = response.data;
          
          // Преобразуем URL изображений, если они есть
          if (product.images && Array.isArray(product.images)) {
            product.images = product.images.map(img => ({
              ...img,
              url: img.url.startsWith('http') ? img.url : `${apiBaseUrl}${img.url}`
            }));
          }
        }
        
        // Проверяем, что получили корректный объект продукта
        if (!product || !product.id) {
          throw new Error('Некорректные данные продукта в ответе API');
        }
        
        console.log('Обработанные данные продукта:', product);
        return product;
      } catch (apiError: any) {
        console.error('Ошибка API при получении продукта по slug:', apiError);
        
        // Проверяем наличие ответа и статуса
        if (apiError.response) {
          console.error('Статус ошибки:', apiError.response.status);
          console.error('Данные ошибки:', apiError.response.data);
          
          // Если продукт не найден, выбрасываем специальную ошибку
          if (apiError.response.status === 404) {
            throw new Error(`Продукт со slug "${slug}" не найден`);
          }
        }
        
        // Пробрасываем ошибку дальше
        throw apiError;
      }
    } catch (error) {
      console.error('Ошибка при получении продукта по slug:', error);
      throw error;
    }
  },

  // Создать товар
  createProduct: async (product: Omit<Product, 'id'>): Promise<Product> => {
    try {
      console.log('Создание нового продукта:', product);
      
      // Проверяем обязательные поля
      if (!product.name || !product.category_id) {
        throw new Error('Отсутствуют обязательные поля для создания продукта');
      }
      
      // Преобразуем числовые поля
      const productData = {
        ...product,
        category_id: Number(product.category_id),
        collection_id: product.collection_id ? Number(product.collection_id) : null
      };
      
      console.log('Отправляемые данные продукта:', productData);
      
      const response = await api.post('/catalog/products', productData);
      
      console.log('Ответ сервера при создании продукта:', response.data);
      
      // Проверяем структуру ответа
      if (!response.data || !response.data.product) {
        throw new Error('Неверный формат ответа от сервера при создании продукта');
      }
      
      return response.data.product;
    } catch (error) {
      console.error('Ошибка при создании продукта:', error);
      if (error.response) {
        console.error('Данные ответа:', error.response.data);
        console.error('Статус ответа:', error.response.status);
        console.error('Заголовки ответа:', error.response.headers);
      }
      throw error;
    }
  },

  // Обновить товар
  updateProduct: async (productId: number, product: Partial<Product>): Promise<Product> => {
    try {
      console.log(`Обновление продукта ${productId}:`, product);
      
      // Преобразуем числовые поля, если они есть
      const productData = {
        ...product,
        category_id: product.category_id !== undefined ? Number(product.category_id) : undefined,
        collection_id: product.collection_id ? Number(product.collection_id) : null
      };
      
      console.log('Отправляемые данные продукта:', productData);
      
      const response = await api.put(`/catalog/products/${productId}`, productData);
      
      console.log('Ответ сервера при обновлении продукта:', response.data);
      
      // Проверяем структуру ответа
      if (!response.data || !response.data.product) {
        throw new Error('Неверный формат ответа от сервера при обновлении продукта');
      }
      
      return response.data.product;
    } catch (error) {
      console.error('Ошибка при обновлении продукта:', error);
      if (error.response) {
        console.error('Данные ответа:', error.response.data);
        console.error('Статус ответа:', error.response.status);
        console.error('Заголовки ответа:', error.response.headers);
      }
      throw error;
    }
  },

  // Удалить товар
  deleteProduct: async (id: number): Promise<void> => {
    await api.delete(`/catalog/products/${id}`);
  },

  // Загрузить изображение товара
  uploadProductImage: async (productId: number, file: File, isPrimary: boolean = false): Promise<ProductImage> => {
    try {
      console.log(`Загрузка изображения для продукта ${productId}. Основное: ${isPrimary}`);
      
      const formData = new FormData();
      formData.append('file', file);
      formData.append('is_primary', isPrimary.toString());
      
      console.log('Отправка данных формы:', {
        productId,
        fileName: file.name,
        fileSize: file.size,
        fileType: file.type,
        isPrimary
      });
      
      const response = await api.post(`/catalog/products/${productId}/images`, formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      });
      
      console.log('Ответ сервера при загрузке изображения:', response.data);
      
      // Проверяем структуру ответа
      if (!response.data || !response.data.image) {
        throw new Error('Неверный формат ответа от сервера при загрузке изображения');
      }
      
      // Преобразуем ответ в нужный формат
      const imageData = response.data.image;
      
      // Формируем полный URL для изображения
      const baseUrl = process.env.NEXT_PUBLIC_API_URL || 'http://127.0.0.1:8000/api';
      const apiBaseUrl = baseUrl.replace(/\/api$/, ''); // Убираем '/api' в конце, если есть
      
      return {
        id: imageData.id,
        url: `${apiBaseUrl}${imageData.image_url}`,
        is_primary: imageData.is_primary,
        product_id: imageData.product_id
      };
    } catch (error) {
      console.error('Ошибка при загрузке изображения:', error);
      if (error.response) {
        console.error('Данные ответа:', error.response.data);
        console.error('Статус ответа:', error.response.status);
      }
      throw error;
    }
  },

  // Обновить изображение товара
  updateProductImage: async (productId: number, imageId: number, data: { is_primary?: boolean }): Promise<ProductImage> => {
    try {
      console.log(`Обновление изображения ${imageId} для продукта ${productId}`, data);
      
      const response = await api.put(`/catalog/images/${imageId}`, data);
      
      console.log('Ответ сервера при обновлении изображения:', response.data);
      
      // Проверяем структуру ответа
      if (!response.data || !response.data.image) {
        throw new Error('Неверный формат ответа от сервера при обновлении изображения');
      }
      
      // Преобразуем ответ в нужный формат
      const imageData = response.data.image;
      
      // Формируем полный URL для изображения
      const baseUrl = process.env.NEXT_PUBLIC_API_URL || 'http://127.0.0.1:8000/api';
      const apiBaseUrl = baseUrl.replace(/\/api$/, ''); // Убираем '/api' в конце, если есть
      
      return {
        id: imageData.id,
        url: `${apiBaseUrl}${imageData.image_url}`,
        is_primary: imageData.is_primary,
        product_id: imageData.product_id
      };
    } catch (error) {
      console.error('Ошибка при обновлении изображения:', error);
      if (error.response) {
        console.error('Данные ответа:', error.response.data);
        console.error('Статус ответа:', error.response.status);
      }
      throw error;
    }
  },

  // Удалить изображение товара
  deleteProductImage: async (productId: number, imageId: number): Promise<void> => {
    try {
      console.log(`Удаление изображения ${imageId} для продукта ${productId}`);
      
      const response = await api.delete(`/catalog/images/${imageId}`);
      
      console.log('Ответ сервера при удалении изображения:', response.data);
      
      // Проверяем успешность операции
      if (!response.data || !response.data.success) {
        throw new Error('Не удалось удалить изображение');
      }
    } catch (error) {
      console.error('Ошибка при удалении изображения:', error);
      if (error.response) {
        console.error('Данные ответа:', error.response.data);
        console.error('Статус ответа:', error.response.status);
      }
      throw error;
    }
  },

  // Добавить вариант товара
  addProductVariant: async (productId: number, variant: Omit<ProductVariant, 'id' | 'product_id'>): Promise<ProductVariant> => {
    try {
      console.log(`Добавление варианта для продукта ${productId}:`, variant);
      
      // Явно указываем все поля, чтобы избежать лишних данных
      const variantData = {
        product_id: productId,
        name: variant.name,
        sku: variant.sku,
        price: Number(variant.price), // Убедимся, что это число
        discount_price: variant.discount_price ? Number(variant.discount_price) : null,
        stock: Number(variant.stock),
        is_active: Boolean(variant.is_active || true)
      };
      
      console.log('Отправляемые данные варианта:', variantData);
      
      const response = await api.post(`/catalog/products/${productId}/variants`, variantData);
      
      console.log('Ответ сервера при добавлении варианта:', response.data);
      
      // Проверяем структуру ответа
      if (!response.data || !response.data.variant) {
        throw new Error('Неверный формат ответа от сервера при добавлении варианта');
      }
      
      return response.data.variant;
    } catch (error) {
      console.error('Ошибка при добавлении варианта:', error);
      if (error.response) {
        console.error('Данные ответа:', error.response.data);
        console.error('Статус ответа:', error.response.status);
        console.error('Заголовки ответа:', error.response.headers);
      }
      throw error;
    }
  },

  // Обновить вариант товара
  updateProductVariant: async (variantId: number, variant: Partial<ProductVariant>): Promise<ProductVariant> => {
    const response = await api.put(`/catalog/variants/${variantId}`, variant);
    return response.data.variant;
  },

  // Удалить вариант товара
  deleteProductVariant: async (productId: number, variantId: number): Promise<void> => {
    await api.delete(`/catalog/products/${productId}/variants/${variantId}`);
  }
}; 