feat: enhance Memories UI with improved titles and event bubbling fix

✨ Features:
- Display 'On this day last year' for memories from exactly 1 year ago
- Format location-based memories as 'Trip to [Location], [Year]' (e.g., 'Trip to Jaipur, 2025')
- Fix MediaView slideshow and info buttons not working in memory albums

🐛 Bug Fixes:
- Fixed event bubbling issue where MediaView control clicks closed the entire viewer
- Conditionally render MemoryViewer backdrop only when MediaView is closed
- Prevent click handlers from interfering with MediaView controls

🎨 UI Improvements:
- Enhanced FeaturedMemoryCard with contextual year display
- Updated MemoryCard title formatting for better location context
- Improved memory viewing experience with proper z-index layering

📦 Technical Changes:
- Backend: Added reverse geocoding for location names in memory clustering
- Backend: Fixed latitude/longitude handling for images without GPS data
- Frontend: Refactored MemoryViewer JSX structure for proper conditional rendering
- Frontend: Integrated MediaView component with full zoom/slideshow/info functionality

This commit completes the Memories feature implementation with Google Photos-style
presentation and fixes critical UX issues with the image viewer controls.

Author: dehydrated-bear

backend/app/database/images.py

@@ -176,16 +176,19 @@ def db_bulk_insert_images(image_records: List[ImageRecord]) -> bool:
     try:
         cursor.executemany(
             """
-            INSERT INTO images (id, path, folder_id, thumbnailPath, metadata, isTagged)
-            VALUES (:id, :path, :folder_id, :thumbnailPath, :metadata, :isTagged)
+            INSERT INTO images (id, path, folder_id, thumbnailPath, metadata, isTagged, latitude, longitude, captured_at)
+            VALUES (:id, :path, :folder_id, :thumbnailPath, :metadata, :isTagged, :latitude, :longitude, :captured_at)
             ON CONFLICT(path) DO UPDATE SET
                 folder_id=excluded.folder_id,
                 thumbnailPath=excluded.thumbnailPath,
                 metadata=excluded.metadata,
                 isTagged=CASE
                     WHEN excluded.isTagged THEN 1
                     ELSE images.isTagged
-                END
+                END,
+                latitude=COALESCE(excluded.latitude, images.latitude),
+                longitude=COALESCE(excluded.longitude, images.longitude),
+                captured_at=COALESCE(excluded.captured_at, images.captured_at)
             """,
             image_records,
         )
@@ -804,6 +807,67 @@ def db_get_images_with_location() -> List[dict]:
 
         return images
 
+    except Exception as e:
+        logger.error(f"Error fetching images with location: {e}")
+        return []
+    finally:
+        conn.close()
+
+
+def db_get_all_images_for_memories() -> List[dict]:
+    """
+    Get ALL images that can be used for memories (with OR without GPS).
+    Includes images with timestamps for date-based memories.
+    
+    Returns:
+        List of all image dictionaries (both GPS and non-GPS images)
+    """
+    conn = _connect()
+    cursor = conn.cursor()
+    
+    try:
+        cursor.execute("""
+            SELECT 
+                i.id, 
+                i.path, 
+                i.folder_id,
+                i.thumbnailPath, 
+                i.metadata,
+                i.isTagged,
+                i.isFavourite,
+                i.latitude, 
+                i.longitude, 
+                i.captured_at,
+                GROUP_CONCAT(m.name, ',') as tags
+            FROM images i
+            LEFT JOIN image_classes ic ON i.id = ic.image_id
+            LEFT JOIN mappings m ON ic.class_id = m.class_id
+            GROUP BY i.id
+            ORDER BY i.captured_at DESC
+        """)
+        
+        results = cursor.fetchall()
+        
+        images = []
+        for row in results:
+            from app.utils.images import image_util_parse_metadata
+            
+            images.append({
+                "id": row[0],
+                "path": row[1],
+                "folder_id": str(row[2]) if row[2] else None,
+                "thumbnailPath": row[3],
+                "metadata": image_util_parse_metadata(row[4]),
+                "isTagged": bool(row[5]),
+                "isFavourite": bool(row[6]),
+                "latitude": row[7] if row[7] else None,  # Can be None
+                "longitude": row[8] if row[8] else None,  # Can be None
+                "captured_at": row[9] if row[9] else None,
+                "tags": row[10].split(',') if row[10] else None
+            })
+        
+        return images
+        
     except Exception as e:
         logger.error(f"Error getting images with location: {e}")
         return []

backend/app/routes/memories.py

@@ -116,46 +116,32 @@ async def generate_memories(
     min_images: int = Query(2, ge=1, le=10, description="Minimum images per memory")
 ):
     """
-    Generate memories from all images with location data.
+    SIMPLIFIED: Generate memories from ALL images.
+    - GPS images → location-based memories
+    - Non-GPS images → monthly date-based memories
     
-    This endpoint:
-    1. Fetches all images that have GPS coordinates
-    2. Clusters them by location using DBSCAN
-    3. Within each location, clusters by date
-    4. Returns memory objects with metadata
-    
-    Args:
-        location_radius_km: Maximum distance between photos in same location (default: 5km)
-        date_tolerance_days: Maximum days between photos in same memory (default: 3)
-        min_images: Minimum images required to form a memory (default: 2)
-        
-    Returns:
-        GenerateMemoriesResponse with list of generated memories
-        
-    Raises:
-        HTTPException: If database query fails or clustering fails
+    Returns simple breakdown: {location_count, date_count, total}
     """
     try:
