import api from './api';

// Типы данных
export interface OrderItem {
  id: number;
  order_id: number;
  product_id: number;
  variant_id?: number;
  quantity: number;
  price: number;
  product: {
    id: number;
    name: string;
    image?: string;
    sku?: string;
  };
  variant_name?: string;
  variant_size?: string;
  variant_color?: string;
  product_name?: string;
  product_sku?: string;
  product_image?: string;
}

export interface Address {
  id?: number;
  address_line1: string;
  address_line2?: string;
  city: string;
  state: string;
  postal_code: string;
  country: string;
}

export interface Order {
  id: number;
  user_id: number;
  user_email?: string;
  user_name?: string;
  status: string;
  total_amount: number;
  shipping_address: string | Address;
  shipping_method?: string;
  payment_method: string;
  tracking_number?: string;
  notes?: string;
  created_at: string;
  updated_at?: string;
  items: OrderItem[];
}

export interface OrderCreate {
  shipping_address_id: number;
  payment_method: string;
  notes?: string;
  items?: {
    product_id: number;
    variant_id?: number;
    quantity: number;
  }[];
}

export interface OrderUpdate {
  status?: string;
  shipping_address_id?: number;
  payment_method?: string;
  shipping_method?: string;
  tracking_number?: string;
  notes?: string;
}

