feat: Add functionality to fetch actor photos and update gallery details

lib/api.dart

···
 import 'models/follows_result.dart';
 import 'models/gallery.dart';
 import 'models/gallery_item.dart';
+import 'models/gallery_photo.dart';
 import 'models/gallery_thread.dart';
 import 'models/notification.dart' as grain;
 import 'models/profile.dart';
 
 class ApiService {
+  // ...existing code...
   static const _storage = FlutterSecureStorage();
   String? _accessToken;
   Profile? currentUser;
···
     galleries =
         (json['items'] as List<dynamic>?)?.map((item) => Gallery.fromJson(item)).toList() ?? [];
     return galleries;
+  }
+
+  Future<List<GalleryPhoto>> fetchActorPhotos({required String did}) async {
+    appLogger.i('Fetching photos for actor did: $did');
+    final response = await http.get(
+      Uri.parse('$_apiUrl/xrpc/social.grain.photo.getActorPhotos?actor=$did'),
+      headers: {'Content-Type': 'application/json'},
+    );
+    if (response.statusCode != 200) {
+      appLogger.w('Failed to fetch photos: ${response.statusCode} ${response.body}');
+      return [];
+    }
+    final json = jsonDecode(response.body);
+    return (json['items'] as List<dynamic>?)?.map((item) => GalleryPhoto.fromJson(item)).toList() ??
+        [];
   }
 
   Future<List<Gallery>> getTimeline({String? algorithm}) async {
···
       return false;
     }
     appLogger.i('Gallery sort order updated successfully');
+    return true;
+  }
+
+  /// Updates a gallery's title and description.
+  /// Returns true on success, false on failure.
+  Future<bool> updateGallery({
+    required String galleryUri,
+    required String title,
+    required String description,
+    required String createdAt,
+  }) async {
+    final session = await auth.getValidSession();
+    if (session == null) {
+      appLogger.w('No valid session for updateGallery');
+      return false;
+    }
+    final dpopClient = DpopHttpClient(dpopKey: session.dpopJwk);
+    final issuer = session.issuer;
+    final did = session.subject;
+    final url = Uri.parse('$issuer/xrpc/com.atproto.repo.putRecord');
+    // Extract rkey from galleryUri
+    String rkey = '';
+    try {
+      rkey = AtUri.parse(galleryUri).rkey;
+    } catch (_) {}
+    if (rkey.isEmpty) {
+      appLogger.w('No rkey found in galleryUri: $galleryUri');
+      return false;
+    }
+    final record = {
+      'collection': 'social.grain.gallery',
+      'repo': did,
+      'rkey': rkey,
+      'record': {
+        'title': title,
+        'description': description,
+        'updatedAt': DateTime.now().toUtc().toIso8601String(),
+        'createdAt': createdAt,
+      },
+    };
+    appLogger.i('Updating gallery: $record');
+    final response = await dpopClient.send(
+      method: 'POST',
+      url: url,
+      accessToken: session.accessToken,
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode(record),
+    );
+    if (response.statusCode != 200 && response.statusCode != 201) {
+      appLogger.w('Failed to update gallery: ${response.statusCode} ${response.body}');
+      return false;
+    }
+    appLogger.i('Gallery updated successfully');
     return true;
   }
 }

lib/providers/gallery_cache_provider.dart

···
     return (galleryUri, photoUris);
   }
 
