// --- SISTEMA DE PERSISTENCIA CAPACITOR ---
// Manejo de almacenamiento nativo para Android usando Capacitor Preferences
// Usa Preferences API como almacenamiento primario en móvil, con localStorage como fallback

// Estado del sistema de persistencia de Capacitor
const CapacitorPersistence = {
    isCapacitor: false,
    isInitialized: false,
    Preferences: null,
    App: null
};

// Detectar si estamos en Capacitor
function isRunningInCapacitor() {
    return typeof Capacitor !== 'undefined' && Capacitor.isNativePlatform && Capacitor.isNativePlatform();
}

// Inicializar sistema de Capacitor
async function initCapacitorPersistence() {
    if (!isRunningInCapacitor()) {
        console.log('[CapPersist] No es plataforma nativa, usando solo localStorage');
        return false;
    }

    try {
        // Obtener plugins de Capacitor
        CapacitorPersistence.isCapacitor = true;

        // Cargar Preferences plugin
        if (Capacitor.Plugins && Capacitor.Plugins.Preferences) {
            CapacitorPersistence.Preferences = Capacitor.Plugins.Preferences;
            console.log('[CapPersist] Preferences plugin cargado');
        } else {
            console.warn('[CapPersist] Preferences plugin no disponible');
        }

        // Cargar App plugin para eventos de ciclo de vida
        if (Capacitor.Plugins && Capacitor.Plugins.App) {
            CapacitorPersistence.App = Capacitor.Plugins.App;
            console.log('[CapPersist] App plugin cargado');

            // Registrar listeners de ciclo de vida
            setupAppLifecycleListeners();
        } else {
            console.warn('[CapPersist] App plugin no disponible');
        }

        // Migrar datos de localStorage a Preferences si es necesario
        await migrateLocalStorageToPreferences();

        CapacitorPersistence.isInitialized = true;
        console.log('[CapPersist] Sistema inicializado correctamente');
        return true;
    } catch (e) {
        console.error('[CapPersist] Error inicializando:', e);
        return false;
    }
}

// Configurar listeners de ciclo de vida de la app
function setupAppLifecycleListeners() {
    if (!CapacitorPersistence.App) return;

    // Guardar cuando la app pasa a background
    CapacitorPersistence.App.addListener('pause', () => {
        console.log('[CapPersist] App en pausa - guardando...');
        saveGame();
    });

    // Cargar cuando la app vuelve a foreground
    CapacitorPersistence.App.addListener('resume', () => {
        console.log('[CapPersist] App resumida');
        // Opcionalmente podríamos recargar el estado aquí
    });

    // Guardar antes de que la app sea terminada
    CapacitorPersistence.App.addListener('appStateChange', (state) => {
        if (!state.isActive) {
            console.log('[CapPersist] App inactiva - guardando...');
            saveGame();
        }
    });

    console.log('[CapPersist] Listeners de ciclo de vida configurados');
}

// Migrar datos de localStorage a Preferences
async function migrateLocalStorageToPreferences() {
    if (!CapacitorPersistence.Preferences) return;

    try {
        // Verificar si ya hay datos en Preferences
        const { value: prefsData } = await CapacitorPersistence.Preferences.get({ key: SAVE_KEY });

        if (prefsData) {
            console.log('[CapPersist] Ya hay datos en Preferences, no es necesario migrar');
            return;
        }

        // Intentar migrar desde localStorage
        const localData = localStorage.getItem(SAVE_KEY);
        if (localData) {
            await CapacitorPersistence.Preferences.set({
                key: SAVE_KEY,
                value: localData
            });
            console.log('[CapPersist] Datos migrados de localStorage a Preferences');
        }
    } catch (e) {
        console.error('[CapPersist] Error migrando datos:', e);
    }
}

// Guardar en Preferences (almacenamiento nativo)
async function saveToPreferences(data) {
    if (!CapacitorPersistence.Preferences) return false;

    try {
        await CapacitorPersistence.Preferences.set({
            key: SAVE_KEY,
            value: JSON.stringify(data)
        });
        return true;
    } catch (e) {
        console.error('[CapPersist] Error guardando en Preferences:', e);
        return false;
    }
}

// Cargar desde Preferences
async function loadFromPreferences() {
    if (!CapacitorPersistence.Preferences) return null;

    try {
        const { value } = await CapacitorPersistence.Preferences.get({ key: SAVE_KEY });
        return value ? JSON.parse(value) : null;
    } catch (e) {
        console.error('[CapPersist] Error cargando desde Preferences:', e);
        return null;
    }
}

// Función de guardado dual (localStorage + Preferences)
async function saveGameDual(saveData) {
    // Siempre guardar en localStorage como fallback
    try {
        localStorage.setItem(SAVE_KEY, JSON.stringify(saveData));
    } catch (e) {
        console.error('[CapPersist] Error guardando en localStorage:', e);
    }

    // Si estamos en Capacitor, también guardar en Preferences
    if (CapacitorPersistence.isCapacitor && CapacitorPersistence.Preferences) {
        await saveToPreferences(saveData);
    }
}

// Función de carga dual (prioriza Preferences sobre localStorage)
async function loadGameDual() {
    // Si estamos en Capacitor, intentar cargar desde Preferences primero
    if (CapacitorPersistence.isCapacitor && CapacitorPersistence.Preferences) {
        const prefsData = await loadFromPreferences();
        if (prefsData) {
            console.log('[CapPersist] Datos cargados desde Preferences');
            // Sincronizar con localStorage
            try {
                localStorage.setItem(SAVE_KEY, JSON.stringify(prefsData));
            } catch (e) {
                // Ignorar errores de sincronización
            }
            return prefsData;
        }
    }

    // Fallback a localStorage
    try {
        const localData = localStorage.getItem(SAVE_KEY);
        if (localData) {
            console.log('[CapPersist] Datos cargados desde localStorage');
            return JSON.parse(localData);
        }
    } catch (e) {
        console.error('[CapPersist] Error cargando desde localStorage:', e);
    }

    return null;
}

// Borrar datos de Preferences (usado en "Borrar Todo")
async function clearPreferences() {
    if (!CapacitorPersistence.Preferences) return false;

    try {
        await CapacitorPersistence.Preferences.remove({ key: SAVE_KEY });
        console.log('[CapPersist] Datos borrados de Preferences');
        return true;
    } catch (e) {
        console.error('[CapPersist] Error borrando Preferences:', e);
        return false;
    }
}
