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

/**
 * ContentService - Управление контентом
 * Базовый путь: /api/smm/content
 */
class ContentService {
    constructor() {
        this.baseUrl = API_CONFIG.SMM_BASE_URL;
        this.endpoints = {
            content: API_CONFIG.ENDPOINTS.CONTENT,
            contentById: API_CONFIG.ENDPOINTS.CONTENT_BY_ID,
            contentApprove: API_CONFIG.ENDPOINTS.CONTENT_APPROVE,
            contentMessages: API_CONFIG.ENDPOINTS.CONTENT_MESSAGES
        };
    }

    /**
     * Получить весь контент
     * GET /api/smm/content
     * @returns {Promise<ContentQueueDto[]>}
     */
    async getAllContent() {
        try {
            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.content}`, {
                method: 'GET',
                headers: {
                    ...DEFAULT_REQUEST_CONFIG.headers
                }
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }

            const data = await response.json();
            return data.map((content) => new ContentQueueDto(content));
        } catch (error) {
            console.error('Error fetching content:', error);
            throw error;
        }
    }

    /**
     * Получить контент по ID
     * GET /api/smm/content/{id}
     * @param {string} id - UUID контента
     * @returns {Promise<ContentQueueDto>}
     */
    async getContentById(id) {
        try {
            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.contentById}/${id}`, {
                method: 'GET',
                headers: {
                    ...DEFAULT_REQUEST_CONFIG.headers
                }
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }

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

    /**
     * Создать контент
     * POST /api/smm/content
     * @param {Object} contentData - Данные контента
     * @param {string} contentData.campaignId - ID кампании
     * @param {string} contentData.locale - Локаль
     * @param {string} contentData.topic - Тема
     * @param {string} contentData.postDraft - Черновик поста
     * @param {string} contentData.assetsRefs - Ссылки на ресурсы
     * @param {string} contentData.scheduledAt - Время публикации (ISO 8601)
     * @param {number} contentData.priority - Приоритет
     * @returns {Promise<ContentQueueDto>}
     */
    async createContent(contentData) {
        try {
            // Валидация
            this.validateContentData(contentData);

            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.content}`, {
                method: 'POST',
                headers: {
                    ...DEFAULT_REQUEST_CONFIG.headers
                },
                body: JSON.stringify(contentData)
            });

            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 ContentQueueDto(data);
        } catch (error) {
            console.error('Error creating content:', error);
            throw error;
        }
    }

    /**
     * Обновить контент
     * PUT /api/smm/content/{id}
     * @param {string} id - UUID контента
     * @param {Object} contentData - Данные контента
     * @returns {Promise<ContentQueueDto>}
     */
    async updateContent(id, contentData) {
        try {
            // Валидация
            this.validateContentData(contentData);

            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.contentById}/${id}`, {
                method: 'PUT',
                headers: {
                    ...DEFAULT_REQUEST_CONFIG.headers
                },
                body: JSON.stringify(contentData)
            });

            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 ContentQueueDto(data);
        } catch (error) {
            console.error(`Error updating content ${id}:`, error);
            throw error;
        }
    }

    /**
     * Удалить контент
     * DELETE /api/smm/content/{id}
     * @param {string} id - UUID контента
     * @returns {Promise<void>}
     */
    async deleteContent(id) {
        try {
            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.contentById}/${id}`, {
                method: 'DELETE'
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
        } catch (error) {
            console.error(`Error deleting content ${id}:`, error);
            throw error;
        }
    }

    /**
     * Одобрить контент
     * POST /api/smm/content/{id}/approve
     * @param {string} id - UUID контента
     * @returns {Promise<ContentQueueDto>}
     */
    async approveContent(id) {
        try {
            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.contentApprove}/${id}/approve`, {
                method: 'POST'
            });

            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 ContentQueueDto(data);
        } catch (error) {
            console.error(`Error approving content ${id}:`, error);
            throw error;
        }
    }

    /**
     * Получить сообщения контента
     * GET /api/smm/content/{id}/messages
     * @param {string} id - UUID контента
     * @returns {Promise<MessageDto[]>}
     */
    async getContentMessages(id) {
        try {
            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.contentMessages}/${id}/messages`, {
                method: 'GET',
                headers: {
                    ...DEFAULT_REQUEST_CONFIG.headers
                }
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }

            const data = await response.json();
            return data.map((message) => new MessageDto(message));
        } catch (error) {
            console.error(`Error fetching content messages ${id}:`, error);
            throw error;
        }
    }

    /**
     * Получить контент по кампании
     * @param {string} campaignId - UUID кампании
     * @returns {Promise<ContentQueueDto[]>}
     */
    async getContentByCampaign(campaignId) {
        try {
            const allContent = await this.getAllContent();
            return allContent.filter((content) => content.campaignId === campaignId);
        } catch (error) {
            console.error(`Error fetching content by campaign ${campaignId}:`, error);
            throw error;
        }
    }

    /**
     * Получить контент по статусу
     * @param {string} status - Статус контента
     * @returns {Promise<ContentQueueDto[]>}
     */
    async getContentByStatus(status) {
        try {
            const allContent = await this.getAllContent();
            return allContent.filter((content) => content.status === status);
        } catch (error) {
            console.error(`Error fetching content by status ${status}:`, error);
            throw error;
        }
    }

    /**
     * Получить контент, ожидающий одобрения
     * @returns {Promise<ContentQueueDto[]>}
     */
    async getPendingApprovalContent() {
        return this.getContentByStatus(ContentStatus.PENDING_APPROVAL);
    }

    /**
     * Получить одобренный контент
     * @returns {Promise<ContentQueueDto[]>}
     */
    async getApprovedContent() {
        return this.getContentByStatus(ContentStatus.APPROVED);
    }

    /**
     * Получить опубликованный контент
     * @returns {Promise<ContentQueueDto[]>}
     */
    async getPublishedContent() {
        return this.getContentByStatus(ContentStatus.PUBLISHED);
    }

    /**
     * Валидация данных контента
     * @param {Object} contentData - Данные контента
     * @throws {Error} Если валидация не прошла
     */
    validateContentData(contentData) {
        if (!contentData.campaignId || contentData.campaignId.trim() === '') {
            throw new Error('ID кампании обязателен');
        }

        if (!contentData.locale || contentData.locale.trim() === '') {
            throw new Error('Локаль обязательна');
        }

        if (!contentData.topic || contentData.topic.trim() === '') {
            throw new Error('Тема обязательна');
        }

        if (contentData.scheduledAt) {
            const scheduledDate = new Date(contentData.scheduledAt);
            if (isNaN(scheduledDate.getTime())) {
                throw new Error('Неверный формат времени публикации');
            }
        }

        if (contentData.priority !== undefined && (contentData.priority < 1 || contentData.priority > 10)) {
            throw new Error('Приоритет должен быть от 1 до 10');
        }
    }
}

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