feat: Implement functionality to update alt text for multiple photos and add editing interface

lib/api.dart

···
     appLogger.i('Created photo exif record result: $result');
     return result['uri'] as String?;
   }
+
+  /// Updates multiple photo records in the social.grain.photo collection using applyWrites.
+  /// Each photo in [updates] should have: photoUri, photo, aspectRatio, alt, createdAt
+  /// Returns true on success, false on failure.
+  Future<bool> updatePhotos(List<Map<String, dynamic>> updates) async {
+    final session = await auth.getValidSession();
+    if (session == null) {
+      appLogger.w('No valid session for updatePhotosBatch');
+      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.applyWrites');
+
+    // Fetch current photo records for all photos
+    final photoRecords = await fetchPhotoRecords();
+
+    final writes = <Map<String, dynamic>>[];
+    for (final update in updates) {
+      String rkey = '';
+      try {
+        rkey = AtUri.parse(update['photoUri'] as String).rkey;
+      } catch (_) {}
+      if (rkey.isEmpty) {
+        appLogger.w('No rkey found in photoUri: ${update['photoUri']}');
+        continue;
+      }
+
+      // Get the full photo record for this photoUri
+      final record = photoRecords[update['photoUri']];
+      if (record == null) {
+        appLogger.w('No photo record found for photoUri: ${update['photoUri']}');
+        continue;
+      }
+
+      // Use provided values or fallback to the record's values
+      final photoBlobRef = update['photo'] ?? record['photo'];
+      final aspectRatio = update['aspectRatio'] ?? record['aspectRatio'];
+      final createdAt = update['createdAt'] ?? record['createdAt'];
+
+      if (photoBlobRef == null) {
+        appLogger.w('No blobRef found for photoUri: ${update['photoUri']}');
+        continue;
+      }
+
+      writes.add({
+        '\$type': 'com.atproto.repo.applyWrites#update',
+        'collection': 'social.grain.photo',
+        'rkey': rkey,
+        'value': {
+          'photo': photoBlobRef,
+          'aspectRatio': aspectRatio,
+          'alt': update['alt'] ?? '',
+          'createdAt': createdAt,
+        },
+      });
+    }
+    if (writes.isEmpty) {
+      appLogger.w('No valid photo updates to apply');
+      return false;
+    }
+    final payload = {'repo': did, 'validate': false, 'writes': writes};
+    appLogger.i('Applying batch photo updates: $payload');
+    final response = await dpopClient.send(
+      method: 'POST',
+      url: url,
+      accessToken: session.accessToken,
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode(payload),
+    );
+    if (response.statusCode != 200 && response.statusCode != 201) {
+      appLogger.w('Failed to apply batch photo updates: ${response.statusCode} ${response.body}');
+      return false;
+    }
+    appLogger.i('Batch photo updates applied successfully');
+    return true;
+  }
+
+  /// Fetches the full photo record for each photo in social.grain.photo.
+  /// Returns a map of photoUri -> photo record (Map`<`String, dynamic`>`).
+  Future<Map<String, dynamic>> fetchPhotoRecords() async {
+    final session = await auth.getValidSession();
+    if (session == null) {
+      appLogger.w('No valid session for fetchPhotoRecords');
+      return {};
+    }
+    final dpopClient = DpopHttpClient(dpopKey: session.dpopJwk);
+    final issuer = session.issuer;
+    final did = session.subject;
+    final url = Uri.parse(
+      '$issuer/xrpc/com.atproto.repo.listRecords?repo=$did&collection=social.grain.photo',
+    );
+
+    final response = await dpopClient.send(
+      method: 'GET',
+      url: url,
+      accessToken: session.accessToken,
+      headers: {'Content-Type': 'application/json'},
+    );
+
+    if (response.statusCode != 200) {
+      appLogger.w('Failed to list photo records: ${response.statusCode} ${response.body}');
+      return {};
+    }
+
+    final json = jsonDecode(response.body) as Map<String, dynamic>;
+    final records = json['records'] as List<dynamic>? ?? [];
+    final photoRecords = <String, dynamic>{};
+
+    for (final record in records) {
+      final uri = record['uri'] as String?;
+      final value = record['value'] as Map<String, dynamic>?;
+      if (uri != null && value != null) {
+        photoRecords[uri] = value;
+      }
+    }
+    return photoRecords;
+  }
 }
 
 final apiService = ApiService();

