Merge branch 'cursor-review-implement' of https://github.com/CodeStorm-Hub/petsphere into cursor-review-implement

Author: anamchowdhury

lib/controllers/follow_controller.dart

@@ -136,3 +136,9 @@ class FollowController extends Notifier<void> {
 
 final followControllerProvider =
     NotifierProvider<FollowController, void>(() => FollowController());
+
+/// Follower list (user profiles) for a specific pet.
+final petFollowersListProvider = FutureProvider.family<
+    List<Map<String, dynamic>>, String>((ref, petId) async {
+  return followRepository.fetchPetFollowersList(petId);
+});

lib/controllers/match_controller.dart

@@ -91,15 +91,19 @@ class MatchController extends Notifier<MatchState> {
     return state;
   }
 
-  Future<void> _load(String myPetId) async {
+  // When [silent] is true the loading flag is NOT set, so the UI avoids a
+  // full-screen spinner. Use this for background refreshes (e.g. after a like).
+  Future<void> _load(String myPetId, {bool silent = false}) async {
     final gen = ++_loadGeneration;
     final userId = ref.read(authProvider).user?.id;
     if (userId == null) {
-      state = state.copyWith(isLoading: false);
+      if (!silent) state = state.copyWith(isLoading: false);
       return;
     }
 
-    state = state.copyWith(isLoading: true, clearError: true);
+    if (!silent) state = state.copyWith(isLoading: true, clearError: true);
+
+    _currentDiscoveryPetId = myPetId;
 
     try {
       final futures = await Future.wait([
@@ -143,6 +147,12 @@ class MatchController extends Notifier<MatchState> {
   /// screen so the global active pet remains unchanged.
   Future<void> load(String petId) async => _load(petId);
 
+  /// The pet ID that was most recently loaded into this controller.
+  /// Tracks which pet the discovery screen is currently browsing for,
+  /// even when it differs from the global [activePetProvider].
+  String? get currentDiscoveryPetId => _currentDiscoveryPetId;
+  String? _currentDiscoveryPetId;
+
   void setFilterBreed(String? breed) {
     final activePet = ref.read(activePetProvider);
     debugPrint(
@@ -199,12 +209,32 @@ class MatchController extends Notifier<MatchState> {
     }).toList();
   }
 
-  Future<bool> sendLikeRequest(String receiverPetId) async {
-    final activePet = ref.read(activePetProvider);
-    if (activePet == null) return false;
+  /// Send a like/match request from the currently-browsing pet to [receiverPetId].
+  ///
+  /// [fromPetId] should be the pet selected in the Discovery tab
+  /// (from [discoveryActivePetIdProvider]). It defaults to the global
+  /// [activePetProvider] only as a fallback.
+  Future<bool> sendLikeRequest(
+    String receiverPetId, {
+    String? fromPetId,
+  }) async {
+    // Resolve the sender: prefer the explicitly passed discovery pet,
+    // fall back to _currentDiscoveryPetId, then the global active pet.
+    final myPets = ref.read(petProvider).myPets;
+    final targetId = fromPetId ?? _currentDiscoveryPetId;
+    PetModel? senderPet;
+    if (targetId != null) {
+      try {
+        senderPet = myPets.firstWhere((p) => p.id == targetId);
+      } catch (_) {
+        senderPet = null;
+      }
+    }
+    senderPet ??= ref.read(activePetProvider);
+    if (senderPet == null) return false;
 
     // Prevent liking own pets
-    final myPetIds = ref.read(petProvider).myPets.map((p) => p.id).toSet();
+    final myPetIds = myPets.map((p) => p.id).toSet();
     if (myPetIds.contains(receiverPetId)) {
       state = state.copyWith(error: 'You cannot like your own pet.');
       return false;
@@ -221,9 +251,11 @@ class MatchController extends Notifier<MatchState> {
 
     try {
       await matchRepository.sendLikeRequest(
-        senderPetId: activePet.id,
+        senderPetId: senderPet.id,
         receiverPetId: receiverPetId,
       );
+
+      // Optimistically remove the liked pet from the in-memory list.
       final discoveryPets =
           state.discoveryPets.where((p) => p.id != receiverPetId).toList();
       final allDiscoveryPets =
@@ -239,16 +271,17 @@ class MatchController extends Notifier<MatchState> {
           targetUserId: receiverPet.userId,
           title: 'New breeding interest',
           body:
-              '${activePet.name} is interested in breeding with ${receiverPet.name}.',
+              '${senderPet.name} is interested in breeding with ${receiverPet.name}.',
           type: 'match_request',
           entityType: 'match_request',
-          entityId: activePet.id,
-          actorPetId: activePet.id,
+          entityId: senderPet.id,
+          actorPetId: senderPet.id,
         );
       }
 
-      // Refresh sent requests
-      _load(activePet.id);
+      // Silent background refresh for the correct (discovery-selected) pet —
+      // does NOT show a loading spinner, so the UI transition is seamless.
+      _load(senderPet.id, silent: true);
       return true;
     } catch (e) {
       state = state.copyWith(error: 'Could not send request: $e');
@@ -296,3 +329,14 @@ class MatchController extends Notifier<MatchState> {
 final matchProvider = NotifierProvider<MatchController, MatchState>(() {
   return MatchController();
 });
+
+/// Aggregated incoming match requests for ALL of the current user's pets.
+/// Used by the Notifications screen so the Requests tab always shows the
+/// full picture regardless of which pet is selected in the Discovery tab.
+final allMatchRequestsProvider =
+    FutureProvider<List<MatchRequestModel>>((ref) async {
+  final myPets = ref.watch(petProvider).myPets;
+  if (myPets.isEmpty) return [];
+  final petIds = myPets.map((p) => p.id).toList();
+  return matchRepository.fetchAllMyRequests(petIds);
+});

lib/driver_main.dart

@@ -155,6 +155,72 @@ class FollowRepository {
         .eq('follower_user_id', userId);
     return (data as List).length;
   }
+
+  // -------------------------------------------------------------------------
+  // Get list of follower user IDs (direct pet followers + owner followers)
+  // Returns unique follower user IDs with basic user profile info via the
+  // users table join.
+  // -------------------------------------------------------------------------
+  Future<List<Map<String, dynamic>>> fetchPetFollowersList(String petId) async {
+    final pet = await supabase
+        .from('pets')
+        .select('user_id')
+        .eq('id', petId)
+        .maybeSingle();
+
+    if (pet == null) return [];
+    final ownerUserId = pet['user_id'] as String;
+
+    final results = await Future.wait([
+      // Direct pet followers
+      supabase
+          .from('follows')
+          .select('follower_user_id, created_at')
+          .not('followed_pet_id', 'is', null)
+          .eq('followed_pet_id', petId),
+      // Owner followers (implicit pet followers)
+      supabase
+          .from('follows')
+          .select('follower_user_id, created_at')
+          .not('followed_user_id', 'is', null)
+          .eq('followed_user_id', ownerUserId),
+    ]);
+
+    final seen = <String>{};
+    final combined = <Map<String, dynamic>>[];
+
+    for (final row in [...(results[0] as List), ...(results[1] as List)]) {
+      final userId = row['follower_user_id'] as String;
+      if (seen.add(userId)) {
+        combined.add({'user_id': userId, 'created_at': row['created_at']});
+      }
+    }
+
+    if (combined.isEmpty) return [];
+
+    // Fetch user profiles for all follower IDs
+    final followerIds = combined.map((r) => r['user_id'] as String).toList();
+    final profiles = await supabase
+        .from('users')
+        .select('id, name, profile_image_url')
+        .inFilter('id', followerIds);
+
+    final profileMap = {
+      for (final p in profiles as List<dynamic>)
+        (p as Map<String, dynamic>)['id'] as String: p,
+    };
+
+    return combined.map((r) {
+      final uid = r['user_id'] as String;
+      final profile = profileMap[uid] ?? {'id': uid, 'name': 'Unknown', 'profile_image_url': ''};
+      return {
+        'user_id': uid,
+        'name': (profile['name'] ?? 'Unknown') as String,
+        'profile_image_url': (profile['profile_image_url'] ?? '') as String,
+        'created_at': r['created_at'],
+      };
+    }).toList();
+  }
 }
 
 final followRepository = FollowRepository();

lib/repositories/follow_repository.dart

@@ -124,6 +124,24 @@ class MatchRepository {
         .toList();
   }
 
+  // -------------------------------------------------------------------------
+  // Fetch ALL match requests received by any of the user's pets
+  // Used by the Notifications screen to show requests across all pets.
+  // -------------------------------------------------------------------------
+  Future<List<MatchRequestModel>> fetchAllMyRequests(List<String> myPetIds) async {
+    if (myPetIds.isEmpty) return [];
+    final data = await supabase
+        .from('match_requests')
+        .select('*, sender_pets:pets!sender_pet_id(*)')
+        .inFilter('receiver_pet_id', myPetIds)
+        .eq('status', 'pending')
+        .order('created_at', ascending: false);
+
+    return (data as List<dynamic>)
+        .map((e) => MatchRequestModel.fromJson(e as Map<String, dynamic>))
+        .toList();
+  }
+
   // -------------------------------------------------------------------------
   // Accept or decline a match request
   // -------------------------------------------------------------------------

lib/repositories/match_repository.dart

@@ -44,6 +44,7 @@ import '../views/pet_social_timeline_screen.dart';
 import '../views/pet_breed_identifier_screen.dart';
 import '../views/pet_knowledge_base_screen.dart';
 import '../views/pet_gear_reviews_screen.dart';
+import '../views/pet_followers_screen.dart';
 
 final routerProvider = Provider<GoRouter>((ref) {
   final authNotifier = ValueNotifier<AuthState>(ref.read(authProvider));
@@ -198,6 +199,13 @@ final routerProvider = Provider<GoRouter>((ref) {
         path: '/search',
         builder: (context, state) => const SearchScreen(),
       ),
+      GoRoute(
+        path: '/pet/:id/followers',
+        builder: (context, state) {
+          final petId = state.pathParameters['id']!;
+          return PetFollowersScreen(petId: petId);
+        },
+      ),
       GoRoute(
         path: '/achievements',
         builder: (context, state) => const GamificationScreen(),

lib/utils/routes.dart

@@ -284,7 +284,13 @@ class DiscoveryTabState extends ConsumerState<DiscoveryTab>
 
     if (!liked) return;
 
-    ref.read(matchProvider.notifier).sendLikeRequest(pet.id).then((success) {
+    // Pass the currently-selected discovery pet so the like is sent from
+    // the correct pet (not the global active pet).
+    final discoveryPetId = ref.read(discoveryActivePetIdProvider);
+    ref
+        .read(matchProvider.notifier)
+        .sendLikeRequest(pet.id, fromPetId: discoveryPetId)
+        .then((success) {
       if (!mounted) return;
       if (success) {
         ScaffoldMessenger.of(context).showSnackBar(
@@ -295,6 +301,7 @@ class DiscoveryTabState extends ConsumerState<DiscoveryTab>
         );
         return;
       }
+      // On failure: re-show the pet by removing it from the dismissed set.
       setState(() => dismissedPetIds.remove(pet.id));
       final error = ref.read(matchProvider).error;
       ScaffoldMessenger.of(context).showSnackBar(
@@ -421,16 +428,25 @@ class DiscoveryTabState extends ConsumerState<DiscoveryTab>
     ref.listen<MatchState>(matchProvider, (prev, next) {
       if (!mounted) return;
       final petsChanged = prev?.discoveryPets != next.discoveryPets;
-      // A load just finished with an empty feed for the selected pet.
-      final loadFinishedEmpty =
-          prev?.isLoading == true && !next.isLoading && next.discoveryPets.isEmpty;
+      // A full load cycle just completed (isLoading transitioned false→false
+      // via true, i.e. prev was loading and now it's done).
+      final loadCycleFinished =
+          prev?.isLoading == true && !next.isLoading;
+      final loadFinishedEmpty = loadCycleFinished && next.discoveryPets.isEmpty;
 
       if (!petsChanged && !loadFinishedEmpty) return;
 
       final currentIds = next.discoveryPets.map((p) => p.id).toSet();
       setState(() {
         if (petsChanged) {
-          dismissedPetIds.removeWhere((id) => !currentIds.contains(id));
+          // Only purge dismissed IDs during a real load cycle (when
+          // isLoading transitioned). Optimistic updates from sendLikeRequest
+          // set petsChanged=true but keep isLoading=false throughout, so we
+          // skip the purge there to avoid re-showing the just-dismissed pet
+          // if a concurrent network fetch brings it back momentarily.
+          if (loadCycleFinished) {
+            dismissedPetIds.removeWhere((id) => !currentIds.contains(id));
+          }
           _clampIndex(next.discoveryPets);
         }
         if (loadFinishedEmpty) {