// Copyright (c) 2015, 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';
import 'dart:typed_data';

/// An interface for `StreamSink`-like classes to indicate whether adding data
/// would be buffered and when the buffer is empty again.
class BufferIndicator {
  final StreamController _controller = StreamController.broadcast(sync: true);

  /// A state variable indicating whether buffereing would occur at the moment.
  bool _wouldBuffer = true;

  /// Indicates whether calling [BufferedBytesWriter.add] would buffer the data
  /// if called.
  ///
  /// This can be used at a higher level as a way to do custom buffering and
  /// possibly prioritization.
  bool get wouldBuffer {
    return _wouldBuffer;
  }

  /// Signals that no buffering is happening at the moment.
  void markUnBuffered() {
    if (_wouldBuffer) {
      _wouldBuffer = false;
      _controller.add(null);
    }
  }

  /// Signals that buffering starts to happen.
  void markBuffered() {
    _wouldBuffer = true;
  }

  /// A broadcast stream notifying users that the [BufferedBytesWriter.add]
  /// method would not buffer the data if called.
  Stream get bufferEmptyEvents => _controller.stream;
}

/// Contains a [StreamSink] and a [BufferIndicator] to indicate whether writes
/// to the sink would cause buffering.
///
/// It uses the `pause signal` from the `sink.addStream()` as an indicator
/// whether the underlying stream cannot handle more data and would buffer.
class BufferedSink {
  /// The indicator whether the underlying sink is buffering at the moment.
  final bufferIndicator = BufferIndicator();

  /// A intermediate [StreamController] used to catch pause signals and to
  /// propagate the change via [bufferIndicator].
  final _controller = StreamController<List<int>>(sync: true);

  /// A future which completes once the sink has been closed.
  late final Future _doneFuture;

  BufferedSink(StreamSink<List<int>> dataSink) {
    bufferIndicator.markBuffered();

    _controller
      ..onListen = bufferIndicator.markUnBuffered
      ..onPause = bufferIndicator.markBuffered
      ..onResume = bufferIndicator.markUnBuffered
      ..onCancel = () {
        // TODO: We may want to propagate cancel events as errors.
        // Currently `_doneFuture` will just complete normally if the sink
        // cancelled.
      };
    _doneFuture =
        Future.wait([_controller.stream.pipe(dataSink), dataSink.done]);
  }

  /// The underlying sink.
  StreamSink<List<int>> get sink => _controller;

  /// The future which will complete once this sink has been closed.
  Future get doneFuture => _doneFuture;
}

/// A small wrapper around [BufferedSink] which writes data in batches.
class BufferedBytesWriter {
  /// A buffer which will be used for batching writes.
  final BytesBuilder _builder = BytesBuilder(copy: false);

  /// The underlying [BufferedSink].
  final BufferedSink _bufferedSink;

  BufferedBytesWriter(StreamSink<List<int>> outgoing)
      : _bufferedSink = BufferedSink(outgoing);

  /// An indicator whether the underlying sink is buffering at the moment.
  BufferIndicator get bufferIndicator => _bufferedSink.bufferIndicator;

  /// Adds [data] immediately to the underlying buffer.
  ///
  /// If there is buffered data which was added with [addBufferedData] and it
  /// has not been flushed with [flushBufferedData] an error will be thrown.
  void add(List<int> data) {
    if (_builder.length > 0) {
      throw StateError(
          'Cannot trigger an asynchronous write while there is buffered data.');
    }
    _bufferedSink.sink.add(data);
  }

  /// Queues up [bytes] to be written.
  void addBufferedData(List<int> bytes) {
    _builder.add(bytes);
  }

  /// Flushes all data which was enqueued by [addBufferedData].
  void flushBufferedData() {
    if (_builder.length > 0) {
      _bufferedSink.sink.add(_builder.takeBytes());
    }
  }

  /// Closes this sink.
  Future close() {
    flushBufferedData();
    return _bufferedSink.sink.close().whenComplete(() => doneFuture);
  }

  /// The future which will complete once this sink has been closed.
  Future get doneFuture => _bufferedSink.doneFuture;
}