pruebas_api_provider.dart

import 'package:miningtrackerapp/domain/entities/prueba.dart';
import 'package:miningtrackerapp/presentation/providers/pruebas/pruebas_repository_provider.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

/// PROVIDERS ==================================================================

// 1
final providerPruebasList =
    StateNotifierProvider<PruebasListNotifier, List<Prueba>>((ref) {
  final getPruebasList = ref.watch(pruebasRepositoryProvider).getPruebasList;

  return PruebasListNotifier(fetchPruebasList: getPruebasList);
});


// 2
final providerPruebasGetById =
    StateNotifierProvider.autoDispose<PruebasNotifier, Map<String, Prueba>>(
        (ref) {
  final getPrueba = ref.watch(pruebasRepositoryProvider).getPruebaItemById;
  return PruebasNotifier(getPrueba: getPrueba);
});

// 3
final providerPruebasSaveItem =
    StateNotifierProvider<SavePruebaNotifier, void>((ref) {
  final savePrueba = ref.watch(pruebasRepositoryProvider).savePrueba;
  return SavePruebaNotifier(savePruebaDB: savePrueba);
});

// 4
final providerPruebasDeleteItem =
    StateNotifierProvider<DeletePruebaNotifier, void>((ref) {
  final deletePrueba = ref.watch(pruebasRepositoryProvider).deletePrueba;
  return DeletePruebaNotifier(deletePruebaDB: deletePrueba);
});


/// STATE NOTIFIER =============================================================

// 1
typedef GetPruebasListCallback = Future<List<Prueba>> Function();
class PruebasListNotifier extends StateNotifier<List<Prueba>> {
  bool isLoading = false;
  GetPruebasListCallback fetchPruebasList;

  PruebasListNotifier({required this.fetchPruebasList}) : super([]);

  Future<void> loadPruebasList() async {
    if (isLoading) return;
    isLoading = true;

    final List<Prueba> pruebas = await fetchPruebasList();

    state = pruebas;

    // provide some 'rendering time' for the new movies
    await Future.delayed(const Duration(milliseconds: 300));
    isLoading = false;
  }

  Future<void> updatePruebasList() async {
    final List<Prueba> pruebas = await fetchPruebasList();

    state = pruebas;

    // provide some 'rendering time' for the new movies
    await Future.delayed(const Duration(milliseconds: 300));
    isLoading = false;
  }
}

//  2
typedef GetPruebaCallback = Future<Prueba> Function(String pruebaId);

class PruebasNotifier extends StateNotifier<Map<String, Prueba>> {
  final GetPruebaCallback getPrueba;

  PruebasNotifier({required this.getPrueba}) : super({});

  Future<void> loadPrueba(String currentPrueba) async {
    if (state[currentPrueba] != null) return;

    final Prueba prueba = await getPrueba(currentPrueba);

    state = {...state, currentPrueba: prueba};
  }
}

// 3
typedef SavePruebaCallback = Future<void> Function(Prueba prueba);
class SavePruebaNotifier extends StateNotifier<void> {
  SavePruebaCallback savePruebaDB;

  SavePruebaNotifier({required this.savePruebaDB}) : super([]);

  Future<void> savePrueba(Prueba prueba) async {
    await savePruebaDB(prueba);
    await Future.delayed(const Duration(milliseconds: 300));
  }
}

// 4
typedef DeletePruebaCallback = Future<int?> Function(int id);
class DeletePruebaNotifier extends StateNotifier<void> {
  DeletePruebaCallback deletePruebaDB;

  DeletePruebaNotifier({required this.deletePruebaDB}) : super([]);

  Future<void> deletePrueba(int pruebaId) async {
    await deletePruebaDB(pruebaId);
    await Future.delayed(const Duration(milliseconds: 300));
  }
}