flutter_paging_viewmodel_example_1

class LocationViewModel extends StateNotifier<AsyncValue<List<Destination>>> {
  final List<Destination> initialLocations;
  final String employeeId;
  final int year;
  final int month;
  final int day;
  final String shift;

  LocationViewModel({
    required this.initialLocations,
    required this.employeeId,
    required this.year,
    required this.month,
    required this.day,
    required this.shift,
  }) : super(const AsyncValue.loading()) {
    _fetchLocations();
  }

  String _searchTerm = '';
  List<Destination> _locations = [];

  // Getter for the selected locations
  List<Destination> get selectedLocations => initialLocations;

  // Method to fetch locations
  Future<void> _fetchLocations() async {
    try {
      state = const AsyncValue.loading();
      final response = await TourPlanRepository.instance.getTourPlanLocation(employeeId, year, month, day, shift);
      final locations = response.data ?? [];
      _locations = locations
          .map((destination) => destination.copyWith(
        selected: initialLocations.any((des) => des.placeKey == destination.placeKey),
      )).toList();

      state = AsyncValue.data(_locations);
    } catch (e, stackTrace) {
      state = AsyncValue.error(e, stackTrace);
    }
  }

  // Method to update the search term
  void updateSearchTerm(String term) {
    _searchTerm = term.trim();
    state = AsyncValue.data(_filterLocations());
  }

  // Method to toggle the selection of a location
  void toggleSelection(Destination location) {
    final index = _locations.indexWhere((des) => des.placeKey == location.placeKey);
    if (index != -1) {
      final isSelected = _locations[index].selected;
      // Update the main list
      _locations[index] = _locations[index].copyWith(selected: !isSelected);

      // Update the selected list
      if (isSelected) {
        initialLocations.removeWhere((des) => des.placeKey == location.placeKey);
      } else {
        initialLocations.add(_locations[index]);
      }

      // Update state without resetting the filtered list
      state = AsyncValue.data(_filterLocations());
    }
  }


  // Method to filter locations based on search term
  List<Destination> _filterLocations() {
    return _locations.where((des) {
      return des.place?.name?.toLowerCase().contains(_searchTerm.toLowerCase()) ?? false;
    }).toList();
  }
}

final locationViewModelProvider =
    StateNotifierProvider.family.autoDispose<LocationViewModel, AsyncValue<List<Destination>>, LocationQueryParams>(
  (ref, params) => LocationViewModel(
    initialLocations: params.initialLocations,
    employeeId: params.employeeId,
    year: params.year,
    month: params.month,
    day: params.day,
    shift: params.shift,
  ),
);

// --------------------------------------------------

class LocationViewModel extends StateNotifier<PagingState<int, Destination>> {
  final String employeeId;
  final int year;
  final int month;
  final int day;
  final String shift;

  final Debouncer _debounce = Debouncer();

  late final List<Destination> _selectedLocations;

  Set<String?> get _selectedKeys =>
      _selectedLocations.map((e) => e.placeKey).toSet();

  String? _searchTerm;

  LocationViewModel({
    required List<Destination> initialLocations,
    required this.employeeId,
    required this.year,
    required this.month,
    required this.day,
    required this.shift,
  }) : super(PagingState()) {
    _selectedLocations = List.from(initialLocations);
  }

  List<Destination> get selectedLocations => _selectedLocations;

  /// Fetches the next page of data
  Future<void> fetchNextPage() async {
    if (state.isLoading) return;

    state = state.copyWith(isLoading: true, error: null);

    try {
      final newKey = state.keys?.last == null ? 0 : state.keys!.last + 1;
      final response = await TourPlanRepository.instance.getTourPlanLocation(
        employeeId,
        year,
        month,
        day,
        shift,
        _searchTerm,
        newKey,
      );
      final locations = response.data?.content ?? [];

      final newItems = locations.map((location) {
        return location.copyWith(
          selected: _selectedKeys.contains(location.placeKey),
        );
      }).toList();

      state = state.copyWith(
        pages: [...?state.pages, newItems],
        keys: [...?state.keys, newKey],
        hasNextPage: response.data?.hasNext,
        isLoading: false,
      );
    } catch (error) {
      state = state.copyWith(error: error, isLoading: false);
    }
  }