-        logger.info("Generating memories with params: "
-                   f"radius={location_radius_km}km, "
-                   f"date_tolerance={date_tolerance_days}days, "
-                   f"min_images={min_images}")
+        logger.info(f"Generating memories: radius={location_radius_km}km, "
+                   f"date_tolerance={date_tolerance_days}days, min_images={min_images}")
 
-        # Fetch all images with location data
-        images = db_get_images_with_location()
+        # Fetch ALL images
+        from app.database.images import db_get_all_images_for_memories
+        images = db_get_all_images_for_memories()
 
         if not images:
             return GenerateMemoriesResponse(
                 success=True,
-                message="No images with location data found",
+                message="No images found",
                 memory_count=0,
                 image_count=0,
                 memories=[]
             )
 
-        logger.info(f"Found {len(images)} images with location data")
+        logger.info(f"Processing {len(images)} images")
 
-        # Cluster images into memories
+        # Cluster into memories
         clustering = MemoryClustering(
             location_radius_km=location_radius_km,
             date_tolerance_days=date_tolerance_days,
@@ -164,19 +150,24 @@ async def generate_memories(
 
         memories = clustering.cluster_memories(images)
 
-        logger.info(f"Generated {len(memories)} memories")
+        # Calculate breakdown
+        location_count = sum(1 for m in memories if m.get('type') == 'location')
+        date_count = sum(1 for m in memories if m.get('type') == 'date')
+        
+        logger.info(f"Generated {len(memories)} memories "
+                   f"(location: {location_count}, date: {date_count})")
 
         return GenerateMemoriesResponse(
             success=True,
-            message=f"Successfully generated {len(memories)} memories from {len(images)} images",
+            message=f"{len(memories)} memories ({location_count} location, {date_count} date)",
             memory_count=len(memories),
             image_count=len(images),
             memories=memories
         )
 
     except Exception as e:
-        logger.error(f"Error generating memories: {e}")
-        raise HTTPException(status_code=500, detail=f"Failed to generate memories: {str(e)}")
+        logger.error(f"Error generating memories: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.get("/timeline", response_model=TimelineResponse)

backend/app/utils/images.py

@@ -3,7 +3,7 @@
 import datetime
 import json
 import logging
-from typing import List, Tuple, Dict, Any, Mapping
+from typing import List, Tuple, Dict, Any, Mapping, Optional
 from PIL import Image, ExifTags
 from pathlib import Path
 
@@ -19,6 +19,7 @@
 from app.models.FaceDetector import FaceDetector
 from app.models.ObjectClassifier import ObjectClassifier
 from app.logging.setup_logging import get_logger
+from app.utils.extract_location_metadata import MetadataExtractor
 
 logger = get_logger(__name__)
 
@@ -141,6 +142,7 @@ def image_util_prepare_image_records(
 ) -> List[Dict]:
     """
     Prepare image records with thumbnails for database insertion.
+    Automatically extracts GPS coordinates and capture datetime from metadata.
 
     Args:
         image_files: List of image file paths
@@ -150,6 +152,8 @@ def image_util_prepare_image_records(
         List of image record dictionaries ready for database insertion
     """
     image_records = []
+    extractor = MetadataExtractor()
+    
     for image_path in image_files:
         folder_id = image_util_find_folder_id_for_image(image_path, folder_path_to_id)
 
@@ -166,16 +170,40 @@ def image_util_prepare_image_records(
         if image_util_generate_thumbnail(image_path, thumbnail_path):
             metadata = image_util_extract_metadata(image_path)
             logger.debug(f"Extracted metadata for {image_path}: {metadata}")
-            image_records.append(
-                {
-                    "id": image_id,
-                    "path": image_path,
-                    "folder_id": folder_id,
-                    "thumbnailPath": thumbnail_path,
-                    "metadata": json.dumps(metadata),
-                    "isTagged": False,
-                }
-            )
+            
+            # Automatically extract GPS coordinates and datetime from metadata
+            # Don't fail upload if extraction fails
+            metadata_json = json.dumps(metadata)
+            latitude, longitude, captured_at = None, None, None
+            
+            try:
+                latitude, longitude, captured_at = extractor.extract_all(metadata_json)
+                
+                # Log GPS extraction results
+                if latitude and longitude:
+                    logger.info(f"GPS extracted for {os.path.basename(image_path)}: ({latitude}, {longitude})")
+                if captured_at:
+                    logger.debug(f"Date extracted for {os.path.basename(image_path)}: {captured_at}")
+            except Exception as e:
+                logger.warning(f"GPS extraction failed for {os.path.basename(image_path)}: {e}")
+                # Continue without GPS - don't fail the upload
+            
+            # Build image record with GPS data
+            # ALWAYS include latitude, longitude, captured_at (even if None)
+            # to satisfy SQL INSERT statement named parameters
+            image_record = {
+                "id": image_id,
+                "path": image_path,
+                "folder_id": folder_id,
+                "thumbnailPath": thumbnail_path,
+                "metadata": metadata_json,
+                "isTagged": False,
+                "latitude": latitude,  # Can be None
+                "longitude": longitude,  # Can be None
+                "captured_at": captured_at.isoformat() if isinstance(captured_at, datetime.datetime) and captured_at else captured_at,  # Can be None
+            }
+            
+            image_records.append(image_record)
 
     return image_records