debounce.dart

import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:http/http.dart';
import 'package:native_http/native_http.dart';
import 'package:crypto/crypto.dart';

class DebounceHttpClient extends BaseClient {
  DebounceHttpClient(
    this.httpClient, {
    required this.duration,
  });

  final Client httpClient;
  final Duration duration;

  final Map<String, Timer?> _timers = {};
  final Map<String, Completer<StreamedResponse>> _completers = {};

  Future<void> _onSend(
    String hash,
    BaseRequest request,
  ) async {
    final response = await httpClient.send(request);
    final data = await response.stream.toBytes();
    // from now, a request can have multiple listeners
    _completers[hash]!.complete(
      StreamedResponse(
        Stream.fromIterable([data]).asBroadcastStream(),
        response.statusCode,
        contentLength: response.contentLength,
        request: request,
        headers: response.headers,
        isRedirect: response.isRedirect,
        persistentConnection: response.persistentConnection,
        reasonPhrase: response.reasonPhrase,
      ),
    );
  }

  @override
  Future<StreamedResponse> send(BaseRequest request) {
    // based on body, we should create a separed debounce experience
    final hash = _generateHash(request as Request);
    var completer = _completers[hash] ?? Completer();
    var timer = _timers[hash];

    completer = (completer.isCompleted) ? Completer() : completer;
    timer?.cancel();
    timer = Timer(duration, () => _onSend(hash, request));

    _completers[hash] = completer;
    _timers[hash] = timer;
    return completer.future;
  }

  String _generateHash(Request request) =>
      md5.convert(utf8.encode(request.body)).toString();
}