import { API_CONFIG, DEFAULT_REQUEST_CONFIG } from '@/config/api';
import AuthService from './AuthService';

const API_BASE_URL = API_CONFIG.BASE_URL;

class NewsService {
    // ===== MarketItemController - Получение данных =====

    async getNewsItems(params = {}) {
        const { page = 0, size = 20, sort = 'publishedAt,desc', sourceName = null, startDate = null, endDate = null } = params;

        const queryParams = new URLSearchParams({
            page: page.toString(),
            size: size.toString(),
            sort
        });

        if (sourceName) {
            queryParams.append('sourceName', sourceName);
        }
        if (startDate) {
            queryParams.append('startDate', startDate);
        }
        if (endDate) {
            queryParams.append('endDate', endDate);
        }

        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.NEWS_ITEMS}?${queryParams}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при загрузке новостей');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при загрузке новостей:', error);
            throw error;
        }
    }

    async getNewsItemById(id) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.NEWS_ITEM_BY_ID}/${id}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при загрузке новости');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при загрузке новости:', error);
            throw error;
        }
    }

    async getNewsBySource(sourceName, params = {}) {
        const { page = 0, size = 20, sort = 'publishedAt,desc' } = params;

        const queryParams = new URLSearchParams({
            page: page.toString(),
            size: size.toString(),
            sort
        });

        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.NEWS_BY_SOURCE}/${encodeURIComponent(sourceName)}?${queryParams}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при загрузке новостей источника');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при загрузке новостей источника:', error);
            throw error;
        }
    }

    async getStats() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.STATS}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при загрузке статистики');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при загрузке статистики:', error);
            throw error;
        }
    }

    async getSources() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.SOURCES}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при загрузке списка источников');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при загрузке списка источников:', error);
            throw error;
        }
    }

    // ===== ParserAdminController - Управление парсерами =====

    async getParsers() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.PARSERS}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при получении списка парсеров');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при получении списка парсеров:', error);
            throw error;
        }
    }

    async getParsersInfo() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.PARSERS_INFO}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при получении информации о парсерах');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при получении информации о парсерах:', error);
            throw error;
        }
    }

    async checkParserExists(sourceName) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.PARSER_EXISTS}/${sourceName}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при проверке существования парсера');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при проверке существования парсера:', error);
            throw error;
        }
    }

    // ===== HealthCheckController - Мониторинг системы =====

    async getHealth() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.HEALTH}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при проверке состояния сервиса');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при проверке состояния сервиса:', error);
            throw error;
        }
    }

    async getMongoHealth() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MONGO_HEALTH}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при проверке состояния MongoDB');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при проверке состояния MongoDB:', error);
            throw error;
        }
    }

    async getSchedulerHealth() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.SCHEDULER_HEALTH}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при проверке состояния планировщика');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при проверке состояния планировщика:', error);
            throw error;
        }
    }

    async getSystemHealth() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.SYSTEM_HEALTH}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при получении информации о системе');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при получении информации о системе:', error);
            throw error;
        }
    }

    async getParsersHealth() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.PARSERS_HEALTH}`);
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при проверке состояния парсеров');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при проверке состояния парсеров:', error);
            throw error;
        }
    }

    // ===== Административные методы парсинга =====

    async parseAll() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.PARSE_ALL}`, {
                method: 'POST',
                ...DEFAULT_REQUEST_CONFIG
            });
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || 'Ошибка при запуске парсинга всех источников');
            }

            return data;
        } catch (error) {
            console.error('Ошибка при запуске парсинга всех источников:', error);
            throw error;
        }
    }

    async parseSource(source) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.PARSE_SOURCE}/${source}`, {
                method: 'POST',
                ...DEFAULT_REQUEST_CONFIG
            });
            const data = await response.json();

            if (!response.ok) {
                throw new Error(data.message || `Ошибка при запуске парсинга источника ${source}`);
            }

            return data;
        } catch (error) {
            console.error(`Ошибка при запуске парсинга источника ${source}:`, error);
            throw error;
        }
    }

    // ===== Вспомогательные методы =====

    // Методы для форматирования дат
    formatDate(dateString) {
        if (!dateString) return '';
        const date = new Date(dateString);
        return date.toLocaleDateString('ru-RU', {
            year: 'numeric',
            month: 'long',
            day: 'numeric',
            hour: '2-digit',
            minute: '2-digit'
        });
    }

    formatDateShort(dateString) {
        if (!dateString) return '';
        const date = new Date(dateString);
        return date.toLocaleDateString('ru-RU', {
            month: 'short',
            day: 'numeric',
            hour: '2-digit',
            minute: '2-digit'
        });
    }

    // Метод для получения списка источников из статистики (fallback)
    async getSourcesFromStats() {
        try {
            const stats = await this.getStats();
            return Object.keys(stats.data.sourceStatistics || {});
        } catch (error) {
            console.error('Ошибка при получении списка источников из статистики:', error);
            return [];
        }
    }
}

export default new NewsService();
