//import Bootstrap configuration (axios, Echo)
import './bootstrap.tsx';

//import Scss - Optimized version
import '../scss/themes-eneon.scss';
import '../css/app.css';

import 'sweetalert2/dist/sweetalert2.min.css';
import './sweetalert-config'; // Configuración global de SweetAlert2

import { createRoot } from 'react-dom/client';
import { createInertiaApp } from '@inertiajs/react';
import { router } from '@inertiajs/react';
import { Provider } from 'react-redux';
import { configureStore } from "@reduxjs/toolkit";
import rootReducer from "./slices";
import { LoadingProvider } from './LoadingContext';
import { ChatAssistantProvider } from './Contexts/ChatAssistantContext';
import { Suspense } from 'react';
import LoadingSpinner from './LoadingSpinner';
import InertiaCursor from './InertiaCursor';
import { registerServiceWorker, requestNotificationPermission } from './registerServiceWorker';

const appName = import.meta.env.VITE_APP_NAME || 'Laravel';
const store = configureStore({ reducer: rootReducer, devTools: import.meta.env.DEV });

// Función para actualizar el token CSRF desde múltiples fuentes
const updateCsrfToken = () => {
    // Prioridad 1: Leer de cookie XSRF-TOKEN (Laravel la envía automáticamente)
    const getCsrfTokenFromCookie = () => {
        try {
            const cookies = document.cookie.split(';');
            const xsrfCookie = cookies.find(cookie => cookie.trim().startsWith('XSRF-TOKEN='));
            if (xsrfCookie) {
                return decodeURIComponent(xsrfCookie.split('=')[1].trim());
            }
        } catch (e) {
            // Silenciar errores
        }
        return null;
    };
    
    // Prioridad 2: Leer del meta tag
    const getCsrfTokenFromMeta = () => {
        return document.querySelector('meta[name="csrf-token"]')?.getAttribute('content') || null;
    };
    
    const csrfToken = getCsrfTokenFromCookie() || getCsrfTokenFromMeta();
    
    if (csrfToken && window.axios) {
        window.axios.defaults.headers.common['X-CSRF-TOKEN'] = csrfToken;
        if (import.meta.env.DEV) {
            console.log('✅ Token CSRF actualizado:', csrfToken.substring(0, 10) + '...');
        }
    }
    return csrfToken;
};

// Función para forzar actualización del token después del logout
const refreshCsrfTokenAfterLogout = async () => {
    try {
        // Hacer una petición GET a /login para obtener el nuevo token
        // Laravel regenera el token después del logout
        await window.axios.get('/login', {
            headers: {
                'Accept': 'text/html, application/json',
            }
        });
        
        // Esperar un momento para que Laravel actualice el meta tag
        await new Promise(resolve => setTimeout(resolve, 100));
        
        // Actualizar el token
        updateCsrfToken();
        
        if (import.meta.env.DEV) {
            console.log('✅ Token CSRF refrescado después del logout');
        }
    } catch (error) {
        if (import.meta.env.DEV) {
            console.warn('⚠️ Error al refrescar token después del logout:', error);
        }
        // Fallback: actualizar desde lo que tengamos
        updateCsrfToken();
    }
};

// Actualizar el token CSRF después de cada navegación exitosa
router.on('success', (event) => {
    // Prioridad 1: Usar el token compartido desde Inertia (más confiable)
    if (event.detail.page.props?.csrfToken) {
        const csrfToken = event.detail.page.props.csrfToken;
        const metaTag = document.querySelector('meta[name="csrf-token"]');
        if (metaTag) {
            metaTag.setAttribute('content', csrfToken);
        }
        if (window.axios) {
            window.axios.defaults.headers.common['X-CSRF-TOKEN'] = csrfToken;
        }
        if (import.meta.env.DEV) {
            console.log('✅ Token CSRF actualizado desde Inertia:', csrfToken.substring(0, 10) + '...');
        }
    } else {
        // Fallback: Actualizar desde cookie o meta tag
        updateCsrfToken();
    }
    
    // Si es la página de login (especialmente después del logout), asegurar que el token esté disponible
    if (event.detail.page.component === 'Auth/Login') {
        setTimeout(() => {
            const csrfToken = event.detail.page.props?.csrfToken || updateCsrfToken();
            if (!csrfToken) {
                // Si no hay token, intentar refrescarlo
                refreshCsrfTokenAfterLogout();
            } else if (import.meta.env.DEV) {
                console.log('✅ Token CSRF disponible en página de login');
            }
        }, 100);
    }
});

// Manejar errores de navegación (especialmente 419 después del logout)
router.on('error', (event) => {
    if (event.detail.errors?.status === 419 || event.detail.errors?.message?.includes('419')) {
        if (import.meta.env.DEV) {
            console.log('🔄 Error 419 detectado, refrescando token CSRF...');
        }
        refreshCsrfTokenAfterLogout();
    }
});

createInertiaApp({
    title: (title) => `${title} - ${appName}`,
    resolve: async (name) => {
        // Lazy load bajo demanda, no pre-cargar todas las páginas
        const pages = import.meta.glob('./Pages/**/*.tsx');
        const page = await pages[`./Pages/${name}.tsx`]();
        return page.default;
    },
    setup({ el, App, props }) {
        const root = createRoot(el);

        // Actualizar el token CSRF al inicializar la app
        updateCsrfToken();
        
        // Si Inertia comparte el token CSRF, actualizarlo
        if (props.initialPage?.props?.csrfToken) {
            const metaTag = document.querySelector('meta[name="csrf-token"]');
            if (metaTag) {
                metaTag.setAttribute('content', props.initialPage.props.csrfToken);
            }
            if (window.axios) {
                window.axios.defaults.headers.common['X-CSRF-TOKEN'] = props.initialPage.props.csrfToken;
            }
            if (import.meta.env.DEV) {
                console.log('✅ Token CSRF actualizado desde Inertia props');
            }
        }

        // Registrar Service Worker para notificaciones push
        // Solo en producción para evitar conflictos en desarrollo
        if (import.meta.env.PROD) {
            registerServiceWorker()
                .then((registration) => {
                    if (registration) {
                        // Solicitar permisos de notificación después de registrar el SW
                        requestNotificationPermission().then((permission) => {
                            if (permission === 'granted') {
                                console.log('✅ Sistema de notificaciones listo');
                            }
                        });
                    }
                })
                .catch((error) => {
                    console.error('❌ Error al inicializar notificaciones:', error);
                });
        }

        root.render(
            <Provider store={store}>
                <LoadingProvider>
                    <ChatAssistantProvider>
                        <InertiaCursor />
                        <Suspense fallback={<LoadingSpinner message="Cargando página..." />}>
                            <App {...props} />
                        </Suspense>
                    </ChatAssistantProvider>
                </LoadingProvider>
            </Provider>
        );
    },
    progress: false,
});