Implement My Festival favourites feature

lib/domain/repositories/api_drink_repository.dart

@@ -28,7 +28,7 @@ class ApiDrinkRepository implements DrinkRepository {
     // Populate favorite status, ratings, and tasted status in a single pass
     final favorites = _favoritesService.getFavorites(festival.id);
     for (final drink in drinks) {
-      drink.isFavorite = favorites.contains(drink.id);
+      drink.isFavorite = favorites.containsKey(drink.id);
       drink.rating = _ratingsService.getRating(festival.id, drink.id);
       drink.isTasted = _tastingLogService.hasTasted(festival.id, drink.id);
     }
@@ -38,7 +38,7 @@ class ApiDrinkRepository implements DrinkRepository {
 
   @override
   Future<List<String>> getFavorites(String festivalId) async {
-    return _favoritesService.getFavorites(festivalId).toList();
+    return _favoritesService.getFavorites(festivalId).keys.toList();
   }
 
   @override
@@ -76,4 +76,26 @@ class ApiDrinkRepository implements DrinkRepository {
   Future<List<String>> getTastedDrinks(String festivalId) {
     return Future.value(_tastingLogService.getTastedDrinkIds(festivalId));
   }
+
+  @override
+  Future<String?> getFavoriteStatus(String festivalId, String drinkId) {
+    final item = _favoritesService.getFavoriteItem(festivalId, drinkId);
+    return Future.value(item?.status);
+  }
+
+  @override
+  Future<void> markAsTasted(String festivalId, String drinkId) {
+    return _favoritesService.markAsTasted(festivalId, drinkId);
+  }
+
+  @override
+  Future<void> deleteTry(String festivalId, String drinkId, DateTime timestamp) {
+    return _favoritesService.deleteTry(festivalId, drinkId, timestamp);
+  }
+
+  @override
+  Future<int> getTryCount(String festivalId, String drinkId) {
+    final item = _favoritesService.getFavoriteItem(festivalId, drinkId);
+    return Future.value(item?.tries.length ?? 0);
+  }
 }

lib/domain/repositories/drink_repository.dart

@@ -37,4 +37,16 @@ abstract class DrinkRepository {
 
   /// Get list of tasted drink IDs for a festival
   Future<List<String>> getTastedDrinks(String festivalId);
+
+  /// Get favorite status for a drink ('want_to_try', 'tasted', or null if not in log)
+  Future<String?> getFavoriteStatus(String festivalId, String drinkId);
+
+  /// Mark a drink as tasted (adds timestamp)
+  Future<void> markAsTasted(String festivalId, String drinkId);
+
+  /// Delete a specific tasting timestamp from a favorite item
+  Future<void> deleteTry(String festivalId, String drinkId, DateTime timestamp);
+
+  /// Get the number of times a drink has been tasted
+  Future<int> getTryCount(String festivalId, String drinkId);
 }

lib/models/favorite_item.dart

@@ -0,0 +1,99 @@
+/// Represents a drink in the user's festival log.
+///
+/// Tracks whether a drink is on the 'want to try' list or has been tasted,
+/// along with timestamps of tastings and optional notes.
+class FavoriteItem {
+  /// Creates a favorite item.
+  const FavoriteItem({
+    required this.id,
+    required this.status,
+    required this.tries,
+    this.notes,
+    required this.createdAt,
+    required this.updatedAt,
+  });
+
+  /// Drink ID.
+  final String id;
+
+  /// Status: 'want_to_try' or 'tasted'.
+  final String status;
+
+  /// List of tasting timestamps (empty if want_to_try).
+  final List<DateTime> tries;
+
+  /// Optional user notes.
+  final String? notes;
+
+  /// When this item was added to the log.
+  final DateTime createdAt;
+
+  /// When this item was last updated.
+  final DateTime updatedAt;
+
+  /// Creates a FavoriteItem from JSON.
+  factory FavoriteItem.fromJson(Map<String, dynamic> json) {
+    return FavoriteItem(
+      id: json['id'] as String,
+      status: json['status'] as String? ?? 'want_to_try',
+      tries: (json['tries'] as List?)
+              ?.map((e) => DateTime.parse(e as String))
+              .toList() ??
+          [],
+      notes: json['notes'] as String?,
+      createdAt: DateTime.parse(json['createdAt'] as String),
+      updatedAt: DateTime.parse(json['updatedAt'] as String),
+    );
+  }
+
+  /// Converts this item to JSON.
+  Map<String, dynamic> toJson() {
+    return {
+      'id': id,
+      'status': status,
+      'tries': tries.map((t) => t.toIso8601String()).toList(),
+      if (notes != null) 'notes': notes,
+      'createdAt': createdAt.toIso8601String(),
+      'updatedAt': updatedAt.toIso8601String(),
+    };
+  }
+
+  /// Creates a copy with updated fields.
+  ///
+  /// To explicitly clear notes, pass an empty Optional: `notes: Optional.value(null)`.
+  /// To keep existing notes, omit the parameter: `copyWith(status: 'tasted')`.
+  FavoriteItem copyWith({
+    String? id,
+    String? status,
+    List<DateTime>? tries,
+    Optional<String?>? notes,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+  }) {
+    return FavoriteItem(
+      id: id ?? this.id,
+      status: status ?? this.status,
+      tries: tries ?? this.tries,
+      notes: notes != null ? notes.value : this.notes,
+      createdAt: createdAt ?? this.createdAt,
+      updatedAt: updatedAt ?? this.updatedAt,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is FavoriteItem &&
+          runtimeType == other.runtimeType &&
+          id == other.id;
+
+  @override
+  int get hashCode => id.hashCode;
+}
+
+/// Wrapper class for explicitly passing null values in copyWith methods.
+class Optional<T> {
+  const Optional.value(this.value);
+
+  final T value;
+}

lib/models/models.dart

@@ -1,2 +1,3 @@
 export 'drink.dart';
+export 'favorite_item.dart';
 export 'festival.dart';

lib/providers/beer_provider.dart

@@ -451,6 +451,63 @@ class BeerProvider extends ChangeNotifier {
     await prefs.setInt('themeMode', mode.index);
   }
 
+  /// Get favorite status for a drink ('want_to_try', 'tasted', or null if not in log)
+  Future<String?> getFavoriteStatus(Drink drink) async {
+    if (_drinkRepository == null) return null;
+    return await _drinkRepository!.getFavoriteStatus(currentFestival.id, drink.id);
+  }
+
+  /// Check if drink is in festival log
+  bool isInFestivalLog(Drink drink) {
+    return drink.isFavorite;
+  }
+
+  /// Get try count for a drink
+  Future<int> getTryCount(Drink drink) async {
+    if (_drinkRepository == null) return 0;
+    return await _drinkRepository!.getTryCount(currentFestival.id, drink.id);
+  }
+
+  /// Mark a drink as tasted (adds timestamp)
+  Future<void> markAsTasted(Drink drink) async {
+    if (_drinkRepository == null) return;
+
+    await _drinkRepository!.markAsTasted(currentFestival.id, drink.id);
+
+    // Update drink state
+    drink.isFavorite = true;
+
+    notifyListeners();
+
+    // Log analytics event
+    final tryCount = await getTryCount(drink);
+    if (tryCount > 1) {
+      unawaited(_analyticsService.logFestivalLogMultipleTasting(drink.id, tryCount));
+    } else {
+      unawaited(_analyticsService.logFestivalLogMarkTasted(drink.id, tryCount));
+    }
+  }
+
+  /// Delete a specific tasting timestamp
+  Future<void> deleteTry(Drink drink, DateTime timestamp) async {
+    if (_drinkRepository == null) return;
+
+    await _drinkRepository!.deleteTry(currentFestival.id, drink.id, timestamp);
+
+    // Update drink state - check if still in favorites after deletion
+    final status = await _drinkRepository!.getFavoriteStatus(currentFestival.id, drink.id);
+    drink.isFavorite = status != null;
+
+    if (_showFavoritesOnly && status == null) {
+      _applyFiltersAndSort();
+    }
+
+    notifyListeners();
+
+    // Log analytics event
+    unawaited(_analyticsService.logFestivalLogDeleteTimestamp(drink.id));
+  }
+
   /// Toggle favorite status for a drink
   Future<void> toggleFavorite(Drink drink) async {
     if (_drinkRepository == null) return;

lib/services/analytics_service.dart

@@ -191,6 +191,38 @@ class AnalyticsService {
     ));
   }
 
+  /// Log drink marked as tasted in festival log
+  Future<void> logFestivalLogMarkTasted(String drinkId, int tryCount) async {
+    await _logIfEnabled(() => analytics.logEvent(
+      name: 'festival_log_mark_tasted',
+      parameters: {
+        'drink_id': drinkId,
+        'try_count': tryCount,
+      },
+    ));
+  }
+
+  /// Log multiple tasting of same drink
+  Future<void> logFestivalLogMultipleTasting(String drinkId, int tryCount) async {
+    await _logIfEnabled(() => analytics.logEvent(
+      name: 'festival_log_multiple_tasting',
+      parameters: {
+        'drink_id': drinkId,
+        'try_count': tryCount,
+      },
+    ));
+  }
+
+  /// Log tasting timestamp deleted
+  Future<void> logFestivalLogDeleteTimestamp(String drinkId) async {
+    await _logIfEnabled(() => analytics.logEvent(
+      name: 'festival_log_delete_timestamp',
+      parameters: {
+        'drink_id': drinkId,
+      },
+    ));
+  }
+
   /// Log error to Crashlytics (non-fatal)
   Future<void> logError(Object error, StackTrace? stackTrace, {String? reason}) async {
     try {