import { defineStore } from 'pinia';
import { Chapter } from '../../domain/entities/Chapter';
import { ApiChapterRepository } from '../../infrastructure/repository/ApiChapterRepository';

export const useReaderStore = defineStore('reader', {
    state: () => ({
        currentChapter: null,
        currentPage: 0,
        readingMode: 'single', // 'single' ou 'infinite'
        readingDirection: 'ltr', // 'ltr' ou 'rtl'
        zoom: 1,
        isLoading: false,
        error: null,
        pages: [],
        totalPages: 0,
        loadedPages: new Set(), // Garder une trace des pages déjà chargées

        // Paramètres pour les doubles pages
        doublePageSettings: {
            autoDetect: true,
            mobileMode: 'rotate', // 'rotate', 'scroll', 'normal'
            detectionThreshold: 1.2 // Ratio largeur/hauteur pour détecter une double page
        }
    }),

    getters: {
        isFirstPage: state => state.currentPage === 0,
        isLastPage: state => state.currentPage === state.totalPages - 1,
        currentPageData: state => state.pages[state.currentPage],
        hasPreviousChapter: state => Boolean(state.currentChapter?.navigation?.previousChapter),
        hasNextChapter: state => Boolean(state.currentChapter?.navigation?.nextChapter),

        // Getters pour les doubles pages
        effectiveDoublePageMode: (state) => {
            // Si la détection automatique est désactivée, retourner 'normal'
            if (!state.doublePageSettings.autoDetect) {
                return 'normal';
            }
            return state.doublePageSettings.mobileMode;
        },

        // Préférences sauvegardées dans localStorage
        savedPreferences: (state) => ({
            readingMode: state.readingMode,
            readingDirection: state.readingDirection,
            zoom: state.zoom,
            doublePageSettings: state.doublePageSettings
        })
    },

    actions: {
        async loadChapter(chapterId) {
            this.isLoading = true;
            this.error = null;
            try {
                const repository = new ApiChapterRepository();

                // Charger les informations du chapitre
                const chapterData = await repository.getChapter(chapterId);
                this.currentChapter = Chapter.create(chapterData);

                // Charger la liste des pages
                const pagesData = await repository.getChapterPages(chapterId);

                // Initialiser le tableau avec des placeholders
                this.pages = new Array(pagesData.totalItems).fill(null);
                this.totalPages = pagesData.totalItems;
                this.loadedPages.clear();

                // Charger la première page
                if (this.totalPages > 0) {
                    this.currentPage = 0;
                    await this.loadPageData(0);

                    // En mode infini, précharger les premières pages
                    if (this.readingMode === 'infinite') {
                        await this.preloadNextPages(0);
                    }
                }
            } catch (error) {
                this.error = error.message;
            } finally {
                this.isLoading = false;
            }
        },

        async loadPageData(pageIndex) {
            if (!this.currentChapter || pageIndex < 0 || pageIndex >= this.totalPages) {
                return;
            }

            // Si la page est déjà chargée, ne rien faire
            if (this.loadedPages.has(pageIndex)) {
                return;
            }

            const pageNumber = pageIndex + 1; // Convertir en 1-based pour l'API

            // Marquer la page comme en cours de chargement
            const newPages = [...this.pages];
            newPages[pageIndex] = { loading: true };
            this.pages = newPages;

            try {
                const repository = new ApiChapterRepository();
                const pageData = await repository.getChapterPage(this.currentChapter.id, pageNumber);

                // Vérifier que les données sont valides
                if (!pageData || !pageData.base64Content) {
                    throw new Error("Données de page invalides reçues de l'API");
                }

                // Mettre à jour la page
                const updatedPages = [...this.pages];
                updatedPages[pageIndex] = {
                    id: pageData.id,
                    pageNumber: pageData.pageNumber,
                    base64Content: pageData.base64Content,
                    mimeType: pageData.mimeType,
                    dimensions: pageData.dimensions
                };
                this.pages = updatedPages;
                this.loadedPages.add(pageIndex);
            } catch (error) {
                console.error(`Erreur lors du chargement de la page ${pageNumber}:`, error);
                // Marquer la page comme en erreur
                const errorPages = [...this.pages];
                errorPages[pageIndex] = { error: error.message };
                this.pages = errorPages;
            }
        },

        async preloadNextPages(startIndex, count = 3) {
            const promises = [];
            for (let i = 1; i <= count; i++) {
                const pageIndex = startIndex + i;
                if (pageIndex < this.totalPages) {
                    promises.push(this.loadPageData(pageIndex));
                }
            }
            await Promise.all(promises);
        },

        async handlePageVisible(pageIndex) {
            if (pageIndex !== this.currentPage) {
                this.currentPage = pageIndex;
                // Précharger les pages suivantes
                if (this.readingMode === 'infinite') {
                    await this.preloadNextPages(pageIndex);
                }
            }
        },

        async nextPage() {
            if (!this.isLastPage) {
                this.currentPage++;
                await this.loadPageData(this.currentPage);
            }
        },

        async previousPage() {
            if (!this.isFirstPage) {
                this.currentPage--;
                await this.loadPageData(this.currentPage);
            }
        },

        async setReadingMode(mode) {
            if (mode === this.readingMode) return;

            this.readingMode = mode;
            this.savePreferences();

            // S'assurer que la page courante est chargée
            await this.loadPageData(this.currentPage);

            // Si on passe en mode infini, précharger les pages suivantes
            if (mode === 'infinite') {
                await this.preloadNextPages(this.currentPage);
            }
        },

        setReadingDirection(direction) {
            this.readingDirection = direction;
            this.savePreferences();
        },

        setZoom(zoom) {
            this.zoom = Math.max(0.5, Math.min(2, zoom));
            this.savePreferences();
        },

        // Nouvelles actions pour les doubles pages
        setDoublePageMode(mode) {
            if (['rotate', 'scroll', 'normal'].includes(mode)) {
                this.doublePageSettings.mobileMode = mode;
                this.savePreferences();
            }
        },

        setDoublePageAutoDetect(enabled) {
            this.doublePageSettings.autoDetect = enabled;
            this.savePreferences();
        },

        setDoublePageDetectionThreshold(threshold) {
            this.doublePageSettings.detectionThreshold = Math.max(1.0, Math.min(3.0, threshold));
            this.savePreferences();
        },

        updateDoublePageSettings(settings) {
            this.doublePageSettings = {
                ...this.doublePageSettings,
                ...settings
            };
            this.savePreferences();
        },

        async goToNextChapter() {
            if (this.currentChapter?.navigation?.nextChapter) {
                await this.loadChapter(this.currentChapter.navigation.nextChapter);
            }
        },

        async goToPreviousChapter() {
            if (this.currentChapter?.navigation?.previousChapter) {
                await this.loadChapter(this.currentChapter.navigation.previousChapter);
                // Aller à la dernière page du chapitre précédent
                this.currentPage = Math.max(0, this.totalPages - 1);
                // S'assurer que la page est chargée
                if (this.totalPages > 0) {
                    await this.loadPageData(this.currentPage);
                }
            }
        },

        // Gestion de la persistance des préférences
        savePreferences() {
            try {
                const preferences = {
                    readingMode: this.readingMode,
                    readingDirection: this.readingDirection,
                    zoom: this.zoom,
                    doublePageSettings: this.doublePageSettings
                };
                localStorage.setItem('mangarr-reader-preferences', JSON.stringify(preferences));
            } catch (error) {
                console.error('Erreur lors de la sauvegarde des préférences:', error);
            }
        },

        loadPreferences() {
            try {
                const stored = localStorage.getItem('mangarr-reader-preferences');
                if (stored) {
                    const preferences = JSON.parse(stored);

                    // Appliquer les préférences sauvegardées
                    if (preferences.readingMode) this.readingMode = preferences.readingMode;
                    if (preferences.readingDirection) this.readingDirection = preferences.readingDirection;
                    if (typeof preferences.zoom === 'number') this.zoom = preferences.zoom;

                    // Migration: si l'ancien doublePageMode existe, le migrer vers mobileMode
                    if (preferences.doublePageMode && ['rotate', 'scroll', 'normal'].includes(preferences.doublePageMode)) {
                        this.doublePageSettings.mobileMode = preferences.doublePageMode;
                    }

                    if (preferences.doublePageSettings) {
                        this.doublePageSettings = {
                            ...this.doublePageSettings,
                            ...preferences.doublePageSettings
                        };
                    }
                }
            } catch (error) {
                console.error('Erreur lors du chargement des préférences:', error);
            }
        },

        // Réinitialiser les préférences
        resetPreferences() {
            this.readingMode = 'single';
            this.readingDirection = 'ltr';
            this.zoom = 1;
            this.doublePageSettings = {
                autoDetect: true,
                mobileMode: 'rotate',
                detectionThreshold: 1.2
            };
            this.savePreferences();
        }
    }
});
