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 '../../data/cache/cache_store.dart';
import '../../features/calendar/data/repositories/calendar_repository.dart';
import '../../features/contacts/data/repositories/friend_repository.dart';
import '../../features/messages/data/repositories/inbox_repository.dart';
import '../../core/inbox/inbox_sync_store.dart';
import '../../features/contacts/data/repositories/user_repository.dart';
import '../../core/auth/session_controller.dart';
import '../../data/network/api_client.dart';
import '../../data/network/i_api_client.dart';
import '../../data/storage/token_storage.dart';
import '../../core/config/env.dart';
import '../../features/auth/data/apis/auth_api.dart';
import '../../features/auth/data/repositories/auth_repository.dart';
import '../../features/auth/data/repositories/auth_repository_impl.dart';
import '../../features/auth/presentation/bloc/auth_bloc.dart';
import '../../features/auth/presentation/bloc/auth_event.dart';
import '../../features/chat/presentation/bloc/chat_bloc.dart';
import '../../core/chat/chat_api.dart';
import '../../core/chat/chat_history_repository.dart';
import '../../features/chat/data/apis/chat_api_impl.dart';
import '../../features/calendar/data/apis/calendar_api.dart';
import '../../features/calendar/data/services/calendar_service.dart';
import '../../shared/state/calendar_state_manager.dart';
import '../../features/contacts/data/apis/friends_api.dart';
import '../../features/messages/data/apis/inbox_api.dart';
import '../../features/settings/data/apis/settings_api.dart';
import '../../features/settings/data/apis/automation_jobs_api.dart';
import '../../features/settings/data/repositories/user_profile_cache_repository.dart';
import '../../features/settings/data/services/user_profile_service.dart';
import '../../features/settings/data/services/memory_service.dart';
import '../../features/contacts/data/apis/users_api.dart';
import '../../features/todo/data/apis/todo_api.dart';
import '../../features/todo/data/repositories/todo_repository.dart';
import '../services/app_prewarm_orchestrator.dart';
import '../services/session_scope_manager.dart';
import '../services/auth_session_controller.dart';
import '../../core/notification/services/reminder_scheduler_service.dart';
import '../../core/notification/services/reminder_permission_service.dart';
import '../../core/notification/services/reminder_reconcile_service.dart';
import '../../core/notification/services/reminder_notification_router.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 memoryCacheStore = MemoryCacheStore();
  final persistentCacheStore = PersistentCacheStore(prefs: sharedPreferences);
  final hybridCacheStore = HybridCacheStore(
    memory: memoryCacheStore,
    persistent: persistentCacheStore,
  );
  sl.registerSingleton<MemoryCacheStore>(memoryCacheStore);
  sl.registerSingleton<PersistentCacheStore>(persistentCacheStore);
  sl.registerSingleton<HybridCacheStore>(hybridCacheStore);
  sl.registerSingleton<SessionScopeManager>(
    SessionScopeManager(cacheStore: hybridCacheStore),
  );
  sl.registerSingleton<CacheInvalidator>(
    CacheInvalidator(store: hybridCacheStore),
  );

  final usersApi = UsersApi(apiClient);
  sl.registerSingleton<UsersApi>(usersApi);
  sl.registerSingleton<UserRepository>(UserRepositoryImpl(apiClient));
  final userProfileService = UserProfileService(apiClient);
  sl.registerSingleton<UserProfileService>(userProfileService);

  final userProfileCacheRepository = UserProfileCacheRepository(
    store: hybridCacheStore,
    remoteLoader: userProfileService.getMe,
  );
  sl.registerSingleton<UserProfileCacheRepository>(userProfileCacheRepository);

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

  final reminderScheduler = ReminderSchedulerService();
  sl.registerSingleton<ReminderSchedulerService>(reminderScheduler);
  sl.registerSingleton<ReminderPermissionService>(
    ReminderPermissionService(scheduler: reminderScheduler),
  );
  sl.registerSingleton<ReminderReconcileService>(
    ReminderReconcileService(scheduler: reminderScheduler),
  );
  sl.registerSingleton<ReminderNotificationRouter>(
    ReminderNotificationRouter(scheduler: reminderScheduler),
    dispose: (service) => service.dispose(),
  );

  final calendarService = CalendarService(
    apiClient: apiClient,
    invalidator: sl<CacheInvalidator>(),
    reminderReconcileService: sl<ReminderReconcileService>(),
  );
  sl.registerSingleton<CalendarService>(calendarService);

  final calendarRepository = CalendarRepository(
    store: hybridCacheStore,
    apiClient: apiClient,
    reminderReconcileService: sl<ReminderReconcileService>(),
  );
  sl.registerSingleton<CalendarRepository>(calendarRepository);

  final friendsApi = FriendsApi(apiClient);
  sl.registerSingleton<FriendsApi>(friendsApi);
  sl.registerSingleton<FriendRepository>(
    FriendRepositoryImpl(apiClient: apiClient, store: hybridCacheStore),
  );

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

  final automationJobsApi = AutomationJobsApi(apiClient);
  sl.registerSingleton<AutomationJobsApi>(automationJobsApi);

  final memoryService = MemoryService(apiClient);
  sl.registerSingleton<MemoryService>(memoryService);

  final inboxApi = InboxApi(apiClient);
  sl.registerSingleton<InboxApi>(inboxApi);
  final inboxRepository = InboxRepositoryImpl(
    apiClient: apiClient,
    store: hybridCacheStore,
  );
  sl.registerSingleton<InboxRepository>(inboxRepository);
  sl.registerSingleton<InboxSyncStore>(
    InboxSyncStore(repository: inboxRepository, inboxApi: inboxApi),
    dispose: (store) => store.dispose(),
  );

  final chatApi = ChatApiImpl(apiClient);
  sl.registerSingleton<ChatApi>(chatApi);

  final chatHistoryRepository = ChatHistoryRepository(
    chatApi: chatApi,
    store: hybridCacheStore,
  );
  sl.registerSingleton<ChatHistoryRepository>(chatHistoryRepository);

  final todoApi = TodoApi(apiClient);
  sl.registerSingleton<TodoApi>(todoApi);
  sl.registerSingleton<TodoRepository>(
    TodoRepository(
      api: todoApi,
      store: hybridCacheStore,
      invalidator: sl<CacheInvalidator>(),
    ),
  );

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

  sl.registerSingleton<AppPrewarmOrchestrator>(
    AppPrewarmOrchestrator(
      calendarRepository: calendarRepository,
      inboxRepository: sl<InboxRepository>(),
      chatHistoryRepository: chatHistoryRepository,
    ),
  );

  final authBloc = AuthBloc(authRepository);
  sl.registerSingleton<AuthBloc>(authBloc);
  sl.registerSingleton<SessionController>(AuthSessionController(authBloc));
  sl.registerSingleton<ChatBloc>(
    ChatBloc(
      chatApi: chatApi,
      historyRepository: chatHistoryRepository,
      onCalendarMutated: () async {
        final calendarRepository = sl<CalendarRepository>();
        final selected = sl<CalendarStateManager>().selectedDate;
        await Future.wait([
          calendarRepository.getDayEvents(selected, forceRefresh: true),
          calendarRepository.getMonthEvents(
            DateTime(selected.year, selected.month, 1),
            forceRefresh: true,
          ),
        ]);
      },
    ),
  );

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

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