relatica/lib/di_initialization.dart

import 'package:logging/logging.dart';
import 'package:relatica/utils/active_profile_selector.dart';

import 'data/interfaces/connections_repo_intf.dart';
import 'data/interfaces/groups_repo.intf.dart';
import 'data/interfaces/hashtag_repo_intf.dart';
import 'data/memory/memory_groups_repo.dart';
import 'data/objectbox/objectbox_cache.dart';
import 'data/objectbox/objectbox_connections_repo.dart';
import 'data/objectbox/objectbox_hashtag_repo.dart';
import 'globals.dart';
import 'models/auth/profile.dart';
import 'services/auth_service.dart';
import 'services/connections_manager.dart';
import 'services/direct_message_service.dart';
import 'services/entry_manager_service.dart';
import 'services/gallery_service.dart';
import 'services/hashtag_service.dart';
import 'services/interactions_manager.dart';
import 'services/media_upload_attachment_helper.dart';
import 'services/network_status_service.dart';
import 'services/notifications_manager.dart';
import 'services/secrets_service.dart';
import 'services/setting_service.dart';
import 'services/timeline_manager.dart';

final _logger = Logger('DI_Init');

Future<void> dependencyInjectionInitialization() async {
  final entryManagerService = EntryManagerService();
  final timelineManager = TimelineManager();
  final galleryService = GalleryService();

  final settingsService = SettingsService();
  await settingsService.initialize();
  getIt.registerSingleton<SettingsService>(settingsService);
  getIt.registerLazySingleton<NetworkStatusService>(
      () => NetworkStatusService());

  getIt.registerSingleton<ActiveProfileSelector<IConnectionsRepo>>(
      ActiveProfileSelector(null));

  final secretsService = SecretsService();
  final serviceInit = await secretsService.initialize();
  final authService = AccountsService(secretsService);
  if (serviceInit.isFailure) {
    _logger.severe('Error initializing credentials');
  } else {
    await authService.initialize();
  }

  final objectBoxCache = await ObjectBoxCache.create();
  getIt.registerSingleton<ObjectBoxCache>(objectBoxCache);

  getIt.registerSingleton<IHashtagRepo>(ObjectBoxHashtagRepo());

  getIt.registerSingleton<ActiveProfileSelector<IGroupsRepo>>(
      ActiveProfileSelector((p) => MemoryGroupsRepo()));

  getIt.registerSingleton<ActiveProfileSelector<ConnectionsManager>>(
      ActiveProfileSelector(
    (p) => ConnectionsManager(
      getIt<ActiveProfileSelector<IConnectionsRepo>>().getForProfile(p).value,
      getIt<ActiveProfileSelector<IGroupsRepo>>().getForProfile(p).value,
    ),
  ));

  getIt.registerLazySingleton<HashtagService>(() => HashtagService());
  //TODO wrap it ActiveProfileSelector
  getIt.registerSingleton(galleryService);
  //TODO wrap it ActiveProfileSelector
  getIt.registerSingleton<EntryManagerService>(entryManagerService);
  getIt.registerSingleton<AccountsService>(authService);
  //TODO wrap it ActiveProfileSelector
  getIt.registerSingleton<TimelineManager>(timelineManager);
  getIt.registerLazySingleton<MediaUploadAttachmentHelper>(
      () => MediaUploadAttachmentHelper());
  getIt.registerLazySingleton<ActiveProfileSelector<NotificationsManager>>(
      () => ActiveProfileSelector((_) => NotificationsManager()));
  //TODO wrap it ActiveProfileSelector
  getIt.registerLazySingleton<DirectMessageService>(
      () => DirectMessageService());

  //TODO wrap it ActiveProfileSelector
  getIt.registerLazySingleton<InteractionsManager>(() => InteractionsManager());
}

Future<void> updateProfileDependencyInjectors(Profile profile) async {
  final objectBox = await ObjectBoxCache.create(
    baseDir: 'profileboxcaches',
    subDir: '${profile.username}_${profile.serverName}',
  );
  final connectionReposSelector =
      getIt<ActiveProfileSelector<IConnectionsRepo>>();
  connectionReposSelector.injectEntry(
      profile, ObjectBoxConnectionsRepo(objectBox));
}