relatica/lib/riverpod_controllers/circles_repo_services.dart

import 'package:logging/logging.dart';
import 'package:result_monad/result_monad.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

import '../data/interfaces/circles_repo_intf.dart';
import '../data/memory/memory_circles_repo.dart';
import '../friendica_client/friendica_client.dart';
import '../models/auth/profile.dart';
import '../models/connection.dart';
import '../models/exec_error.dart';
import '../models/timeline_grouping_list_data.dart';

part 'circles_repo_services.g.dart';

final _crLogger = Logger('CirclesRepoProvider');

@Riverpod(keepAlive: true)
class CirclesRepo extends _$CirclesRepo {
  late Profile userProfile;

  @override
  ICirclesRepo build(Profile profile) {
    _crLogger.info('Creating for $profile');
    userProfile = profile;
    return MemoryCirclesRepo();
  }

  Future<void> refreshCircleData() async {
    _crLogger.info('Refreshing member circle data ');
    await TimelineGroupingListClient(profile)
        .getTimelineGroupingListData()
        .match(
      onSuccess: (circles) {
        state.addAllCircles(circles);
      },
      onError: (error) {
        _crLogger.severe('Error getting list data: $error');
      },
    );
  }
}

final _cpLogger = Logger('CirclesProvider');

@Riverpod(keepAlive: true)
class Circles extends _$Circles {
  late Profile userProfile;

  @override
  List<TimelineGroupingListData> build(Profile profile) {
    _cpLogger.info('Creating for $profile');
    userProfile = profile;
    final circles = ref.watch(circlesRepoProvider(userProfile)).getMyCircles();
    if (circles.isEmpty) {
      Future.delayed(const Duration(milliseconds: 1), refresh);
    }
    return circles;
  }

  Future<void> refresh() async {
    _cpLogger.info('Refreshing cicrles provider');
    await ref
        .read(circlesRepoProvider(userProfile).notifier)
        .refreshCircleData();
    ref.invalidateSelf();
  }

  void upsertCircle(TimelineGroupingListData circle) {
    ref.read(circlesRepoProvider(userProfile)).upsertCircle(circle);
    ref.invalidateSelf();
  }

  void deleteCircle(TimelineGroupingListData circle) {
    ref.read(circlesRepoProvider(userProfile)).deleteCircle(circle);
    ref.invalidateSelf();
  }

  void clear() {
    ref.read(circlesRepoProvider(userProfile)).clear();
    ref.invalidateSelf();
  }

  void addAllCircles(List<TimelineGroupingListData> circles) {
    ref.read(circlesRepoProvider(userProfile)).addAllCircles(circles);
    ref.invalidateSelf();
  }

  void addConnectionToCircle(
      TimelineGroupingListData circle, Connection connection) {
    ref
        .read(circlesRepoProvider(userProfile))
        .addConnectionToCircle(circle, connection);
    ref.invalidateSelf();
  }

  Result<List<Connection>, ExecError> getCircleMembers(
          TimelineGroupingListData circle) =>
      ref.read(circlesRepoProvider(userProfile)).getCircleMembers(circle);

  Result<List<TimelineGroupingListData>, ExecError> getCirclesForUser(
          String id) =>
      ref.read(circlesRepoProvider(userProfile)).getCirclesForUser(id);

  bool updateConnectionCircleData(
          String id, List<TimelineGroupingListData> currentCircless) =>
      ref
          .read(circlesRepoProvider(userProfile))
          .updateConnectionCircleData(id, currentCircless);
}

final _tglLogger = Logger('TimelineGroupingListProvider');

@Riverpod(keepAlive: true)
List<TimelineGroupingListData> timelineGroupingList(
    TimelineGroupingListRef ref, Profile profile, GroupingType type) {
  _tglLogger.info('Creating for $type for $profile');
  final circles = ref.watch(circlesProvider(profile));
  final result = circles.where((e) => e.groupingType == type).toList();
  result.sort((g1, g2) => g1.name.compareTo(g2.name));
  return result;
}