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

const API_BASE_URL = API_CONFIG.BASE_URL;

class MarketingService {
    /**
     * Запуск маркетингового анализа
     * POST /api/marketing/analysis/start
     * @param {Object} data - Данные для анализа
     * @param {string} data.businessNiche - Ниша бизнеса
     * @param {string} data.product - Название продукта или услуги
     * @param {Object} data.targetAudience - Целевая аудитория (объект с полями genders, ageRanges, types)
     * @param {string[]} data.targetAudience.genders - Массив гендеров ('Женщины', 'Мужчины')
     * @param {string[]} data.targetAudience.ageRanges - Массив возрастных диапазонов ('20-40', '25-45', '18-25', '40-60', '60+')
     * @param {string[]} data.targetAudience.types - Массив типов ('Семьи', 'Молодёжь', 'Все подряд')
     * @param {string[]} data.region - Массив регионов (города Казахстана)
     * @param {string} data.goal - Цель на 6-12 месяцев
     * @param {string} data.detailLevel - Уровень детализации анализа (КРАТКО, СТАНДАРТНО, ПОДРОБНО)
     * @param {string[]} data.analysisType - Массив типов анализа (РЫНОК, КОНКУРЕНТЫ, ЦА, КАНАЛЫ, SWOT)
     * @param {string} [data.strongSide] - Сильная сторона бизнеса (опционально)
     * @param {string} [data.weakSide] - Слабая сторона бизнеса (опционально)
     * @returns {Promise<Object|Array>} Объект с analysisId и статусом (или массив объектов при множественном выборе типов анализа)
     */
    async startAnalysis(data) {
        try {
            const requestBody = {
                businessNiche: data.businessNiche,
                product: data.product,
                targetAudience: data.targetAudience,
                region: data.region,
                goal: data.goal,
                detailLevel: data.detailLevel,
                analysisType: data.analysisType
            };

            // Добавляем опциональные поля только если они указаны
            if (data.strongSide) {
                requestBody.strongSide = data.strongSide;
            }
            if (data.weakSide) {
                requestBody.weakSide = data.weakSide;
            }

            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_ANALYSIS_START}`, {
                method: 'POST',
                ...DEFAULT_REQUEST_CONFIG,
                body: JSON.stringify(requestBody)
            });

            const result = await response.json().catch(() => null);

            if (!response.ok) {
                throw new Error(result?.message || result?.error?.message || 'Ошибка при запуске анализа');
            }

            if (!result || !result.success) {
                throw new Error(result?.message || 'Ошибка при запуске анализа');
            }

            // Возвращаем data, который может быть объектом или массивом
            return result.data || null;
        } catch (error) {
            console.error('Ошибка при запуске маркетингового анализа:', error);
            throw error;
        }
    }

    /**
     * Получение результата анализа
     * GET /api/marketing/analysis/{analysisId}
     * @param {string} analysisId - Идентификатор анализа
     * @returns {Promise<Object>} Объект с статусом и результатами анализа
     */
    async getAnalysisResult(analysisId) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}/api/marketing/analysis/${analysisId}`);

            const result = await response.json().catch(() => null);

            if (!response.ok) {
                throw new Error(result?.message || result?.error?.message || 'Ошибка при получении результата анализа');
            }

            if (!result || !result.success) {
                throw new Error(result?.message || 'Ошибка при получении результата анализа');
            }