+  /// Creates gallery items for existing photoUris, polls for updated gallery items, and updates the cache.
+  /// Returns the list of new gallery item URIs if successful, or empty list otherwise.
+  Future<List<String>> addGalleryItemsToGallery({
+    required String galleryUri,
+    required List<String> photoUris,
+    int? startPosition,
+  }) async {
+    // Fetch the latest gallery from the API to avoid stale state
+    final latestGallery = await apiService.getGallery(uri: galleryUri);
+    if (latestGallery != null) {
+      state = {...state, galleryUri: latestGallery};
+    }
+    final gallery = latestGallery ?? state[galleryUri];
+    final int initialCount = gallery?.items.length ?? 0;
+    final int positionOffset = startPosition ?? initialCount;
+    final List<String> galleryItemUris = [];
+    int position = positionOffset;
+    for (final photoUri in photoUris) {
+      // Create the gallery item
+      final itemUri = await apiService.createGalleryItem(
+        galleryUri: galleryUri,
+        photoUri: photoUri,
+        position: position,
+      );
+      if (itemUri != null) {
+        galleryItemUris.add(itemUri);
+        position++;
+      }
+    }
+    // Poll for updated gallery items
+    final expectedCount = (gallery?.items.length ?? 0) + galleryItemUris.length;
+    await apiService.pollGalleryItems(galleryUri: galleryUri, expectedCount: expectedCount);
+    // Fetch the updated gallery and update the cache
+    final updatedGallery = await apiService.getGallery(uri: galleryUri);
+    if (updatedGallery != null) {
+      state = {...state, galleryUri: updatedGallery};
+    }
+    return galleryItemUris;
+  }
+
   /// Deletes a gallery from the backend and removes it from the cache.
   Future<void> deleteGallery(String uri) async {
     await apiService.deleteRecord(uri);
···
         .toList();
     final updatedGallery = gallery.copyWith(items: updatedPhotos);
     state = {...state, galleryUri: updatedGallery};
+  }
+
+  /// Updates gallery details (title, description) and updates cache if successful.
+  /// Updates gallery details (title, description, createdAt), polls for cid change, and updates cache.
+  Future<bool> updateGalleryDetails({
+    required String galleryUri,
+    required String title,
+    required String description,
+    required String createdAt,
+  }) async {
+    final prevGallery = state[galleryUri];
+    final prevCid = prevGallery?.cid;
+    final success = await apiService.updateGallery(
+      galleryUri: galleryUri,
+      title: title,
+      description: description,
+      createdAt: createdAt,
+    );
+    if (success) {
+      final start = DateTime.now();
+      const timeout = Duration(seconds: 20);
+      const pollInterval = Duration(milliseconds: 1000);
+      Gallery? updatedGallery;
+      while (DateTime.now().difference(start) < timeout) {
+        updatedGallery = await apiService.getGallery(uri: galleryUri);
+        if (updatedGallery != null && updatedGallery.cid != prevCid) {
+          break;
+        }
+        await Future.delayed(pollInterval);
+      }
+      if (updatedGallery != null) {
+        state = {...state, galleryUri: updatedGallery};
+      }
+    }
+    return success;
   }
 }

lib/providers/gallery_cache_provider.g.dart

···
 // RiverpodGenerator
 // **************************************************************************
 
-String _$galleryCacheHash() => r'd4561d30bcba16bf3a32f456e45c73f4c36da2e7';
+String _$galleryCacheHash() => r'87470ecbbe2528ec77f1df7062bd1a29780e6732';
 
 /// Holds a cache of galleries by URI.
 ///

lib/screens/create_gallery_page.dart

···
     }
     setState(() => _submitting = true);
     String? galleryUri;
+    final container = ProviderScope.containerOf(context, listen: false);
     if (widget.gallery == null) {
       // Use provider to create gallery and add photos
       final newImages = _images.where((img) => !img.isExisting).toList();
-      final container = ProviderScope.containerOf(context, listen: false);
       final galleryCache = container.read(galleryCacheProvider.notifier);
       final (createdUri, newPhotoUris) = await galleryCache.createGalleryAndAddPhotos(
         title: _titleController.text.trim(),
···
         }
       }
     } else {
-      // Only support editing title/description for existing galleries
       galleryUri = widget.gallery!.uri;
-      // If you have a provider method for updating, use it. Otherwise, call the correct API method.
-      // await apiService.updateGallery(
-      //   uri: galleryUri,
-      //   title: _titleController.text.trim(),
-      //   description: _descController.text.trim(),
-      // );
+      final galleryCache = container.read(galleryCacheProvider.notifier);
+      await galleryCache.updateGalleryDetails(
+        galleryUri: galleryUri,
+        title: _titleController.text.trim(),
+        description: _descController.text.trim(),
+        createdAt: widget.gallery!.createdAt ?? DateTime.now().toUtc().toIso8601String(),
+      );
     }
     setState(() => _submitting = false);
     if (mounted && galleryUri != null) {
···
                 hintText: 'Enter a description',
               ),
               const SizedBox(height: 16),
