import 'package:dio/dio.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:get_it/get_it.dart';
import 'package:shared_preferences/shared_preferences.dart';
import '../api/api_client.dart';
import '../api/i_api_client.dart';
import '../storage/token_storage.dart';
import '../config/env.dart';
import '../notifications/local_notification_service.dart';
import '../../features/auth/data/auth_api.dart';
import '../../features/auth/data/auth_repository.dart';
import '../../features/auth/data/auth_repository_impl.dart';
import '../../features/auth/presentation/bloc/auth_bloc.dart';
import '../../features/auth/presentation/bloc/auth_event.dart';
import '../../features/calendar/data/calendar_api.dart';
import '../../features/calendar/data/services/calendar_service.dart';
import '../../features/calendar/reminders/reminder_action_executor.dart';
import '../../features/calendar/reminders/reminder_outbox_store.dart';
import '../../features/calendar/ui/calendar_state_manager.dart';
import '../../features/friends/data/friends_api.dart';
import '../../features/messages/data/inbox_api.dart';
import '../../features/settings/data/settings_api.dart';
import '../../features/users/data/users_api.dart';
import '../../features/todo/data/todo_api.dart';

final sl = GetIt.instance;

Future<void> configureDependencies() async {
  if (sl.isRegistered<IApiClient>()) {
    await sl.reset();
  }

  final SecureTokenStorage tokenStorage;

  final dio = Dio(BaseOptions(baseUrl: Env.apiUrl));
  tokenStorage = SecureTokenStorage(
    const FlutterSecureStorage(
      aOptions: AndroidOptions(encryptedSharedPreferences: true),
      iOptions: IOSOptions(
        accessibility: KeychainAccessibility.first_unlock_this_device,
      ),
    ),
  );
  final apiClient = ApiClient(
    baseUrl: Env.apiUrl,
    tokenStorage: tokenStorage,
    dio: dio,
  );

  sl.registerSingleton<IApiClient>(apiClient);

  final authApi = AuthApi(apiClient);
  sl.registerSingleton<AuthApi>(authApi);

  final sharedPreferences = await SharedPreferences.getInstance();
  sl.registerSingleton<SharedPreferences>(sharedPreferences);

  final usersApi = UsersApi(apiClient);
  sl.registerSingleton<UsersApi>(usersApi);

  final calendarApi = CalendarApi(apiClient);
  sl.registerSingleton<CalendarApi>(calendarApi);

  final calendarService = CalendarService(apiClient: apiClient);
  sl.registerSingleton<CalendarService>(calendarService);

  final reminderOutboxStore = ReminderOutboxStore(sharedPreferences);
  sl.registerSingleton<ReminderOutboxStore>(reminderOutboxStore);

  sl.registerSingleton<LocalNotificationService>(LocalNotificationService());

  final reminderActionExecutor = ReminderActionExecutor(
    calendarService: calendarService,
    notificationService: sl<LocalNotificationService>(),
    outboxStore: reminderOutboxStore,
  );
  sl.registerSingleton<ReminderActionExecutor>(reminderActionExecutor);

  final friendsApi = FriendsApi(apiClient);
  sl.registerSingleton<FriendsApi>(friendsApi);

  final settingsApi = SettingsApi(apiClient);
  sl.registerSingleton<SettingsApi>(settingsApi);

  final inboxApi = InboxApi(apiClient);
  sl.registerSingleton<InboxApi>(inboxApi);

  final todoApi = TodoApi(apiClient);
  sl.registerSingleton<TodoApi>(todoApi);

  final authRepository = AuthRepositoryImpl(
    api: authApi,
    tokenStorage: tokenStorage,
    onLogout: () async {
      apiClient.resetInterceptor();
    },
  );
  sl.registerSingleton<AuthRepository>(authRepository);

  final authBloc = AuthBloc(authRepository);
  sl.registerSingleton<AuthBloc>(authBloc);

  apiClient.setRefreshCallback((token) async {
    try {
      await authRepository.refreshSession(token);
      return true;
    } catch (_) {
      return false;
    }
  });

  apiClient.setAuthFailureCallback(() async {
    authBloc.add(
      const AuthSessionInvalidated(
        source: AuthInvalidationSource.unauthorized401,
      ),
    );
  });
  sl.registerSingleton<CalendarStateManager>(CalendarStateManager());
}