fixed the slot reordering and drag and drop

Author: Your Name

lib/providers/badge_slot_provider..dart

@@ -14,6 +14,10 @@ class BadgeSlotProvider with ChangeNotifier {
   // Available slot numbers pool
   final Set<int> _availableSlots = {1, 2, 3, 4, 5, 6, 7, 8};
 
+  // Maps badge key -> visual order in the list (for display)
+  // Visual order represents the target position where badge should appear
+  final Map<String, int> _badgeKeyToVisualOrder = {};
+
   static const int maxSelectedBadges = 8;
 
   Set<String> get selectedBadges => _badgeKeyToSelectionOrder.keys.toSet();
@@ -32,41 +36,90 @@ class BadgeSlotProvider with ChangeNotifier {
     return entries.map((e) => e.key).toList();
   }
 
-  /// ✅ Updated reorderSlots to perform push-down insertion
+  /// Swaps slot assignments between two badges when drag and drop occurs
   void reorderSlots(String fromBadgeKey, String toBadgeKey) {
     if (!_badgeKeyToSelectionOrder.containsKey(fromBadgeKey) ||
         !_badgeKeyToSelectionOrder.containsKey(toBadgeKey)) {
       return;
     }
 
-    final orderedKeys = getSelectionsOrderedBySlot();
-    orderedKeys.remove(fromBadgeKey);
-    final toIndex = orderedKeys.indexOf(toBadgeKey);
+    // Swap the slot assignments
+    final fromSlot = _badgeKeyToSlot[fromBadgeKey];
+    final toSlot = _badgeKeyToSlot[toBadgeKey];
+
+    if (fromSlot != null && toSlot != null) {
+      _badgeKeyToSlot[fromBadgeKey] = toSlot;
+      _badgeKeyToSlot[toBadgeKey] = fromSlot;
+    }
+
+    // Swap the visual order assignments
+    final fromVisual = _badgeKeyToVisualOrder[fromBadgeKey];
+    final toVisual = _badgeKeyToVisualOrder[toBadgeKey];
+
+    if (fromVisual != null && toVisual != null) {
+      // Both have visual order, swap them
+      _badgeKeyToVisualOrder[fromBadgeKey] = toVisual;
+      _badgeKeyToVisualOrder[toBadgeKey] = fromVisual;
+    } else if (fromVisual == null && toVisual == null) {
+      // Neither has visual order, assign them based on slots after swap
+      // Use the swapped slot numbers as visual order
+      if (fromSlot != null && toSlot != null) {
+        _badgeKeyToVisualOrder[fromBadgeKey] = toSlot;
+        _badgeKeyToVisualOrder[toBadgeKey] = fromSlot;
+      }
+    } else if (fromVisual == null) {
+      // fromBadgeKey doesn't have visual order yet
+      if (toSlot != null) {
+        _badgeKeyToVisualOrder[fromBadgeKey] = toSlot;
+      }
+      if (toVisual != null && fromSlot != null) {
+        _badgeKeyToVisualOrder[toBadgeKey] = fromSlot;
+      } else if (fromSlot != null) {
+        _badgeKeyToVisualOrder[toBadgeKey] = fromSlot;
+      }
+    } else {
+      // toBadgeKey doesn't have visual order yet
+      if (fromSlot != null && toSlot != null) {
+        _badgeKeyToVisualOrder[fromBadgeKey] = toSlot;
+        _badgeKeyToVisualOrder[toBadgeKey] = fromSlot;
+      }
+    }
 
-    orderedKeys.insert(toIndex, fromBadgeKey);
+    // Update selection order to reflect the slot positions
+    // Sort badges by their slot numbers (1, 2, 3, etc.)
+    final allBadgeKeys = _badgeKeyToSlot.keys.toList();
+    allBadgeKeys.sort((a, b) {
+      final slotA = _badgeKeyToSlot[a] ?? 0;
+      final slotB = _badgeKeyToSlot[b] ?? 0;
+      return slotA.compareTo(slotB);
+    });
 
-    // Update selection order
+    // Reassign selection order based on sorted slot positions
     _badgeKeyToSelectionOrder.clear();
-    for (int i = 0; i < orderedKeys.length; i++) {
-      _badgeKeyToSelectionOrder[orderedKeys[i]] = i;
+    for (int i = 0; i < allBadgeKeys.length; i++) {
+      _badgeKeyToSelectionOrder[allBadgeKeys[i]] = i;
     }
 
-    // Keep original slot assignments - don't reassign slots
-    // The slot numbers should remain as they were originally assigned
     notifyListeners();
   }
 
   void toggleSelection(String badgeKey) {
     if (_badgeKeyToSelectionOrder.containsKey(badgeKey)) {
-      // Unselect: remove from selection order and slot
+      // Unselect: remove from selection order but keep original slot and visual order assignments
       _badgeKeyToSelectionOrder.remove(badgeKey);
+      // CRITICAL: Keep visual order so badge doesn't move in the list when deselected
+      // _badgeKeyToVisualOrder stays intact
       final freedSlot = _badgeKeyToSlot.remove(badgeKey);
 
+      // Add the freed slot to available slots
       if (freedSlot != null) {
         _availableSlots.add(freedSlot);
       }
 
-      // Don't reassign slot numbers - keep original slots for remaining badges
+      // CRITICAL: Do NOT reindex the remaining badges
+      // This keeps A (slot 1), C (slot 3) in their original positions
+      // even after B (slot 2) is deselected
+
       notifyListeners();
       return;
     }
@@ -79,6 +132,10 @@ class BadgeSlotProvider with ChangeNotifier {
     final newOrder = _badgeKeyToSelectionOrder.length;
     _badgeKeyToSelectionOrder[badgeKey] = newOrder;
 
+    // CRITICAL: Do NOT assign visual order on selection
+    // Visual order is only assigned when badges are swapped via drag-and-drop
+    // This keeps selected badges in their original file position
+
     // Assign lowest available slot number
     final smallest = _availableSlots.reduce((a, b) => a < b ? a : b);
     _availableSlots.remove(smallest);
@@ -90,12 +147,15 @@ class BadgeSlotProvider with ChangeNotifier {
   void clearSelections() {
     _badgeKeyToSelectionOrder.clear();
     _badgeKeyToSlot.clear();
+    _badgeKeyToVisualOrder.clear();
     _availableSlots
       ..clear()
       ..addAll({1, 2, 3, 4, 5, 6, 7, 8});
     notifyListeners();
   }
 
+  int? getVisualOrder(String badgeKey) => _badgeKeyToVisualOrder[badgeKey];
+
   bool canTransfer(String badgeKey) {
     final slot = _badgeKeyToSlot[badgeKey];
     return slot != null && slot <= 8;

lib/view/widgets/saved_badge_listview.dart

@@ -174,8 +174,22 @@ class _BadgeListViewState extends State<BadgeListView> {
 
         return Consumer<BadgeSlotProvider>(
           builder: (context, slotProvider, _) {
-            // Keep badges in their original order - no sorting or rearrangement
-            final sortedBadges = allBadges;
+            // Create a list with both badge and its sort key (visual order if exists, else original index)
+            final badgesWithSortKey = <_BadgeWithSortKey>[];
+
+            for (int i = 0; i < allBadges.length; i++) {
+              final visualOrder = slotProvider.getVisualOrder(allBadges[i].key);
+              // Use visual order if it exists, otherwise use original file index
+              final sortKey = visualOrder ?? i;
+              badgesWithSortKey.add(_BadgeWithSortKey(allBadges[i], sortKey));
+            }
+
+            // Sort by sort key
+            badgesWithSortKey.sort((a, b) => a.sortKey.compareTo(b.sortKey));
+
+            // Build final result
+            final sortedBadges =
+                badgesWithSortKey.map((item) => item.badge).toList();
 
             return Padding(
               padding:
@@ -378,3 +392,10 @@ class _BadgeListViewState extends State<BadgeListView> {
     );
   }
 }
+
+class _BadgeWithSortKey {
+  final MapEntry<String, Map<String, dynamic>> badge;
+  final int sortKey;
+
+  _BadgeWithSortKey(this.badge, this.sortKey);
+}