// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:async';

/// This library helps run parallel thread-like closures asynchronously.
/// Borrowed from dartdoc:src/io_utils.dart.

Future<T> retryClosure<T>(Future<T> Function() closure,
    {Duration baseInterval = const Duration(milliseconds: 200),
    double factor = 2,
    int retries = 5}) async {
  Future<T> handleError(Object _) async {
    return await Future.delayed(
        baseInterval,
        () => retryClosure(closure,
            baseInterval: baseInterval * factor,
            factor: factor,
            retries: retries - 1));
  }

  if (retries > 0) {
    return await Future.sync(closure).catchError(handleError);
  } else {
    return closure();
  }
}

// TODO(jcollins-g): like SubprocessLauncher, merge with io_utils in dartdoc
// before cut-and-paste gets out of hand.
class MultiFutureTracker {
  /// Maximum number of simultaneously incomplete [Future]s.
  final int parallel;

  final Set<Future<void>> _trackedFutures = <Future<void>>{};

  MultiFutureTracker(this.parallel);

  /// Wait until fewer or equal to this many Futures are outstanding.
  Future<void> _waitUntil(int max) async {
    assert(_trackedFutures.length <= parallel);
    while (_trackedFutures.length > max) {
      await Future.any(_trackedFutures);
    }
  }

  /// Generates a [Future] from the given closure and adds it to the queue,
  /// once the queue is sufficiently empty.  The returned future completes
  /// when the generated [Future] has been added to the queue.
  Future<void> addFutureFromClosure(Future<void> Function() closure) async {
    assert(_trackedFutures.length <= parallel);
    // Can't use _waitUntil because we might not return directly to this
    // invocation of addFutureFromClosure.
    while (_trackedFutures.length > parallel - 1) {
      await Future.any(_trackedFutures);
    }
    Future<void> future = closure();
    _trackedFutures.add(future);
    future.then((f) => _trackedFutures.remove(future));
  }

  /// Generates a [Future] from the given closure and adds it to the queue,
  /// once the queue is sufficiently empty.  Completes when the generated
  /// closure completes.
  Future<T> runFutureFromClosure<T>(FutureOr<T>? Function() closure) async {
    Completer<T> futureComplete = Completer();
    await addFutureFromClosure(() async {
      futureComplete.complete(await closure());
    });
    return futureComplete.future;
  }

  /// Wait until all futures added so far have completed.
  Future<void> wait() => _waitUntil(0);
}