import { getCurrentUserId } from '../constants/user';
import { StickerPack, StickerSetResponse } from '../types/api';
import { normalizeImageUrl } from './api';

/**
 * Сервис для работы со стикерпаками через Sticker API.
 */
export class StickerService {
  private apiUrl = 'https://stickerserver.gymnasticstuff.uk';
  
  /**
   * Получает ID пользователя для работы со стикерпаками
   */
  getUserId(): string {
    return getCurrentUserId().toString();
  }

  /**
   * Получает список стикерпаков пользователя.
   * @param userId Telegram ID пользователя
   * @returns Массив объектов стикерпаков
   */
  async getUserStickerPacks(userId: string): Promise<StickerSetResponse[]> {
    try {
      const response = await fetch(`${this.apiUrl}/user_sticker_sets/${userId}`);
      if (!response.ok) {
        throw new Error(`Ошибка при получении стикерпаков: ${response.statusText}`);
      }
      return await response.json();
    } catch (error) {
      console.error('Ошибка при получении стикерпаков:', error);
      return [];
    }
  }

  /**
   * Получает информацию о стикерпаке.
   * @param packName Имя стикерпака
   * @returns Информация о стикерпаке
   */
  async getStickerPack(packName: string): Promise<StickerPack> {
    try {
      const response = await fetch(`${this.apiUrl}/stickers/packs/${packName}`);
      if (!response.ok) {
        throw new Error(`Ошибка при получении стикерпака: ${response.statusText}`);
      }
      const packData = await response.json();
      
      // Нормализуем URL для каждого стикера
      if (packData.stickers && Array.isArray(packData.stickers)) {
        packData.stickers = packData.stickers.map((sticker: { file_url: string; [key: string]: any }) => ({
          ...sticker,
          file_url: normalizeImageUrl(sticker.file_url)
        }));
      }
      
      return packData;
    } catch (error) {
      console.error('Ошибка при получении стикерпака:', error);
      throw error;
    }
  }