-              Row(
-                children: [
-                  AppButton(
-                    label: 'Upload photos',
-                    onPressed: _pickImages,
-                    icon: Icons.photo_library,
-                    variant: AppButtonVariant.primary,
-                    height: 40,
-                    fontSize: 15,
-                    borderRadius: 6,
-                  ),
-                ],
-              ),
+              if (widget.gallery == null)
+                Row(
+                  children: [
+                    AppButton(
+                      label: 'Upload photos',
+                      onPressed: _pickImages,
+                      icon: Icons.photo_library,
+                      variant: AppButtonVariant.primary,
+                      height: 40,
+                      fontSize: 15,
+                      borderRadius: 6,
+                    ),
+                  ],
+                ),
               if (_images.isNotEmpty) ...[
                 const SizedBox(height: 16),
                 GridView.builder(

lib/screens/gallery_edit_photos_sheet.dart

···
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:grain/api.dart';
 import 'package:grain/models/gallery_photo.dart';
 import 'package:grain/providers/gallery_cache_provider.dart';
 import 'package:grain/widgets/app_button.dart';
 import 'package:grain/widgets/app_image.dart';
 import 'package:image_picker/image_picker.dart';
+
+import 'library_photos_select_sheet.dart';
 
 class GalleryEditPhotosSheet extends ConsumerStatefulWidget {
   final String galleryUri;
···
   @override
   Widget build(BuildContext context) {
     final theme = Theme.of(context);
+    // ...existing code...
     return CupertinoPageScaffold(
       backgroundColor: theme.colorScheme.surface,
       navigationBar: CupertinoNavigationBar(
···
                       label: 'Add from library',
                       variant: AppButtonVariant.secondary,
                       onPressed: () async {
-                        // TODO: Implement add from library action
+                        if (_loading) return;
+                        final actorDid = apiService.currentUser?.did;
+                        if (actorDid == null) return;
+                        await showLibraryPhotosSelectSheet(
+                          context,
+                          actorDid: actorDid,
+                          galleryUri: widget.galleryUri,
+                          onSelect: (photos) {
+                            setState(() {
+                              _photos.addAll(photos);
+                            });
+                          },
+                        );
                       },
                     ),
                   ),

lib/screens/gallery_sort_order_sheet.dart

···
 
 class _GallerySortOrderSheetState extends State<GallerySortOrderSheet> {
   late List<GalleryPhoto> _photos;
+  bool _saving = false;
 
   @override
   void initState() {
···
         ),
         leading: CupertinoButton(
           padding: EdgeInsets.zero,
-          onPressed: () => Navigator.of(context).maybePop(),
+          onPressed: _saving ? null : () => Navigator.of(context).maybePop(),
           child: Text(
             'Cancel',
-            style: TextStyle(color: theme.colorScheme.primary, fontWeight: FontWeight.w600),
+            style: TextStyle(
+              color: _saving ? Colors.grey : theme.colorScheme.primary,
+              fontWeight: FontWeight.w600,
+            ),
           ),
         ),
         trailing: CupertinoButton(
           padding: EdgeInsets.zero,
-          onPressed: () {
-            widget.onReorderDone(_photos, context);
-          },
-          child: Text(
-            'Save',
-            style: TextStyle(color: theme.colorScheme.primary, fontWeight: FontWeight.w600),
+          onPressed: _saving
+              ? null
+              : () {
+                  setState(() => _saving = true);
+                  widget.onReorderDone(_photos, context);
+                  if (mounted) setState(() => _saving = false);
+                },
+          child: Row(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              Text(
+                'Save',
+                style: TextStyle(
+                  color: _saving ? Colors.grey : theme.colorScheme.primary,
+                  fontWeight: FontWeight.w600,
+                ),
+              ),
+              if (_saving) ...[
+                const SizedBox(width: 8),
+                SizedBox(width: 18, height: 18, child: CircularProgressIndicator(strokeWidth: 2)),
+              ],
+            ],
           ),
         ),
       ),

lib/screens/library_photos_select_sheet.dart

···
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:font_awesome_flutter/font_awesome_flutter.dart';
+import 'package:grain/api.dart';
+import 'package:grain/models/gallery_photo.dart';
+import 'package:grain/providers/gallery_cache_provider.dart';
+import 'package:grain/widgets/app_button.dart';
+import 'package:grain/widgets/app_image.dart';
+
+class LibraryPhotosSelectSheet extends ConsumerStatefulWidget {
+  final String actorDid;
+  final String galleryUri;
+  final void Function(List<GalleryPhoto>) onSelect;
+
+  const LibraryPhotosSelectSheet({
+    super.key,
+    required this.actorDid,
+    required this.galleryUri,
+    required this.onSelect,
+  });
+
+  @override
+  ConsumerState<LibraryPhotosSelectSheet> createState() => _LibraryPhotosSelectSheetState();
+}
+
+class _LibraryPhotosSelectSheetState extends ConsumerState<LibraryPhotosSelectSheet> {
+  List<GalleryPhoto> _photos = [];
+  final Set<int> _selectedIndexes = {};
+  bool _loading = true;
+  bool _addingItems = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _fetchPhotos();
+  }
+
+  Future<void> _fetchPhotos() async {
+    setState(() => _loading = true);
+    final photos = await apiService.fetchActorPhotos(did: widget.actorDid);
+    if (mounted) {
+      setState(() {
+        _photos = photos;
+        _loading = false;
+      });
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    return CupertinoPageScaffold(
+      backgroundColor: theme.colorScheme.surface,
+      navigationBar: CupertinoNavigationBar(
+        backgroundColor: theme.colorScheme.surface,
+        border: Border(bottom: BorderSide(color: theme.dividerColor, width: 1)),
+        middle: Text(
+          'Select Photos from Library',
+          style: theme.textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600),
+        ),
+        leading: CupertinoButton(
+          padding: EdgeInsets.zero,
+          onPressed: (_loading || _addingItems) ? null : () => Navigator.of(context).maybePop(),
+          child: Text(
+            'Cancel',
+            style: TextStyle(
+              color: _addingItems ? Colors.grey : theme.colorScheme.primary,
+              fontWeight: FontWeight.w600,
+            ),
+          ),
+        ),
+      ),
+      child: SafeArea(
+        bottom: false,
+        child: Padding(
+          padding: const EdgeInsets.only(top: 8, left: 16, right: 16, bottom: 24),
+          child: Column(
+            children: [
+              Expanded(
+                child: _loading
+                    ? Center(child: CircularProgressIndicator())
+                    : GridView.builder(
+                        itemCount: _photos.length,
+                        gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(
+                          crossAxisCount: 3,
+                          crossAxisSpacing: 8,
+                          mainAxisSpacing: 8,
+                          childAspectRatio: 1,
+                        ),
+                        itemBuilder: (context, index) {
+                          final photo = _photos[index];
+                          final selected = _selectedIndexes.contains(index);
+                          return GestureDetector(
+                            onTap: () {
+                              setState(() {
+                                if (selected) {
+                                  _selectedIndexes.remove(index);
+                                } else {
+                                  _selectedIndexes.add(index);
+                                }
+                              });
+                            },
+                            child: Stack(
+                              fit: StackFit.expand,
+                              children: [
+                                Container(
+                                  decoration: BoxDecoration(
+                                    borderRadius: BorderRadius.circular(8),
+                                    color: Colors.grey[200],
+                                    // Remove border highlight for selected
+                                    // borderRadius already specified above
+                                  ),
+                                  clipBehavior: Clip.antiAlias,
+                                  child: Stack(
+                                    fit: StackFit.expand,
+                                    children: [
+                                      photo.thumb != null && photo.thumb!.isNotEmpty
+                                          ? AppImage(url: photo.thumb!, fit: BoxFit.cover)
+                                          : const Icon(Icons.photo, size: 48),
+                                      if (selected) ...[
+                                        Container(
+                                          decoration: BoxDecoration(
+                                            color: Colors.black.withOpacity(0.25),
+                                            borderRadius: BorderRadius.circular(8),
+                                          ),
+                                        ),
+                                        Positioned(
+                                          top: 8,
+                                          right: 8,
+                                          child: FaIcon(
+                                            FontAwesomeIcons.checkCircle,
+                                            color: Colors.white,
+                                            size: 24,
+                                          ),
+                                        ),
+                                      ],
+                                    ],
+                                  ),
+                                ),
+                                // ...existing code...
+                              ],
+                            ),
+                          );
+                        },
+                      ),
+              ),
+              const SizedBox(height: 16),
+              AppButton(
+                label: _selectedIndexes.isEmpty
+                    ? 'Add Selected Photos'
+                    : 'Add Selected (${_selectedIndexes.length}) Photos',
+                loading: _addingItems,
+                onPressed: _loading || _addingItems || _selectedIndexes.isEmpty
+                    ? null
+                    : () async {
+                        setState(() => _addingItems = true);
+                        final selectedPhotos = _selectedIndexes.map((i) => _photos[i]).toList();
+                        final photoUris = selectedPhotos.map((p) => p.uri).toList();
+                        // Call provider to add gallery items
+                        await ref
+                            .read(galleryCacheProvider.notifier)
+                            .addGalleryItemsToGallery(
+                              galleryUri: widget.galleryUri,
+                              photoUris: photoUris,
+                            );
+                        widget.onSelect(selectedPhotos);
+                        if (mounted) setState(() => _addingItems = false);
+                        if (!context.mounted) return;
+                        Navigator.of(context).maybePop();
+                      },
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+Future<void> showLibraryPhotosSelectSheet(
+  BuildContext context, {
+  required String actorDid,
+  required String galleryUri,
+  required void Function(List<GalleryPhoto>) onSelect,
+}) async {
+  await showCupertinoSheet(
+    context: context,
+    useNestedNavigation: true,
+    pageBuilder: (context) => Material(
+      type: MaterialType.transparency,
+      child: LibraryPhotosSelectSheet(
+        actorDid: actorDid,
+        galleryUri: galleryUri,
+        onSelect: onSelect,
+      ),
+    ),
+  );
+}