lib/providers/gallery_cache_provider.dart

···
     setGalleries(galleries);
     return galleries;
   }
+
+  /// Updates alt text for multiple photos by calling apiService.updatePhotos, then updates the gallery cache state manually.
+  /// [galleryUri]: The URI of the gallery containing the photos.
+  /// [altUpdates]: List of maps with keys: photoUri, alt (and optionally aspectRatio, createdAt, photo).
+  Future<bool> updatePhotoAltTexts({
+    required String galleryUri,
+    required List<Map<String, dynamic>> altUpdates,
+  }) async {
+    final success = await apiService.updatePhotos(altUpdates);
+    if (!success) return false;
+
+    // Update the gallery photos' alt text in the cache manually
+    final gallery = state[galleryUri];
+    if (gallery == null) return false;
+
+    // Build a map of photoUri to new alt text
+    final altMap = {for (final update in altUpdates) update['photoUri'] as String: update['alt']};
+
+    final updatedPhotos = gallery.items.map((photo) {
+      final newAlt = altMap[photo.uri];
+      if (newAlt != null) {
+        return photo.copyWith(alt: newAlt);
+      }
+      return photo;
+    }).toList();
+
+    final updatedGallery = gallery.copyWith(items: updatedPhotos);
+    state = {...state, galleryUri: updatedGallery};
+    return true;
+  }
 }

lib/screens/edit_alt_text_sheet.dart

···
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:grain/models/gallery_photo.dart';
+import 'package:grain/widgets/app_image.dart';
+
+class EditAltTextSheet extends StatefulWidget {
+  final List<GalleryPhoto> photos;
+  final void Function(Map<String, String?>) onSave;
+
+  const EditAltTextSheet({super.key, required this.photos, required this.onSave});
+
+  @override
+  State<EditAltTextSheet> createState() => _EditAltTextSheetState();
+}
+
+class _EditAltTextSheetState extends State<EditAltTextSheet> {
+  late Map<String, TextEditingController> _controllers;
+
+  @override
+  void initState() {
+    super.initState();
+    _controllers = {
+      for (final photo in widget.photos) photo.uri: TextEditingController(text: photo.alt ?? ''),
+    };
+  }
+
+  @override
+  void dispose() {
+    for (final c in _controllers.values) {
+      c.dispose();
+    }
+    super.dispose();
+  }
+
+  void _onSave() {
+    final altTexts = {for (final photo in widget.photos) photo.uri: _controllers[photo.uri]?.text};
+    widget.onSave(altTexts);
+    Navigator.of(context).pop();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    return CupertinoPageScaffold(
+      backgroundColor: theme.colorScheme.surface,
+      navigationBar: CupertinoNavigationBar(
+        backgroundColor: theme.colorScheme.surface,
+        middle: Text(
+          'Edit alt text',
+          style: theme.textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600),
+        ),
+        leading: CupertinoButton(
+          padding: EdgeInsets.zero,
+          child: const Text('Cancel'),
+          onPressed: () => Navigator.of(context).pop(),
+        ),
+        trailing: CupertinoButton(
+          padding: EdgeInsets.zero,
+          onPressed: _onSave,
+          child: const Text('Save'),
+        ),
+      ),
+      child: SafeArea(
+        child: ListView.separated(
+          padding: const EdgeInsets.all(16),
+          itemCount: widget.photos.length,
+          separatorBuilder: (_, __) => const SizedBox(height: 12),
+          itemBuilder: (context, index) {
+            final theme = Theme.of(context);
+            final photo = widget.photos[index];
+            final width = photo.aspectRatio?.width;
+            final height = photo.aspectRatio?.height;
+            return Row(
+              crossAxisAlignment: CrossAxisAlignment.center,
+              children: [
+                SizedBox(
+                  width: 64,
+                  child: AspectRatio(
+                    aspectRatio: (width != null && height != null && width > 0 && height > 0)
+                        ? width / height
+                        : 1.0,
+                    child: AppImage(
+                      url: photo.thumb ?? photo.fullsize,
+                      borderRadius: BorderRadius.circular(8),
+                    ),
+                  ),
+                ),
+                const SizedBox(width: 16),
+                Expanded(
+                  child: TextField(
+                    controller: _controllers[photo.uri],
+                    decoration: InputDecoration(
+                      hintText: 'Enter alt text',
+                      border: InputBorder.none,
+                      filled: false,
+                      contentPadding: const EdgeInsets.symmetric(vertical: 16, horizontal: 12),
+                      hintStyle: theme.textTheme.bodyMedium?.copyWith(color: theme.hintColor),
+                    ),
+                    style: theme.textTheme.bodyMedium,
+                    cursorColor: theme.colorScheme.primary,
+                    minLines: 1,
+                    maxLines: 6,
+                    textAlignVertical: TextAlignVertical.top,
+                    scrollPhysics: const AlwaysScrollableScrollPhysics(),
+                    keyboardType: TextInputType.multiline,
+                  ),
+                ),
+              ],
+            );
+          },
+        ),
+      ),
+    );
+  }
+}
+
+Future<void> showEditAltTextSheet(
+  BuildContext context, {
+  required List<GalleryPhoto> photos,
+  required void Function(Map<String, String?>) onSave,
+}) async {
+  final theme = Theme.of(context);
+  await showCupertinoSheet(
+    context: context,
+    useNestedNavigation: false,
+    pageBuilder: (context) => Material(
+      type: MaterialType.transparency,
+      child: EditAltTextSheet(photos: photos, onSave: onSave),
+    ),
+  );
+  // Restore status bar style or any other cleanup
+  SystemChrome.setSystemUIOverlayStyle(
+    theme.brightness == Brightness.dark ? SystemUiOverlayStyle.light : SystemUiOverlayStyle.dark,
+  );
+}

