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

/**
 * AnalyticsService - Аналитика
 * Базовый путь: /api/smm/analytics
 */
class AnalyticsService {
    constructor() {
        this.baseUrl = API_CONFIG.SMM_BASE_URL;
        this.endpoints = {
            collectNow: API_CONFIG.ENDPOINTS.ANALYTICS_COLLECT
        };
    }

    /**
     * Запустить сбор аналитики
     * POST /api/smm/analytics/collect-now
     * @returns {Promise<AnalyticsResultDto>}
     */
    async collectAnalytics() {
        try {
            const response = await AuthService.authFetch(`${this.baseUrl}${this.endpoints.collectNow}`, {
                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 AnalyticsResultDto(data);
        } catch (error) {
            console.error('Error collecting analytics:', error);
            throw error;
        }
    }

    /**
     * Получить статистику кампаний
     * @returns {Promise<Object>} - Статистика кампаний
     */
    async getCampaignStats() {
        try {
            // Импортируем CampaignService для получения данных
            const { default: CampaignService } = await import('./CampaignService.js');
            const campaigns = await CampaignService.getAllCampaigns();

            const stats = {
                total: campaigns.length,
                byStatus: {},
                totalBudget: 0,
                activeCampaigns: 0,
                completedCampaigns: 0,
                plannedCampaigns: 0
            };

            campaigns.forEach((campaign) => {
                // Подсчет по статусам
                stats.byStatus[campaign.status] = (stats.byStatus[campaign.status] || 0) + 1;

                // Подсчет бюджета
                if (campaign.budget) {
                    stats.totalBudget += campaign.budget;
                }

                // Подсчет активных кампаний
                if (campaign.status === 'ACTIVE') {
                    stats.activeCampaigns++;
                } else if (campaign.status === 'COMPLETED') {
                    stats.completedCampaigns++;
                } else if (campaign.status === 'PLANNED') {
                    stats.plannedCampaigns++;
                }
            });

            return stats;
        } catch (error) {
            console.error('Error getting campaign stats:', error);
            throw error;
        }
    }

    /**
     * Получить статистику каналов
     * @returns {Promise<Object>} - Статистика каналов
     */
    async getChannelStats() {
        try {
            // Импортируем ChannelService для получения данных
            const { default: ChannelService } = await import('./ChannelService.js');
            const channels = await ChannelService.getAllChannels();

            const stats = {
                total: channels.length,
                byType: {},
                activeChannels: 0,
                inactiveChannels: 0
            };

            channels.forEach((channel) => {
                // Подсчет по типам
                stats.byType[channel.type] = (stats.byType[channel.type] || 0) + 1;

                // Подсчет активных/неактивных
                if (channel.isActive) {
                    stats.activeChannels++;
                } else {
                    stats.inactiveChannels++;
                }
            });

            return stats;
        } catch (error) {
            console.error('Error getting channel stats:', error);
            throw error;
        }
    }

    /**
     * Получить статистику контента
     * @returns {Promise<Object>} - Статистика контента
     */
    async getContentStats() {
        try {
            // Импортируем ContentService для получения данных
            const { default: ContentService } = await import('./ContentService.js');
            const content = await ContentService.getAllContent();

            const stats = {
                total: content.length,
                byStatus: {},
                byLocale: {},
                pendingApproval: 0,
                approved: 0,
                published: 0,
                failed: 0
            };

            content.forEach((item) => {
                // Подсчет по статусам
                stats.byStatus[item.status] = (stats.byStatus[item.status] || 0) + 1;

                // Подсчет по локалям
                stats.byLocale[item.locale] = (stats.byLocale[item.locale] || 0) + 1;

                // Подсчет специальных статусов
                if (item.status === 'PENDING_APPROVAL') {
                    stats.pendingApproval++;
                } else if (item.status === 'APPROVED') {
                    stats.approved++;
                } else if (item.status === 'PUBLISHED') {
                    stats.published++;
                } else if (item.status === 'FAILED') {
                    stats.failed++;
                }
            });

            return stats;
        } catch (error) {
            console.error('Error getting content stats:', error);
            throw error;
        }
    }

    /**
     * Получить общую статистику системы
     * @returns {Promise<Object>} - Общая статистика
     */
    async getSystemStats() {
        try {
            const [campaignStats, channelStats, contentStats] = await Promise.all([this.getCampaignStats(), this.getChannelStats(), this.getContentStats()]);

            return {
                campaigns: campaignStats,
                channels: channelStats,
                content: contentStats,
                timestamp: new Date().toISOString()
            };
        } catch (error) {
            console.error('Error getting system stats:', error);
            throw error;
        }
    }

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

            const publishedContent = content.filter((item) => item.status === 'PUBLISHED');
            const stats = {
                totalPublished: publishedContent.length,
                totalContent: content.length,
                publishingRate: content.length > 0 ? (publishedContent.length / content.length) * 100 : 0,
                byCampaign: {},
                byLocale: {}
            };

            // Группировка по кампаниям
            publishedContent.forEach((item) => {
                stats.byCampaign[item.campaignId] = (stats.byCampaign[item.campaignId] || 0) + 1;
                stats.byLocale[item.locale] = (stats.byLocale[item.locale] || 0) + 1;
            });

            return stats;
        } catch (error) {
            console.error('Error getting publishing stats:', error);
            throw error;
        }
    }
}

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