// Сервис для работы с заказами
export const orderService = {
  // Получить список заказов пользователя
  getUserOrders: async (): Promise<Order[]> => {
    try {
      const response = await api.get('/orders/');
      console.log('Ответ от сервера с заказами:', response.data);
      
      // Проверяем, что ответ содержит данные
      if (response.data) {
        let orders = [];
        
        // Если ответ - это массив, используем его
        if (Array.isArray(response.data)) {
          orders = response.data;
        }
        // Если ответ - это объект с полем orders, используем это поле
        else if (response.data.orders && Array.isArray(response.data.orders)) {
          orders = response.data.orders;
        }
        
        // Преобразуем данные заказов, чтобы гарантировать наличие всех необходимых полей
        return orders.map(order => {
          // Гарантируем, что у заказа есть массив items
          const items = Array.isArray(order.items) ? order.items.map(item => ({
            id: item.id || 0,
            order_id: item.order_id || order.id || 0,
            product_id: item.product_id || 0,
            variant_id: item.variant_id,
            quantity: item.quantity || 1,
            price: item.price || 0,
            // Гарантируем, что у элемента заказа есть объект product
            product: item.product || {
              id: item.product_id || 0,
              name: 'Товар',
              image: null
            },
            variant_name: item.variant_name || ''
          })) : [];
          
          // Обрабатываем адрес доставки
          let shippingAddress = order.shipping_address || '';
          
          // Если адрес доставки - это объект, оставляем его как есть
          // Если адрес доставки - это строка, оставляем его как строку
          // В противном случае, устанавливаем пустую строку
          if (typeof shippingAddress !== 'string' && typeof shippingAddress !== 'object') {
            shippingAddress = '';
          }
          
          return {
            id: order.id || 0,
            user_id: order.user_id || 0,
            status: order.status || 'pending',
            total_amount: order.total_amount || 0,
            shipping_address: shippingAddress,
            payment_method: order.payment_method || '',
            created_at: order.created_at || new Date().toISOString(),
            updated_at: order.updated_at,
            items: items
          };
        });
      }
      
      // Если ответ не содержит массив заказов, возвращаем пустой массив
      console.warn('Ответ от сервера не содержит массив заказов:', response.data);
      return [];
    } catch (error) {
      console.error('Ошибка при получении заказов пользователя:', error);
      // В случае ошибки возвращаем пустой массив
      return [];
    }
  },

  // Получить заказ по ID
  getOrderById: async (id: number): Promise<Order> => {
    if (!id || isNaN(id)) {
      throw new Error('Некорректный ID заказа');
    }
    
    try {
      const response = await api.get(`/orders/${id}/`);
      console.log('Ответ от сервера с заказом:', response.data);
      
      // Проверяем, что ответ содержит данные
      if (response.data) {
        // Получаем данные заказа из ответа
        let orderData = response.data;
        
        // Если ответ - это объект с полем order, используем это поле
        if (response.data.order) {
          orderData = response.data.order;
        }
        
        // Гарантируем, что у заказа есть массив items
        const items = Array.isArray(orderData.items) ? orderData.items.map(item => ({
          id: item.id || 0,
          order_id: item.order_id || orderData.id || 0,
          product_id: item.product_id || 0,
          variant_id: item.variant_id,
          quantity: item.quantity || 1,
          price: item.price || 0,
          // Гарантируем, что у элемента заказа есть объект product
          product: item.product || {
            id: item.product_id || 0,
            name: 'Товар',
            image: null
          },
          variant_name: item.variant_name || ''
        })) : [];
        
        // Обрабатываем адрес доставки
        let shippingAddress = orderData.shipping_address || '';
        
        // Если адрес доставки - это объект, оставляем его как есть
        // Если адрес доставки - это строка, оставляем его как строку
        // В противном случае, устанавливаем пустую строку
        if (typeof shippingAddress !== 'string' && typeof shippingAddress !== 'object') {
          shippingAddress = '';
        }
        
        // Возвращаем заказ с гарантированными полями
        return {
          id: orderData.id || 0,
          user_id: orderData.user_id || 0,
          user_email: orderData.user_email || '',
          user_name: orderData.user_name || '',
          status: orderData.status || 'pending',
          total_amount: orderData.total_amount || 0,
          shipping_address: shippingAddress,
          shipping_method: orderData.shipping_method || 'Стандартная доставка',
          payment_method: orderData.payment_method || '',
          tracking_number: orderData.tracking_number || '',
          notes: orderData.notes || '',
          created_at: orderData.created_at || new Date().toISOString(),
          updated_at: orderData.updated_at,
          items: items
        };
      }
      
      throw new Error('Ответ от сервера не содержит данные заказа');
    } catch (error) {
      console.error(`Ошибка при получении заказа с ID ${id}:`, error);
      throw error;
    }
  },

  // Получить список всех заказов (для админки)
  getOrders: async (params?: { 
    skip?: number; 
    limit?: number; 
    status?: string;
    dateFrom?: string;
    dateTo?: string;
    search?: string;
  }): Promise<Order[]> => {
    try {
      // Формируем строку запроса из параметров
      const queryParams = new URLSearchParams();
      if (params) {
        if (params.skip !== undefined) queryParams.append('skip', params.skip.toString());
        if (params.limit !== undefined) queryParams.append('limit', params.limit.toString());
        if (params.status) queryParams.append('status', params.status);
        if (params.dateFrom) queryParams.append('date_from', params.dateFrom);
        if (params.dateTo) queryParams.append('date_to', params.dateTo);
        if (params.search) queryParams.append('search', params.search);
      }
      
      const queryString = queryParams.toString() ? `?${queryParams.toString()}` : '';
      const response = await api.get(`/orders${queryString}`);
      console.log('Ответ от сервера с заказами (админка):', response.data);
      
      // Проверяем, что ответ содержит данные
      if (response.data) {
        let orders = [];
        
        // Если ответ - это массив, используем его
        if (Array.isArray(response.data)) {
          orders = response.data;
        }
        // Если ответ - это объект с полем orders, используем это поле
        else if (response.data.orders && Array.isArray(response.data.orders)) {
          orders = response.data.orders;
        }
        
        // Преобразуем данные заказов, чтобы гарантировать наличие всех необходимых полей
        return orders.map(order => {
          // Гарантируем, что у заказа есть массив items
          const items = Array.isArray(order.items) ? order.items.map(item => ({
            id: item.id || 0,
            order_id: item.order_id || order.id || 0,
            product_id: item.product_id || 0,
            variant_id: item.variant_id,
            quantity: item.quantity || 1,
            price: item.price || 0,
            // Гарантируем, что у элемента заказа есть объект product
            product: item.product || {
              id: item.product_id || 0,
              name: item.product_name || 'Товар',
              image: item.product_image || null
            },
            variant_name: item.variant_name || ''
          })) : [];
          
          // Обрабатываем адрес доставки
          let shippingAddress = order.shipping_address || '';
          
          // Если адрес доставки - это объект, оставляем его как есть
          // Если адрес доставки - это строка, оставляем его как строку
          // В противном случае, устанавливаем пустую строку
          if (typeof shippingAddress !== 'string' && typeof shippingAddress !== 'object') {
            shippingAddress = '';
          }
          
          return {
            id: order.id || 0,
            user_id: order.user_id || 0,
            user_email: order.user_email || '',
            user_name: order.user_name || '',
            status: order.status || 'pending',
            total_amount: order.total_amount || 0,
            shipping_address: shippingAddress,
            shipping_method: order.shipping_method || 'Стандартная доставка',
            payment_method: order.payment_method || '',
            created_at: order.created_at || new Date().toISOString(),
            updated_at: order.updated_at,
            items: items
          };
        });
      }
      
      // Если ответ не содержит массив заказов, возвращаем пустой массив
      console.warn('Ответ от сервера не содержит массив заказов:', response.data);
      return [];
    } catch (error) {
      console.error('Ошибка при получении списка заказов:', error);
      // В случае ошибки возвращаем пустой массив
      return [];
    }
  },

  // Создать новый заказ
  createOrder: async (order: OrderCreate): Promise<Order> => {
    console.log('Отправка запроса на создание заказа:', order);
    try {
      const response = await api.post('/orders/', order);
      console.log('Успешный ответ от сервера:', response.data);
      return response.data;
    } catch (error) {
      console.error('Ошибка при создании заказа:', error);
      if (error.response) {
        console.error('Статус ответа:', error.response.status);
        console.error('Данные ответа:', error.response.data);
      }
      throw error;
    }
  },

  // Обновить заказ
  updateOrder: async (id: number, order: OrderUpdate): Promise<Order> => {
    const response = await api.put(`/orders/${id}/`, order);
    return response.data;
  },

  // Отменить заказ
  cancelOrder: async (id: number): Promise<Order> => {
    const response = await api.post(`/orders/${id}/cancel/`);
    return response.data;
  }
}; 