lib/screens/gallery_action_sheet.dart

···
   final VoidCallback? onChangeSortOrder;
   final Future<void> Function(BuildContext parentContext)? onDeleteGallery;
   final BuildContext parentContext;
+  final VoidCallback? onEditAltText;
 
   const GalleryActionSheet({
     super.key,
     required this.parentContext,
     this.onEditDetails,
     this.onEditPhotos,
+    this.onEditAltText,
     this.onChangeSortOrder,
     this.onDeleteGallery,
   });
···
             onTap: () {
               Navigator.of(context).pop();
               if (onEditPhotos != null) onEditPhotos!();
+            },
+          ),
+          ListTile(
+            leading: Icon(AppIcons.edit),
+            title: const Text('Edit alt text'),
+            onTap: () {
+              Navigator.of(context).pop();
+              if (onEditAltText != null) onEditAltText!();
             },
           ),
           ListTile(

lib/screens/gallery_page.dart

···
 import 'package:grain/providers/profile_provider.dart';
 import 'package:grain/screens/comments_page.dart';
 import 'package:grain/screens/create_gallery_page.dart';
+import 'package:grain/screens/edit_alt_text_sheet.dart';
 import 'package:grain/screens/gallery_action_sheet.dart';
 import 'package:grain/screens/gallery_edit_photos_sheet.dart';
 import 'package:grain/screens/gallery_sort_order_sheet.dart';
···
                             },
                           );
                         },
+                        onEditAltText: () {
+                          showEditAltTextSheet(
+                            context,
+                            photos: gallery.items,
+                            onSave: (altTexts) async {
+                              // altTexts: Map<String, String?> (photoUri -> alt)
+                              final altUpdates = altTexts.entries
+                                  .map((e) => {'photoUri': e.key, 'alt': e.value})
+                                  .toList();
+                              await ref
+                                  .read(galleryCacheProvider.notifier)
+                                  .updatePhotoAltTexts(
+                                    galleryUri: gallery.uri,
+                                    altUpdates: altUpdates,
+                                  );
+                            },
+                          );
+                        },
                         onChangeSortOrder: () {
                           showGallerySortOrderSheet(
                             context,
···
                               await ref
                                   .read(galleryCacheProvider.notifier)
                                   .reorderGalleryItems(galleryUri: gallery.uri, newOrder: newOrder);
-                              await _maybeFetchGallery(forceRefresh: true);
                               if (!sheetContext.mounted) return;
                               Navigator.of(sheetContext).pop();
                               if (!mounted) return;