immich/mobile/lib/utils/debounce.dart

import 'dart:async';

import 'package:flutter_hooks/flutter_hooks.dart';

/// Used to debounce function calls with the [interval] provided.
/// If [maxWaitTime] is provided, the first [run] call as well as the next call since [maxWaitTime] has passed will be immediately executed, even if [interval] is not satisfied.
class Debouncer {
  Debouncer({required this.interval, this.maxWaitTime});
  final Duration interval;
  final Duration? maxWaitTime;
  Timer? _timer;
  FutureOr<void> Function()? _lastAction;
  DateTime? _lastActionTime;
  Future<void>? _actionFuture;

  void run(FutureOr<void> Function() action) {
    _lastAction = action;
    _timer?.cancel();

    if (maxWaitTime != null &&
        // _actionFuture == null && // TODO: should this check be here?
        (_lastActionTime == null || DateTime.now().difference(_lastActionTime!) > maxWaitTime!)) {
      _callAndRest();
      return;
    }
    _timer = Timer(interval, _callAndRest);
  }

  Future<void>? drain() {
    if (_timer != null && _timer!.isActive) {
      _timer!.cancel();
      if (_lastAction != null) {
        _callAndRest();
      }
    }
    return _actionFuture;
  }

  @pragma('vm:prefer-inline')
  void _callAndRest() {
    _lastActionTime = DateTime.now();
    final action = _lastAction;
    _lastAction = null;

    final result = action!();
    if (result is Future) {
      _actionFuture = result.whenComplete(() {
        _actionFuture = null;
      });
    }
    _timer = null;
  }

  void dispose() {
    _timer?.cancel();
    _timer = null;
    _lastAction = null;
    _lastActionTime = null;
    _actionFuture = null;
  }

  bool get isActive => _actionFuture != null || (_timer != null && _timer!.isActive);
}

/// Creates a [Debouncer] that will be disposed automatically. If no [interval] is provided, a
/// default interval of 300ms is used to debounce the function calls
Debouncer useDebouncer({
  Duration interval = const Duration(milliseconds: 300),
  Duration? maxWaitTime,
  List<Object?>? keys,
}) => use(_DebouncerHook(interval: interval, maxWaitTime: maxWaitTime, keys: keys));

class _DebouncerHook extends Hook<Debouncer> {
  const _DebouncerHook({required this.interval, this.maxWaitTime, super.keys});

  final Duration interval;
  final Duration? maxWaitTime;

  @override
  HookState<Debouncer, Hook<Debouncer>> createState() => _DebouncerHookState();
}

class _DebouncerHookState extends HookState<Debouncer, _DebouncerHook> {
  late final debouncer = Debouncer(interval: hook.interval, maxWaitTime: hook.maxWaitTime);

  @override
  Debouncer build(_) => debouncer;

  @override
  void dispose() => debouncer.dispose();

  @override
  String get debugLabel => 'useDebouncer';
}