import { defineStore } from 'pinia';
import { ApiMangaRepository } from '../../infrastructure/api/apiMangaRepository';

const mangaRepository = new ApiMangaRepository();

// Helper pour comparer la collection (peut être supprimé si non utilisé ailleurs)
const deepCompare = (obj1, obj2) => {
    try {
        if (obj1 == null && obj2 == null) return true;
        if (obj1 == null || obj2 == null) return false;
        return JSON.stringify(obj1) === JSON.stringify(obj2);
    } catch (e) {
        console.error("Erreur lors de la comparaison d'objets:", e);
        return false;
    }
};

export const useMangaStore = defineStore('manga', {
    state: () => ({
        // --- Collection State ---
        collection: null,
        loadingCollection: false,
        errorCollection: null,
        isBackgroundLoadingCollection: false,

        // --- Selected Manga State ---
        // Gardé pour savoir quel manga est sélectionné dans l'UI,
        // mais les données détaillées ne sont plus stockées ici.
        currentMangaId: null,

        // --- Manga Chapters State ---
        mangaChapters: {},
        loadingChapters: false,
        chaptersError: null,

        // --- Search State ---
        searchResults: [],
        loadingSearch: false,
        searchError: null,

        // --- Add Manga State ---
        addingManga: false,
        addMangaError: null,

        // --- Discover State ---
        discoverResults: [],
        loadingDiscover: false,
        discoverError: null
    }),

    getters: {
        // Plus de getters spécifiques aux détails/chapitres ici
    },

    actions: {
        // --- Collection Actions ---
        async loadCollection() {
            if (this.loadingCollection) return;
            this.loadingCollection = true;
            this.errorCollection = null;
            try {
                const newCollection = await mangaRepository.getCollection();
                // On garde la comparaison pour éviter màj inutile de la collection
                if (!deepCompare(this.collection, newCollection)) {
                    this.collection = newCollection;
                }
            } catch (err) {
                this.errorCollection = err.message;
            } finally {
                this.loadingCollection = false;
            }
        },

        async refreshCollectionInBackground() {
            if (this.isBackgroundLoadingCollection) return;
            this.isBackgroundLoadingCollection = true;
            try {
                const newCollection = await mangaRepository.getCollection();
                if (!deepCompare(this.collection, newCollection)) {
                    this.collection = newCollection;
                }
            } catch (err) {
                console.error('Failed to refresh collection:', err);
            } finally {
                this.isBackgroundLoadingCollection = false;
            }
        },

        // --- Selected Manga Actions ---
        setCurrentMangaId(mangaId) {
            // Met simplement à jour l'ID sélectionné
            this.currentMangaId = mangaId;
        },

        clearCurrentMangaFocus() {
            this.currentMangaId = null;
        },

        // --- Chapters Actions ---
        async loadChapters(mangaId) {
            if (this.loadingChapters) return;
            this.loadingChapters = true;
            this.chaptersError = null;

            try {
                const chaptersData = await mangaRepository.getChapters(mangaId);
                this.mangaChapters[mangaId] = chaptersData;
            } catch (err) {
                this.chaptersError = err.message;
            } finally {
                this.loadingChapters = false;
            }
        },

        updateChapterAvailability(chapterId, isAvailable = true) {
            console.log(`Mise à jour du chapitre ${chapterId}, disponible: ${isAvailable}`);

            // Pour chaque manga dans notre store
            Object.keys(this.mangaChapters).forEach(mangaId => {
                const chaptersObj = this.mangaChapters[mangaId];
                if (!chaptersObj || !chaptersObj.items) return;

                const chapters = chaptersObj.items;

                // Chercher le chapitre correspondant
                const chapterIndex = chapters.findIndex(chapter => chapter.id === chapterId);

                // Si on trouve le chapitre, mettre à jour son état
                if (chapterIndex !== -1) {
                    console.log(`Chapitre trouvé dans le manga ${mangaId}, index: ${chapterIndex}`);

                    // Important: créer une nouvelle référence pour que Vue détecte le changement
                    const updatedChapter = {
                        ...chapters[chapterIndex],
                        isAvailable: isAvailable
                    };

                    // Créer un nouveau tableau pour garantir la réactivité
                    const updatedChapters = [...chapters];
                    updatedChapters[chapterIndex] = updatedChapter;

                    // Mise à jour reactive du store
                    this.mangaChapters[mangaId] = {
                        ...chaptersObj,
                        items: updatedChapters
                    };

                    console.log('Chapitre mis à jour avec succès');
                }
            });
        },

        // --- Search Actions ---
        async searchMangaDex(query) {
            if (this.loadingSearch) return;

            this.loadingSearch = true;
            this.searchError = null;
            this.searchResults = [];

            try {
                const data = await mangaRepository.searchMangaDex(query);
                this.searchResults = data.items || [];
            } catch (error) {
                this.searchError = error.message;
                throw error;
            } finally {
                this.loadingSearch = false;
            }
        },

        clearSearchResults() {
            this.searchResults = [];
            this.searchError = null;
            this.loadingSearch = false;
        },

        // --- Discover Actions ---
        async loadDiscoverRecommendations() {
            if (this.loadingDiscover) return;

            this.loadingDiscover = true;
            this.discoverError = null;
            this.discoverResults = [];

            try {
                const data = await mangaRepository.discoverManga();
                this.discoverResults = data.items || [];
            } catch (error) {
                this.discoverError = error.message;
                throw error;
            } finally {
                this.loadingDiscover = false;
            }
        },

        // --- Add Manga Actions ---
        async createFromMangaDex(externalId) {
            if (this.addingManga) return;

            this.addingManga = true;
            this.addMangaError = null;

            try {
                await mangaRepository.createFromMangaDex(externalId);
                // Rafraîchir la collection après l'ajout
                await this.loadCollection();
            } catch (error) {
                this.addMangaError = error.message;
                throw error;
            } finally {
                this.addingManga = false;
            }
        },

        async fetchMangaChapters(mangaId) {
            if (this.loadingChapters) return;
            this.loadingChapters = true;
            this.chaptersError = null;

            try {
                // Déclenche la récupération initiale des chapitres depuis la source externe
                await mangaRepository.fetchMangaChapters(mangaId);
                console.log('Récupération initiale des chapitres déclenchée avec succès');

                // Note: Les nouveaux chapitres seront disponibles après traitement asynchrone
                // Le MercureListener se chargera de mettre à jour l'interface
            } catch (err) {
                this.chaptersError = err.message;
                console.error('Erreur lors de la récupération des chapitres:', err);
                throw err;
            } finally {
                this.loadingChapters = false;
            }
        },

        async refreshMangaChapters(mangaId) {
            if (this.loadingChapters) return;
            this.loadingChapters = true;
            this.chaptersError = null;

            try {
                // Déclenche la synchronisation incrémentale avec scraping automatique
                await mangaRepository.refreshMangaChapters(mangaId);
                console.log('Synchronisation incrémentale déclenchée avec succès');

                // Note: Les chapitres mis à jour seront disponibles après traitement asynchrone
                // Le MercureListener se chargera de mettre à jour l'interface
            } catch (err) {
                this.chaptersError = err.message;
                console.error('Erreur lors de la synchronisation des chapitres:', err);
                throw err;
            } finally {
                this.loadingChapters = false;
            }
        },

        // --- Scrape Chapter Action ---
        async searchChapter(chapterId) {
            try {
                await mangaRepository.searchChapter(chapterId);
            } catch (error) {
                console.error('Erreur lors de la recherche du chapitre:', error);
                throw error;
            }
        },

        // --- Delete Chapter Action ---
        async deleteChapter(chapterId) {
            try {
                await mangaRepository.deleteChapter(chapterId);
                // Mettre à jour l'état du chapitre pour refléter qu'il n'est plus disponible
                this.updateChapterAvailability(chapterId, false);
            } catch (error) {
                console.error('Erreur lors de la suppression du chapitre:', error);
                throw error;
            }
        },

        // --- Download Chapter Action ---
        async downloadChapter(chapterId) {
            try {
                await mangaRepository.downloadChapter(chapterId);
            } catch (error) {
                console.error('Erreur lors du téléchargement du chapitre:', error);
                throw error;
            }
        },

                // --- Hide Chapter Action ---
        async hideChapter(chapterId, mangaId) {
            try {
                await mangaRepository.hideChapter(chapterId);
                // Recharger la liste des chapitres depuis l'API
                await this.loadChapters(mangaId);
            } catch (error) {
                console.error('Erreur lors du masquage du chapitre:', error);
                throw error;
            }
        },

        // --- Download Volume Action ---
        async downloadVolume(mangaId, volumeNumber) {
            try {
                await mangaRepository.downloadVolume(mangaId, volumeNumber);
            } catch (error) {
                console.error('Erreur lors du téléchargement du volume:', error);
                throw error;
            }
        }
    }
});