            return result.data || null;
        } catch (error) {
            console.error('Ошибка при получении результата анализа:', error);
            throw error;
        }
    }

    /**
     * Получение списка всех анализов текущего пользователя
     * GET /api/marketing/analysis/my
     * @returns {Promise<Array>} Массив анализов. Поля могут различаться в зависимости от версии API:
     * Старые анализы: analysisId, product, location, clientType, differentiator, status, userId, createdAt, completedAt, statusHistory
     * Новые анализы: analysisId, product, businessNiche, targetAudience, region, goal, detailLevel, strongSide, weakSide, status, userId, createdAt, completedAt, statusHistory
     */
    async getMyAnalyses() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_ANALYSIS_MY}`);

            const result = await response.json().catch(() => null);

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

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

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

    /**
     * Получение детальной истории анализа
     * GET /api/marketing/analysis/{analysisId}/history
     * @param {string} analysisId - Идентификатор анализа
     * @returns {Promise<Object>} Объект анализа с полной историей статусов
     */
    async getAnalysisHistory(analysisId) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_ANALYSIS_HISTORY}/${analysisId}/history`);

            const result = await response.json();

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

            if (!result.success) {
                throw new Error(result.message || 'Ошибка при получении истории анализа');
            }

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

    /**
     * Скачивание PDF отчета
     * GET /api/marketing/analysis/{analysisId}/download
     * @param {string} analysisId - Идентификатор анализа
     * @returns {Promise<Blob>} Blob с PDF файлом
     */
    async downloadPdf(analysisId) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_ANALYSIS_DOWNLOAD}/${analysisId}/download`);

            if (!response.ok) {
                const errorData = await response.json().catch(() => ({}));
                throw new Error(errorData.message || errorData.error?.message || 'Ошибка при скачивании PDF');
            }

            return await response.blob();
        } catch (error) {
            console.error('Ошибка при скачивании PDF:', error);
            throw error;
        }
    }

    /**
     * Вспомогательный метод для скачивания PDF в браузере
     * @param {string} analysisId - Идентификатор анализа
     */
    async downloadPdfFile(analysisId) {
        try {
            const blob = await this.downloadPdf(analysisId);
            const url = window.URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = `marketing_analysis_${analysisId}.pdf`;
            document.body.appendChild(a);
            a.click();
            window.URL.revokeObjectURL(url);
            document.body.removeChild(a);
        } catch (error) {
            console.error('Ошибка при скачивании PDF файла:', error);
            throw error;
        }
    }

    /**
     * Запуск генерации стратегии продвижения
     * POST /api/marketing/strategy/generate?analysisId={analysisId}
     * @param {string} analysisId - ID завершенного маркетингового анализа
     * @param {Object} options - Опции генерации стратегии
     * @param {number} options.durationWeeks - Длительность стратегии в неделях (1-12)
     * @param {string[]} options.priorityPlatforms - Приоритетные платформы для продвижения
     * @returns {Promise<Object>} Объект с strategyId и статусом
     */
    async generateStrategy(analysisId, options = {}) {
        try {
            const params = new URLSearchParams();
            params.append('analysisId', analysisId);

            const body = {};
            if (options.durationWeeks) {
                body.durationWeeks = options.durationWeeks;
            }
            if (options.priorityPlatforms && options.priorityPlatforms.length > 0) {
                body.priorityPlatforms = options.priorityPlatforms;
            }

            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_STRATEGY_GENERATE}?${params}`, {
                method: 'POST',
                ...DEFAULT_REQUEST_CONFIG,
                body: Object.keys(body).length > 0 ? JSON.stringify(body) : undefined
            });

            const result = await response.json();

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

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

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

    /**
     * Получение стратегии по ID
     * GET /api/marketing/strategy/{strategyId}
     * @param {string} strategyId - Идентификатор стратегии
     * @returns {Promise<Object>} Объект с статусом и результатами стратегии
     */
    async getStrategy(strategyId) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_STRATEGY_GET}/${strategyId}`);

            const result = await response.json();

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

            if (!result.success) {
                throw new Error(result.message || 'Ошибка при получении стратегии');
            }

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

    /**
     * Получение стратегии по ID анализа
     * GET /api/marketing/analysis/{analysisId}/strategy
     * @param {string} analysisId - Идентификатор анализа
     * @returns {Promise<Object>} Объект с статусом и результатами стратегии
     */
    async getStrategyByAnalysis(analysisId) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_STRATEGY_BY_ANALYSIS}/${analysisId}/strategy`);

            const result = await response.json();

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

            if (!result.success) {
                throw new Error(result.message || 'Ошибка при получении стратегии');
            }

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

    /**
     * Получение списка всех стратегий текущего пользователя
     * GET /api/marketing/analysis/strategy/my
     * @returns {Promise<Array>} Массив стратегий с полями strategyId, analysisId, status, userId, durationWeeks, priorityPlatforms, createdAt, completedAt, statusHistory
     */
    async getMyStrategies() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_STRATEGY_MY}`);

            const result = await response.json();

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

            if (!result.success) {
                throw new Error(result.message || 'Ошибка при получении списка стратегий');
            }

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

    /**
     * Получение детальной истории стратегии
     * GET /api/marketing/analysis/strategy/{strategyId}/history
     * @param {string} strategyId - Идентификатор стратегии
     * @returns {Promise<Object>} Объект стратегии с полной историей статусов
     */
    async getStrategyHistory(strategyId) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_STRATEGY_HISTORY}/${strategyId}/history`);

            const result = await response.json();

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

            if (!result.success) {
                throw new Error(result.message || 'Ошибка при получении истории стратегии');
            }

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

    /**
     * Запуск стратегии продвижения
     * POST /api/marketing/analysis/strategy/{strategyId}/start
     * @param {string} strategyId - Идентификатор стратегии для запуска
     * @returns {Promise<Object>} Объект с информацией о запуске (tasksCreated, platforms)
     */
    async startStrategy(strategyId) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_STRATEGY_START}/${strategyId}/start`, {
                method: 'POST',
                ...DEFAULT_REQUEST_CONFIG,
                body: JSON.stringify({})
            });

            const result = await response.json();

            if (!response.ok) {
                const error = {
                    message: result.data?.message || result.message || result.error?.message || 'Ошибка при запуске стратегии',
                    code: result.data?.code || result.error?.code,
                    details: result.data?.details || result.error?.details
                };
                throw error;
            }

            if (!result.success) {
                const error = {
                    message: result.data?.message || result.message || 'Ошибка при запуске стратегии',
                    code: result.data?.code || result.error?.code,
                    details: result.data?.details || result.error?.details
                };
                throw error;
            }

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

    /**
     * Сохранение/обновление credentials для социальной сети
     * POST /api/social-media/credentials
     * @param {string} platform - Название платформы (facebook, instagram, telegram, etc.)
     * @param {string|Object} credentials - Access token (строка) для простых платформ или объект для сложных (например, {botToken, chatId} для Telegram)
     * @returns {Promise<Object>} Объект с информацией о сохраненных credentials
     */
    async saveCredentials(platform, credentials) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.SOCIAL_MEDIA_CREDENTIALS}`, {
                method: 'POST',
                ...DEFAULT_REQUEST_CONFIG,
                body: JSON.stringify({
                    platform: platform,
                    credentials: credentials // Может быть строкой или объектом
                })
            });

            const result = await response.json();

            if (!response.ok) {
                const error = {
                    message: result.message || result.error?.message || 'Ошибка при сохранении credentials',
                    code: result.error?.code,
                    details: result.error?.details
                };
                throw error;
            }

            if (!result.success) {
                const error = {
                    message: result.message || 'Ошибка при сохранении credentials',
                    code: result.error?.code,
                    details: result.error?.details
                };
                throw error;
            }

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

    /**
     * Получение информации о credentials для платформы
     * GET /api/social-media/credentials/{platform}
     * @param {string} platform - Название платформы
     * @returns {Promise<Object>} Объект с информацией о наличии credentials
     */
    async getCredentials(platform) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.SOCIAL_MEDIA_CREDENTIALS_BY_PLATFORM}/${platform}`);

            const result = await response.json();

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

            if (!result.success) {
                throw new Error(result.message || 'Ошибка при получении credentials');
            }

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

    /**
     * Получение списка всех credentials
     * GET /api/social-media/credentials
     * @returns {Promise<Array>} Массив объектов с информацией о credentials для каждой платформы
     */
    async getAllCredentials() {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.SOCIAL_MEDIA_CREDENTIALS}`);

            const result = await response.json();

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

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

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

    /**
     * Получение URL изображения поста
     * GET /api/marketing/analysis/images/{imageFilename}
     * @param {string} imageFilename - Имя файла изображения
     * @returns {string} URL изображения через бэкенд API
     */
    getImageUrl(imageFilename) {
        if (!imageFilename) return null;
        return `${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_IMAGE_GET}/${imageFilename}`;
    }

    /**
     * Загрузка изображения поста с авторизацией
     * GET /api/marketing/analysis/images/{imageFilename}
     * @param {string} imageFilename - Имя файла изображения
     * @returns {Promise<string>} Promise с blob URL изображения
     */
    async loadImageAsBlobUrl(imageFilename) {
        if (!imageFilename) return null;
        try {
            const imageUrl = this.getImageUrl(imageFilename);
            const response = await AuthService.authFetch(imageUrl, {
                method: 'GET'
            });

            if (!response.ok) {
                throw new Error('Failed to load image');
            }

            const blob = await response.blob();
            return URL.createObjectURL(blob);
        } catch (error) {
            console.error('Ошибка при загрузке изображения:', error);
            return null;
        }
    }

    /**
     * Удаление credentials для платформы
     * DELETE /api/social-media/credentials/{platform}
     * @param {string} platform - Название платформы
     * @returns {Promise<void>}
     */
    async deleteCredentials(platform) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.SOCIAL_MEDIA_CREDENTIALS_BY_PLATFORM}/${platform}`, {
                method: 'DELETE'
            });

            const result = await response.json();

            if (!response.ok) {
                const error = {
                    message: result.message || result.error?.message || 'Ошибка при удалении credentials',
                    code: result.error?.code,
                    details: result.error?.details
                };
                throw error;
            }

            if (!result.success) {
                const error = {
                    message: result.message || 'Ошибка при удалении credentials',
                    code: result.error?.code,
                    details: result.error?.details
                };
                throw error;
            }

            return result.data;
        } catch (error) {
            console.error('Ошибка при удалении credentials:', error);
            throw error;
        }
    }

    /**
     * Ручной запуск задачи публикации
     * POST /api/marketing/analysis/tasks/{taskId}/execute
     * @param {string} taskId - ID задачи публикации
     * @returns {Promise<Object>} Объект с информацией о запуске задачи (taskId, status, platform, publishDate)
     */
    async executeTask(taskId) {
        try {
            const response = await AuthService.authFetch(`${API_BASE_URL}${API_CONFIG.ENDPOINTS.MARKETING_TASK_EXECUTE}/${taskId}/execute`, {
                method: 'POST',
                ...DEFAULT_REQUEST_CONFIG,
                body: JSON.stringify({})
            });

            const result = await response.json();

            if (!response.ok) {
                const error = {
                    message: result.message || result.error?.message || 'Ошибка при запуске задачи',
                    code: result.error?.code,
                    details: result.error?.details
                };
                throw error;
            }

            if (!result.success) {
                const error = {
                    message: result.message || 'Ошибка при запуске задачи',
                    code: result.error?.code,
                    details: result.error?.details
                };
                throw error;
            }

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

export default new MarketingService();