  /**
   * Создает новый стикерпак.
   * @param title Название стикерпака
   * @param userId Telegram ID пользователя
   * @param stickers Массив file_id стикеров
   * @param emojis Массив эмодзи для каждого стикера
   * @param name Опциональное имя стикерпака
   * @returns Результат создания стикерпака
   */
  async createStickerPack(
    title: string,
    userId: string,
    stickers: string[],
    emojis: string[],
    name?: string
  ): Promise<any> {
    try {
      // Создаем стикерпак с первым стикером
      const sticker_set_name = name || title.toLowerCase().replace(/\s+/g, '_');
      const firstSticker = stickers[0];
      const firstEmoji = emojis[0] || '😊';
      
      const createPackData = {
        user_id: parseInt(userId),
        sticker_set_name: sticker_set_name,
        title: title,
        file_id: firstSticker,
        emojis: firstEmoji,
        is_animated: false,
        is_video: false
      };
      
      // Логируем данные запроса
      console.log('Данные запроса на создание стикерпака:', JSON.stringify(createPackData));
      
      const response = await fetch(`${this.apiUrl}/create_sticker_set`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(createPackData)
      });
      
      if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Ошибка при создании стикерпака: ${errorText}`);
      }
      
      const createResult = await response.json();
      
      // Добавляем остальные стикеры, если они есть
      if (stickers.length > 1) {
        for (let i = 1; i < stickers.length; i++) {
          await this.addStickerToPack(
            sticker_set_name,
            userId,
            stickers[i],
            emojis[i] || '😊',
            title // Передаем title при добавлении стикеров
          );
        }
      }
      
      return createResult;
    } catch (error) {
      console.error('Ошибка при создании стикерпака:', error);
      throw error;
    }
  }
  
  /**
   * Создает запись о стикерпаке в базе данных.
   * @param userId Telegram ID пользователя
   * @param stickerSetName Полное имя стикерпака
   * @returns Результат создания записи
   * @deprecated Этот метод не используется в текущей версии
   */
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  private async createStickerPackDB(
    userId: string,
    stickerSetName: string
  ): Promise<StickerSetResponse> {
    try {
      const response = await fetch(`${this.apiUrl}/create_sticker_set_db`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          user_id: parseInt(userId),
          sticker_set_name: stickerSetName
        })
      });
      
      if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Ошибка при создании записи о стикерпаке: ${errorText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Ошибка при создании записи о стикерпаке:', error);
      throw error;
    }
  }

  /**
   * Добавляет стикер в существующий стикерпак.
   * @param packName Имя стикерпака
   * @param userId Telegram ID пользователя
   * @param fileId File ID стикера
   * @param emoji Эмодзи для стикера
   * @param title Опциональное название стикерпака (если не указано, будет получено из API)
   * @returns Результат добавления стикера
   */
  async addStickerToPack(
    packName: string,
    userId: string,
    fileId: string,
    emoji: string,
    title?: string // Добавляем опциональный параметр title
  ): Promise<any> {
    try {
      // Получаем информацию о стикерпаке, если title не передан
      let packTitle = title;
      if (!packTitle) {
        try {
          const packInfo = await this.getStickerPack(packName);
          packTitle = packInfo.title;
        } catch (error) {
          console.error('Ошибка при получении информации о стикерпаке:', error);
          packTitle = `Стикерпак ${packName}`; // Используем имя пака как заголовок, если не удалось получить информацию
        }
      }
      
      const data = {
        user_id: parseInt(userId),
        sticker_set_name: packName,
        title: packTitle, // Добавляем title в запрос
        file_id: fileId,
        emojis: emoji,
        is_animated: false,
        is_video: false
      };
      
      // Логируем данные запроса
      console.log('Данные запроса на добавление стикера:', JSON.stringify(data));
      
      const response = await fetch(`${this.apiUrl}/add_sticker_to_set`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(data)
      });
      
      if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Ошибка при добавлении стикера: ${errorText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Ошибка при добавлении стикера:', error);
      throw error;
    }
  }

  /**
   * Изменяет позицию стикера в стикерпаке.
   * @param fileId File ID стикера
   * @param position Новая позиция стикера
   * @returns Результат изменения позиции
   */
  async setStickerPosition(fileId: string, position: number): Promise<any> {
    try {
      const data = {
        sticker_file_id: fileId,
        position: position
      };
      
      const response = await fetch(`${this.apiUrl}/set_sticker_position_in_set`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(data)
      });
      
      if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Ошибка при изменении позиции стикера: ${errorText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Ошибка при изменении позиции стикера:', error);
      throw error;
    }
  }

  /**
   * Удаляет стикер из стикерпака по Telegram file_id.
   * @param fileId Telegram File ID стикера
   * @returns Результат удаления стикера
   */
  async deleteStickerByFileId(fileId: string): Promise<any> {
    try {
      const data = {
        file_id: fileId
      };
      
      const response = await fetch(`${this.apiUrl}/delete_sticker_from_set`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(data)
      });
      
      if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Ошибка при удалении стикера: ${errorText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Ошибка при удалении стикера:', error);
      throw error;
    }
  }
  
  /**
   * Удаляет стикер из стикерпака по ID.
   * @param stickerId ID стикера
   * @returns Результат удаления стикера
   * @deprecated Используйте deleteStickerByFileId вместо этого метода
   */
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  async deleteSticker(_stickerId: number): Promise<any> {
    console.warn('Метод deleteSticker устарел. Используйте deleteStickerByFileId вместо него.');
    throw new Error('Метод не поддерживается в новой версии API');
  }

  /**
   * Удаляет стикерпак.
   * @param packName Имя стикерпака
   * @returns Результат удаления стикерпака
   */
  async deleteStickerPack(packName: string): Promise<any> {
    try {
      const data = {
        sticker_set_name: packName
      };
      
      const response = await fetch(`${this.apiUrl}/delete_sticker_set`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(data)
      });
      
      if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Ошибка при удалении стикерпака: ${errorText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Ошибка при удалении стикерпака:', error);
      throw error;
    }
  }
}

// Экспортируем экземпляр сервиса для использования в компонентах
export const stickerService = new StickerService();
