import { API_CONFIG, DEFAULT_REQUEST_CONFIG } from '@/config/api.js';
import AuthService from '@/service/AuthService.js';
import { PublishingResultDto } from '@/types/smm.js';

/**
 * PublishingService - Публикация контента
 * Базовый путь: /api/smm/publishing
 */
class PublishingService {
    constructor() {
        this.baseUrl = API_CONFIG.SMM_BASE_URL;
        this.endpoints = {
            publishPost: API_CONFIG.ENDPOINTS.PUBLISHING_POST
        };
    }

    /**
     * Опубликовать контент
     * POST /api/smm/publishing/post/{contentId}
     * @param {string} contentId - UUID контента для публикации
     * @returns {Promise<PublishingResultDto>}
     */
    async publishContent(contentId) {
        try {
            if (!contentId || contentId.trim() === '') {
                throw new Error('ID контента обязателен');
            }

            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.publishPost}/${contentId}`, {
                method: 'POST',
                headers: {
                    ...DEFAULT_REQUEST_CONFIG.headers
                }
            });

            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(`HTTP error! status: ${response.status}, message: ${errorData.message || 'Unknown error'}`);
            }

            const data = await response.json();
            return new PublishingResultDto(data);
        } catch (error) {
            console.error(`Error publishing content ${contentId}:`, error);
            throw error;
        }
    }

    /**
     * Проверить статус публикации контента
     * @param {string} contentId - UUID контента
     * @returns {Promise<boolean>} - true если контент опубликован
     */
    async isContentPublished(contentId) {
        try {
            // Импортируем ContentService для проверки статуса
            const { default: ContentService } = await import('./ContentService.js');
            const content = await ContentService.getContentById(contentId);
            return content.status === 'PUBLISHED';
        } catch (error) {
            console.error(`Error checking publication status for content ${contentId}:`, error);
            return false;
        }
    }

    /**
     * Получить URL опубликованного контента
     * @param {string} contentId - UUID контента
     * @returns {Promise<string|null>} - URL публикации или null
     */
    async getPublishedContentUrl(contentId) {
        try {
            // Импортируем ContentService для получения сообщений
            const { default: ContentService } = await import('./ContentService.js');
            const messages = await ContentService.getContentMessages(contentId);

            if (messages && messages.length > 0) {
                // Возвращаем URL первого сообщения
                return messages[0].url;
            }

            return null;
        } catch (error) {
            console.error(`Error getting published content URL for ${contentId}:`, error);
            return null;
        }
    }

    /**
     * Получить статистику публикаций
     * @param {string} contentId - UUID контента
     * @returns {Promise<Object>} - Статистика публикаций
     */
    async getPublishingStats(contentId) {
        try {
            // Импортируем ContentService для получения сообщений
            const { default: ContentService } = await import('./ContentService.js');
            const messages = await ContentService.getContentMessages(contentId);

            return {
                totalMessages: messages.length,
                publishedChannels: messages.map((msg) => msg.channelId),
                urls: messages.map((msg) => msg.url),
                lastPublished: messages.length > 0 ? new Date(Math.max(...messages.map((msg) => new Date(msg.postedAt).getTime()))) : null
            };
        } catch (error) {
            console.error(`Error getting publishing stats for content ${contentId}:`, error);
            return {
                totalMessages: 0,
                publishedChannels: [],
                urls: [],
                lastPublished: null
            };
        }
    }

    /**
     * Массовая публикация контента
     * @param {string[]} contentIds - Массив UUID контента
     * @returns {Promise<PublishingResultDto[]>} - Результаты публикации
     */
    async publishMultipleContent(contentIds) {
        try {
            if (!Array.isArray(contentIds) || contentIds.length === 0) {
                throw new Error('Массив ID контента не может быть пустым');
            }

            const results = [];

            for (const contentId of contentIds) {
                try {
                    const result = await this.publishContent(contentId);
                    results.push(result);
                } catch (error) {
                    console.error(`Error publishing content ${contentId}:`, error);
                    results.push({
                        success: false,
                        message: `Ошибка публикации контента ${contentId}: ${error.message}`,
                        data: null
                    });
                }
            }

            return results;
        } catch (error) {
            console.error('Error in mass publishing:', error);
            throw error;
        }
    }
}

// Экспорт singleton instance
export default new PublishingService();