  /// Updates search term and refreshes the list
  void updateSearchTerm(String searchTerm) {
    _searchTerm = searchTerm;
    _debounce.run(refreshList);
  }

  /// Clear search and refreshes the list
  void clearSearchTerm() {
    _searchTerm = null;
    _debounce.run(refreshList);
  }

  /// Refreshes the list and fetches the first page
  void refreshList() {
    state = PagingState();
    fetchNextPage();
  }

  /// Method to toggle the selection of a location
  void toggleSelection(Destination destination) {
    final isSelected = !destination.selected;

    final updatedPages = state.pages?.map((page) {
      return page.map((loc) {
        if (loc.placeKey == destination.placeKey) {
          return loc.copyWith(selected: isSelected);
        }
        return loc;
      }).toList();
    }).toList();

    state = state.copyWith(pages: updatedPages);

    // Update internal selected list
    if (isSelected) {
      _selectedLocations.add(destination.copyWith(selected: true));
    } else {
      _selectedLocations.removeWhere((e) => e.placeKey == destination.placeKey);
    }
  }
}

final locationViewModelProvider = StateNotifierProvider.family
    .autoDispose<
      LocationViewModel,
      PagingState<int, Destination>,
      LocationQueryParams
    >(
      (ref, params) => LocationViewModel(
        initialLocations: params.initialLocations,
        employeeId: params.employeeId,
        year: params.year,
        month: params.month,
        day: params.day,
        shift: params.shift,
      ),
    );


// --------------------------------------------------

class LocationViewModel extends StateNotifier<AsyncValue<List<Places>>> {
  final List<Places> initialLocations;
  final String employeeId;
  final int year;
  final int month;
  final Debouncer _debounce = Debouncer();
  String _searchTerm = '';

  LocationViewModel({
    required this.initialLocations,
    required this.employeeId,
    required this.year,
    required this.month,
  }) : super(const AsyncValue.loading()) {
    _fetchLocations();
  }

  String get searchTerm => _searchTerm;

  // Method to fetch locations from the API based on the search term
  Future<void> _fetchLocations() async {
    try {
      state = const AsyncValue.loading();
      final response = await TourPlanRepository.instance.getTourPlanLocation(employeeId, year, month);
      final locations = response.data ?? [];

      // Update the state with the new list of places
      state = AsyncValue.data(
        locations.map((location) {
          return location.copyWith(
            selected: initialLocations.any((loc) => loc.id == location.id),
          );
        }).toList(),
      );
    } catch (e, stackTrace) {
      state = AsyncValue.error(e, stackTrace);
    }
  }

  // Method to update the search term with debounce
  void updateSearchTerm(String term) {
    _searchTerm = term.trim();

    _debounce.run(() {
      _fetchLocations();
    });
  }

  // Method to toggle the selection of a location
  void toggleSelection(Places location) {
    final locations = state.value ?? [];

    final index = locations.indexWhere((l) => l.id == location.id);
    if (index == -1) return;

    final isSelected = locations[index].selected;
    final updatedLocation = locations[index].copyWith(selected: !isSelected);

    locations[index] = updatedLocation;

    state = AsyncValue.data(locations);

    if (isSelected) {
      initialLocations.removeWhere((l) => l.id == location.id);
    } else {
      initialLocations.add(updatedLocation);
    }
  }

  // Getter for the selected locations
  List<Places> get selectedLocations => initialLocations;
}

final locationViewModelProvider =
    StateNotifierProvider.family.autoDispose<LocationViewModel, AsyncValue<List<Places>>, LocationQueryParams>(
  (ref, params) => LocationViewModel(
    initialLocations: params.initialLocations,
    employeeId: params.employeeId,
    year: params.year,
    month: params.month,
  ),
);