@aguacerowx/react-native 0.0.24 → 0.0.26

package/src/WeatherLayerManager.js

@@ -8,13 +8,18 @@ import { fromByteArray } from 'base64-js';
 import { Platform, NativeModules } from 'react-native';
 import { mapRegistry } from './MapRegistry';
 
-console.log("--- Aguacero Native Module Initial State Check ---");
-console.log("All NativeModules:", Object.keys(NativeModules));
-console.log("WeatherFrameProcessorModule available?:", !!NativeModules.WeatherFrameProcessorModule);
-console.log("InspectorModule available?:", !!NativeModules.InspectorModule);
-console.log("GridRenderLayerManager available?:", !!NativeModules.GridRenderLayerManager);
-console.log("-------------------------------------------------");
-
+function findLatestModelRun(modelsData, modelName) {
+    const model = modelsData?.[modelName];
+    if (!model) return null;
+    const availableDates = Object.keys(model).sort((a, b) => b.localeCompare(a));
+    for (const date of availableDates) {
+        const runs = model[date];
+        if (!runs) continue;
+        const availableRuns = Object.keys(runs).sort((a, b) => b.localeCompare(a));
+        if (availableRuns.length > 0) return { date: date, run: availableRuns[0] };
+    }
+    return null;
+}
 const { WeatherFrameProcessorModule, InspectorModule } = NativeModules;
 
 /**
@@ -67,8 +72,17 @@ AguaceroCore.prototype.setMapCenter = function(center) {
 };
 
 export const WeatherLayerManager = forwardRef((props, ref) => {
-    // EDIT: Destructure the new props
-    const { inspectorEnabled, onInspect, apiKey, customColormaps, initialMode, initialVariable, ...restProps } = props;
+    const { 
+        inspectorEnabled, 
+        onInspect, 
+        apiKey, 
+        customColormaps, 
+        initialMode, 
+        initialVariable,
+        autoRefresh,        
+        autoRefreshInterval,  
+        ...restProps 
+    } = props;
     const context = useContext(AguaceroContext);
     
     // Create the core here instead of getting it from context
@@ -84,13 +98,11 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
     
     const gridLayerRef = useRef(null);
     const currentGridDataRef = useRef(null);
+    const autoRefreshIntervalId = useRef(null);
     
     // Cache for preloaded grid data - stores the processed data ready for GPU upload
     const preloadedDataCache = useRef(new Map());
     
-    // Track what we're currently preloading to avoid duplicates
-    const preloadingSet = useRef(new Set());
-    
     // Store geometry and colormap that don't change with forecast hour
     const cachedGeometry = useRef(null);
     const cachedColormap = useRef(null);
@@ -110,6 +122,18 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
     });
 
     useImperativeHandle(ref, () => {
+        const setAutoRefresh = (enabled, intervalSeconds) => {
+            if (autoRefreshIntervalId.current) {
+                clearInterval(autoRefreshIntervalId.current);
+                autoRefreshIntervalId.current = null;
+            }
+            if (enabled) {
+                const effectiveInterval = (intervalSeconds || autoRefreshInterval || 30) * 1000;
+                // Run once immediately, then start the interval
+                _checkForUpdates();
+                autoRefreshIntervalId.current = setInterval(_checkForUpdates, effectiveInterval);
+            }
+        };
         return {
             play: () => {
                 core.play();
@@ -137,8 +161,9 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     gridLayerRef.current.setSmoothing(enabled);
                 }
             },
+            setAutoRefresh,
         };
-    }, [core]);
+    }, [core, autoRefreshInterval, _checkForUpdates]);
 
     const preloadAllFramesToDisk = (state) => {
         
@@ -337,6 +362,23 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         });
     };
 
+    useEffect(() => {
+        // This effect manages the auto-refresh based on props
+        if (autoRefresh) {
+            const interval = (autoRefreshInterval || 30) * 1000;
+            _checkForUpdates(); // Run immediately on enable
+            autoRefreshIntervalId.current = setInterval(_checkForUpdates, interval);
+        }
+
+        // Cleanup function: this runs when the component unmounts or props change
+        return () => {
+            if (autoRefreshIntervalId.current) {
+                clearInterval(autoRefreshIntervalId.current);
+                autoRefreshIntervalId.current = null;
+            }
+        };
+    }, [autoRefresh, autoRefreshInterval, _checkForUpdates]);
+
     const updateGPUWithCachedData = (state) => {
         const { model, date, run, forecastHour, variable, units, isMRMS, mrmsTimestamp } = state;
         
@@ -547,13 +589,92 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         }
     };
 
+    const _checkForUpdates = useMemo(() => async () => {
+        if (!core) return;
+        const { isMRMS, model: currentModel, variable: currentVariable, date, run } = core.state;
+
+        if (isMRMS) {
+            // --- MRMS LOGIC WITH PRE-LOADING ---
+            const oldTimestamps = new Set(core.mrmsStatus?.[currentVariable] || []);
+            const mrmsStatus = await core.fetchMRMSStatus(true);
+            const newTimestamps = mrmsStatus?.[currentVariable] || [];
+            if (newTimestamps.length === 0) return;
+
+            const newTimestampsToPreload = newTimestamps.filter(ts => !oldTimestamps.has(ts));
+
+            if (newTimestampsToPreload.length > 0) {
+                core.mrmsStatus = mrmsStatus;
+                core._emitStateChange(); // Update UI slider without changing selection
+
+                console.log(`[Auto-Refresh] Preloading ${newTimestampsToPreload.length} new MRMS frames.`);
+                const { corners, gridDef } = core._getGridCornersAndDef('mrms');
+                const { nx, ny } = gridDef.grid_params;
+
+                newTimestampsToPreload.forEach(frame => {
+                    const cacheKey = `mrms-${frame}-${currentVariable}`;
+                    if (preloadedDataCache.current.has(cacheKey)) return;
+
+                    const frameDate = new Date(frame * 1000);
+                    const y = frameDate.getUTCFullYear(), m = (frameDate.getUTCMonth() + 1).toString().padStart(2, '0'), d = frameDate.getUTCDate().toString().padStart(2, '0');
+                    
+                    // --- THIS IS THE FIX ---
+                    // Changed 'variable' to 'currentVariable'
+                    const resourcePath = `/grids/mrms/${y}${m}${d}/${frame}/0/${currentVariable}/0`;
+                    // --- END FIX ---
+
+                    const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
+
+                    WeatherFrameProcessorModule.processFrame({ url, apiKey: core.apiKey, bundleId: core.bundleId })
+                        .then(result => {
+                            if (!result || !result.filePath) return;
+                            const frameData = { filePath: result.filePath, nx, ny, scale: result.scale, offset: result.offset, missing: result.missing, corners, gridDef, scaleType: result.scaleType, originalScale: result.scale, originalOffset: result.offset };
+                            preloadedDataCache.current.set(cacheKey, frameData);
+                            if (Platform.OS === 'ios' && gridLayerRef.current?.primeGpuCache) {
+                                gridLayerRef.current.primeGpuCache({ [cacheKey]: frameData });
+                            }
+                        }).catch(error => console.warn(`[Auto-Refresh] Failed to preload frame ${frame}:`, error));
+                });
+
+                const newTimestampsSet = new Set(newTimestamps);
+                oldTimestamps.forEach(oldTs => {
+                    if (!newTimestampsSet.has(oldTs)) {
+                        const cacheKey = `mrms-${oldTs}-${currentVariable}`;
+                        preloadedDataCache.current.delete(cacheKey);
+                    }
+                });
+            }
+        } else {
+            // --- MODEL LOGIC ---
+            const modelStatus = await core.fetchModelStatus(true);
+            const latestRun = findLatestModelRun(modelStatus, currentModel);
+            if (!latestRun) return;
+
+            const currentRunKey = `${date}:${run}`;
+            const latestRunKey = `${latestRun.date}:${latestRun.run}`;
+
+            if (latestRunKey > currentRunKey) {
+                // This preserves the current forecastHour while changing the run
+                await core.setState({
+                    date: latestRun.date,
+                    run: latestRun.run,
+                });
+            }
+        }
+    }, [core]);
+
     useEffect(() => {
         if (!core) {
             console.warn('⚠️ [useEffect] Core is not available yet');
             return;
         }
 
+        // --- REPLACE THIS ENTIRE FUNCTION ---
         const handleStateChange = async (newState) => {
+            // --- FIX 1: Notify the parent component IMMEDIATELY ---
+            // This ensures the parent UI (like sliders) always gets the latest state,
+            // including updated lists of available hours or timestamps.
+            props.onStateChange?.(newState);
+
             if (!previousStateRef.current) {
                 previousStateRef.current = core.state;
             } 
@@ -575,7 +696,6 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 newState.model === previousStateRef.current?.model &&
                 newState.units === previousStateRef.current?.units;
 
-            // ADD: Check for play state only change
             const isPlayStateOnlyChange = 
                 hasInitialLoad.current &&
                 newState.isPlaying !== previousStateRef.current?.isPlaying &&
@@ -586,7 +706,12 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 newState.units === previousStateRef.current?.units &&
                 newState.opacity === previousStateRef.current?.opacity;
             
+            // This gate now correctly prevents only redundant *internal* processing.
+            // The parent has already been notified.
             if (!isOpacityOnlyChange && !isPlayStateOnlyChange && lastProcessedState.current === stateKey) {
+                // --- FIX 2: Update the previous state ref before returning ---
+                // This is critical to prevent stale comparisons on the next state change event.
+                previousStateRef.current = newState;
                 return;
             }
             
@@ -594,22 +719,17 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 lastProcessedState.current = stateKey;
             }
             
-            // MOVE THIS TO THE TOP - Always notify the parent component of state changes
-            props.onStateChange?.(newState);
-            
             if (isOpacityOnlyChange) {
                 setRenderProps(prev => ({ ...prev, opacity: newState.opacity }));
                 previousStateRef.current = newState;
                 return;
             }
 
-            // ADD: Handle play state only change
             if (isPlayStateOnlyChange) {
                 previousStateRef.current = newState;
                 return;
             }
 
-            // Check if only units changed
             const isUnitsOnlyChange = 
                 hasInitialLoad.current &&
                 newState.model === previousStateRef.current.model &&
@@ -632,88 +752,48 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 if (cachedData && cachedData.originalScale !== undefined && cachedData.originalOffset !== undefined) {
                     const { baseUnit } = core._getColormapForVariable(variable);
                     const toUnit = core._getTargetUnit(baseUnit, units);
-                    
                     let dataScale = cachedData.originalScale;
                     let dataOffset = cachedData.originalOffset;
                     
                     if (baseUnit !== toUnit) {
                         const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
-                        console.log('🔧 [Unit Conversion] Conversion function exists:', !!conversionFunc);
-                        
                         if (conversionFunc) {
                             if (cachedData.scaleType === 'sqrt') {
-                                // Calculate what the physical values would be at offset and offset+scale
                                 const physicalAtOffset = dataOffset * dataOffset;
                                 const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
-
-                                // Convert these physical values to the new unit
                                 const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
                                 const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
-
-                                // Take sqrt to get back to intermediate values
                                 const newOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
                                 const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
-
                                 dataScale = newOffsetPlusScale - newOffset;
                                 dataOffset = newOffset;
                             } else {
                                 const convertedOffset = conversionFunc(dataOffset);
                                 const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
-
                                 dataScale = convertedOffsetPlusScale - convertedOffset;
                                 dataOffset = convertedOffset;
                             }
                         }
                     } 
                     
-                    // Update the colormap AND data range
                     const { colormap } = core._getColormapForVariable(variable);
                     const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-                    let dataRange;
-                    if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
-                        if (isMRMS) {
-                            dataRange = [5, 380];
-                        } else {
-                            dataRange = [5, 380];
-                        }
-                    } else {
-                        dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
-                    }
-                    
+                    let dataRange = (variable === 'ptypeRefl' || variable === 'ptypeRate') ? [5, 380] : [finalColormap[0], finalColormap[finalColormap.length - 2]];
                     const colormapBytes = _generateColormapBytes(finalColormap);
                     const colormapAsBase64 = fromByteArray(colormapBytes);
                     
                     gridLayerRef.current.updateColormapTexture(colormapAsBase64);
                     cachedColormap.current = { key: `${variable}-${units}` };
                     cachedDataRange.current = dataRange;
-                    
                     setRenderProps(prev => ({ ...prev, dataRange, opacity: newState.opacity }));
                     
                     if (gridLayerRef.current && gridLayerRef.current.updateDataParameters) {
-                        const scaleTypeValue = cachedData.scaleType === 'sqrt' ? 1 : 0;  // Convert to number
-                        
-                        console.log('🔄 [Unit Conversion] Calling updateDataParameters with:', {
-                            scale: dataScale,
-                            offset: dataOffset,
-                            missing: cachedData.missing,
-                            scaleType: scaleTypeValue
-                        });
-                        
-                        gridLayerRef.current.updateDataParameters(dataScale, dataOffset, cachedData.missing, scaleTypeValue);  // Pass scaleType
+                        const scaleTypeValue = cachedData.scaleType === 'sqrt' ? 1 : 0;
+                        gridLayerRef.current.updateDataParameters(dataScale, dataOffset, cachedData.missing, scaleTypeValue);
                     }
 
-                    const newCacheKey = isMRMS 
-                        ? `mrms-${mrmsTimestamp}-${variable}`
-                        : `${model}-${date}-${run}-${forecastHour}-${variable}`;
-                    
-                    preloadedDataCache.current.set(newCacheKey, {
-                        ...cachedData,
-                        scale: dataScale,
-                        offset: dataOffset
-                    });
-                    
-                } else {
-                    console.warn('⚠️ [Unit Conversion] No cached data found for key:', oldCacheKey);
+                    const newCacheKey = isMRMS ? `mrms-${mrmsTimestamp}-${variable}` : `${model}-${date}-${run}-${forecastHour}-${variable}`;
+                    preloadedDataCache.current.set(newCacheKey, { ...cachedData, scale: dataScale, offset: dataOffset });
                 }
                 
                 previousStateRef.current = newState;
@@ -729,51 +809,35 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 newState.run !== previousStateRef.current.run;
 
             if (needsFullLoad) {
-                
                 if (gridLayerRef.current) {
                     gridLayerRef.current.setVariable(newState.variable);
                     gridLayerRef.current.clear();
-                    // --- OPTIMIZATION: Clear the native GPU cache on iOS ---
                     if (Platform.OS === 'ios' && gridLayerRef.current.clearGpuCache) {
                         gridLayerRef.current.clearGpuCache();
                     }
                 }
                 hasPreloadedRef.current = false;
-                
                 preloadedDataCache.current.clear();
                 cachedGeometry.current = null;
                 cachedColormap.current = null;
-                
-                // ADD THIS: Clear the inspector cache too
                 currentGridDataRef.current = null;
-                
                 WeatherFrameProcessorModule.cancelAllFrames();
 
                 if (!newState.variable) {
                     previousStateRef.current = newState;
                     return;
                 }
-
                 preloadAllFramesToDisk(newState);
             } else if (newState.forecastHour !== previousStateRef.current.forecastHour || (newState.isMRMS && newState.mrmsTimestamp !== previousStateRef.current.mrmsTimestamp)) {
                 const success = updateGPUWithCachedData(newState);
-                
-                if (!success) {
-                    // CHANGED: Don't error, just log and wait for preload
-                    const timeKey = newState.isMRMS ? `timestamp ${newState.mrmsTimestamp}` : `hour +${newState.forecastHour}`;
-                    console.log(`⏳ [handleStateChange] Frame ${timeKey} not ready yet, waiting for preload...`);
-                    // Don't clear the layer - keep showing the previous frame until new one is ready
-                    // The preload will eventually complete and trigger a re-render
-                } else {
-                    // Only update inspector cache when we successfully loaded new data
-                    if (newState.opacity !== renderProps.opacity) {
-                        setRenderProps(prev => ({ ...prev, opacity: newState.opacity }));
-                    }
+                if (success && newState.opacity !== renderProps.opacity) {
+                    setRenderProps(prev => ({ ...prev, opacity: newState.opacity }));
                 }
             }
             
             previousStateRef.current = newState;
         };
+        // --- END REPLACEMENT ---
 
         handleStateChangeRef.current = handleStateChange;