export class ApiImportRepository {
    /**
     * Analyse le nom d'un fichier et trouve les mangas correspondants
     * @param {string} filename - Nom du fichier à analyser
     * @returns {Promise<Object>} - Résultat de l'analyse avec les correspondances
     */
    async analyzeFilename(filename) {
        try {
            console.log('Analyzing filename:', filename);
            const response = await fetch(`/api/manga-matches?filename=${encodeURIComponent(filename)}`);

            if (!response.ok) {
                const errorText = await response.text();
                console.error('Analyze filename failed:', response.status, errorText);
                throw new Error(`Failed to analyze filename: ${response.status}`);
            }

            const result = await response.json();
            console.log('Analyze result:', result);

            // Extract chapter and volume numbers from the first match if available
            const firstMatch = result.matches && result.matches.length > 0 ? result.matches[0] : null;
            const chapterNumber = firstMatch?.chapterNumber ?? null;
            const volumeNumber = firstMatch?.volumeNumber ?? null;

            return {
                matches: result.matches || [],
                chapterNumber,
                volumeNumber,
                possibleTitles: result.possibleTitles || []
            };
        } catch (error) {
            console.error('API Error:', error);
            throw error;
        }
    }

    /**
     * Récupère les détails d'un manga par son slug
     * @param {string} slug - Slug du manga
     * @returns {Promise<Object>} - Détails du manga avec chapitres et volumes
     */
    async getMangaDetails(slug) {
        try {
            console.log('Fetching manga details for:', slug);
            const response = await fetch(`/api/mangas/${slug}`);

            if (!response.ok) {
                const errorText = await response.text();
                console.error('Get manga details failed:', response.status, errorText);
                throw new Error(`Failed to get manga details: ${response.status}`);
            }

            const result = await response.json();
            return result;
        } catch (error) {
            console.error('API Error:', error);
            throw error;
        }
    }

    /**
     * Upload et import d'un fichier avec les informations du manga
     * @param {File} file - Fichier à uploader
     * @param {string} mangaId - ID du manga
     * @param {number|null} chapterNumber - Numéro du chapitre (optionnel)
     * @param {number|null} volumeNumber - Numéro du volume (optionnel)
     * @returns {Promise<Object>} - Résultat de l'import
     */
    async importFile(file, mangaId, chapterNumber = null, volumeNumber = null) {
        try {
            // Déterminer s'il s'agit d'un import de chapitre ou volume
            if (chapterNumber !== null && chapterNumber !== undefined) {
                return await this.importChapter(file, mangaId, chapterNumber);
            } else if (volumeNumber !== null && volumeNumber !== undefined) {
                return await this.importVolume(file, mangaId, volumeNumber);
            } else {
                throw new Error('Either chapterNumber or volumeNumber must be provided');
            }
        } catch (error) {
            console.error('API Error:', error);
            throw error;
        }
    }

    /**
     * Import d'un chapitre
     * @param {File} file - Fichier CBZ à uploader
     * @param {string} mangaId - ID du manga
     * @param {number} chapterNumber - Numéro du chapitre
     * @returns {Promise<Object>} - Résultat de l'import
     */
    async importChapter(file, mangaId, chapterNumber) {
        try {
            const formData = new FormData();
            formData.append('file', file);
            formData.append('mangaId', mangaId);
            formData.append('chapterNumber', chapterNumber.toString());

            console.log('Importing chapter:', chapterNumber, 'for manga:', mangaId);
            const response = await fetch('/api/chapters/import', {
                method: 'POST',
                body: formData
            });

            if (!response.ok) {
                const errorText = await response.text();
                console.error('Import failed:', response.status, errorText);

                // Parse the error response if it's JSON
                let errorMessage = `Failed to import chapter: ${response.status}`;
                try {
                    const errorJson = JSON.parse(errorText);
                    errorMessage = errorJson.error || errorJson.details || errorMessage;
                } catch (e) {
                    // Not JSON, use the status message
                }
                throw new Error(errorMessage);
            }

            const result = await response.json();
            console.log('Import result:', result);
            return result;
        } catch (error) {
            console.error('API Error:', error);
            throw error;
        }
    }

    /**
     * Import d'un volume (TODO: À implémenter)
     * @param {File} file - Fichier CBZ à uploader
     * @param {string} mangaId - ID du manga
     * @param {number} volumeNumber - Numéro du volume
     * @returns {Promise<Object>} - Résultat de l'import
     */
    async importVolume(file, mangaId, volumeNumber) {
        try {
            const formData = new FormData();
            formData.append('file', file);
            formData.append('mangaId', mangaId);
            formData.append('volumeNumber', volumeNumber.toString());

            console.log('Importing volume:', volumeNumber, 'for manga:', mangaId);
            const response = await fetch('/api/volumes/import', {
                method: 'POST',
                body: formData
            });

            if (!response.ok) {
                const errorText = await response.text();
                console.error('Import failed:', response.status, errorText);

                // Parse the error response if it's JSON
                let errorMessage = `Failed to import volume: ${response.status}`;
                try {
                    const errorJson = JSON.parse(errorText);
                    errorMessage = errorJson.error || errorJson.details || errorMessage;
                } catch (e) {
                    // Not JSON, use the status message
                }
                throw new Error(errorMessage);
            }

            const result = await response.json();
            console.log('Import result:', result);
            return result;
        } catch (error) {
            console.error('API Error:', error);
            throw error;
        }
    }

}
