// Copyright (c) 2013, 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.

library scheduled_test.stream_matcher;

import 'dart:async';
import 'dart:collection';

import '../scheduled_stream.dart';
import '../scheduled_test.dart';
import 'utils.dart';

/// An abstract superclass for matchers that validate and consume zero or more
/// values emitted by a [ScheduledStream].
///
/// [StreamMatcher]s are most commonly used by passing them to
/// [ScheduledStream.expect].
abstract class StreamMatcher {
  /// Wrap a [Matcher], [StreamMatcher] or [Object] in a [StreamMatcher].
  ///
  /// If this isn't a [StreamMatcher], a [nextValue] matcher is used.
  factory StreamMatcher.wrap(matcher) =>
      matcher is StreamMatcher ? matcher : nextValue(matcher);

  StreamMatcher();

  /// Tries to match [this] against [stream].
  ///
  /// If the match succeeds, this returns `null`. If it fails, this returns a
  /// [Description] describing the failure.
  Future<Description> tryMatch(ScheduledStream stream);

  /// Returns whether [this] would match [stream] without actually consuming
  /// values from [stream].
  ///
  /// If the match succeeds, this returns `null`. If it fails, this returns a
  /// [Description] describing the failure.
  Future<Description> hasMatch(ScheduledStream stream) {
    var fork = stream.fork();
    return tryMatch(fork).whenComplete(fork.close);
  }

  String toString();
}

/// A matcher that consumes and matches a single value.
///
/// [matcher] can be a [Matcher] or an [Object], but not a [StreamMatcher].
StreamMatcher nextValue(matcher) => new _NextValueMatcher(matcher);

/// A matcher that consumes [n] values and matches a list containing those
/// objects against [matcher].
///
/// [matcher] can be a [Matcher] or an [Object], but not a [StreamMatcher].
StreamMatcher nextValues(int n, matcher) => new _NextValuesMatcher(n, matcher);

/// A matcher that matches several sub-matchers in sequence.
///
/// Each element of [streamMatchers] can be a [StreamMatcher], a [Matcher], or
/// an [Object].
StreamMatcher inOrder(Iterable streamMatchers) {
  streamMatchers = streamMatchers.toList();
  if (streamMatchers.length == 1) {
    return new StreamMatcher.wrap(streamMatchers.first);
  } else {
    return new _InOrderMatcher(streamMatchers);
  }
}

/// A matcher that consumes values emitted by a stream until one matching
/// [streamMatcher] is emitted.
///
/// This will fail if the stream never emits a value that matches
/// [streamMatcher].
///
/// [streamMatcher] can be a [StreamMatcher], a [Matcher] or an [Object].
StreamMatcher consumeThrough(streamMatcher) =>
    new _ConsumeThroughMatcher(streamMatcher);

/// A matcher that consumes values emitted by a stream as long as they match
/// [streamMatcher].
///
/// This matcher will always match a stream. It exists to consume values. If
/// [streamMatcher] consumes more than one value, the next match will begin
/// after all the consumed values.
///
/// [streamMatcher] can be a [StreamMatcher], a [Matcher] or an [Object].
StreamMatcher consumeWhile(streamMatcher) =>
    new _ConsumeWhileMatcher(streamMatcher);

/// A matcher that matches either [streamMatcher1], [streamMatcher2], or both.
///
/// If both matchers match the stream, the one that consumed more values will be
/// used.
///
/// Both [streamMatcher1] and [streamMatcher2] can be a [StreamMatcher], a
/// [Matcher], or an [Object].
StreamMatcher either(streamMatcher1, streamMatcher2) =>
  new _EitherMatcher(streamMatcher1, streamMatcher2);

/// A matcher that consumes [streamMatcher] if it matches, or nothing otherwise.
///
/// This matcher will always match a stream. It exists to consume values that
/// may or may not be emitted by a stream.
///
/// [streamMatcher] can be a [StreamMatcher], a [Matcher], or an [Object].
StreamMatcher allow(streamMatcher) => new _AllowMatcher(streamMatcher);

/// A matcher that asserts that a stream never emits values matching
/// [streamMatcher].
///
/// This will consume the remainder of a stream.
///
/// [streamMatcher] can be a [StreamMatcher], a [Matcher], or an [Object].
StreamMatcher never(streamMatcher) => new _NeverMatcher(streamMatcher);

/// A matcher that matches a stream that emits no more values.
StreamMatcher get isDone => new _IsDoneMatcher();

/// See [nextValue].
class _NextValueMatcher extends StreamMatcher {
  final Matcher _matcher;

  _NextValueMatcher(matcher)
      : _matcher = wrapMatcher(matcher);

  Future<Description> tryMatch(ScheduledStream stream) {
    return stream.hasNext.then((hasNext) {
      if (!hasNext) {
        return new StringDescription("unexpected end of stream");
      }
      return stream.next().then((value) {
        var matchState = {};
        if (_matcher.matches(value, matchState)) return null;
        return _matcher.describeMismatch(value, new StringDescription(),
            matchState, false);
      });
    });
  }

  String toString() => _matcher.describe(new StringDescription()).toString();
}

/// See [nextValues].
class _NextValuesMatcher extends StreamMatcher {
  final int _n;
  final Matcher _matcher;

  _NextValuesMatcher(this._n, matcher)
      : _matcher = wrapMatcher(matcher);

  Future<Description> tryMatch(ScheduledStream stream) {
    var collectedValues = [];
    collectValues(count) {
      if (count == 0) return null;

      return stream.hasNext.then((hasNext) {
        if (!hasNext) return new StringDescription('unexpected end of stream');

        return stream.next().then((value) {
          collectedValues.add(value);
          return collectValues(count - 1);
        });
      });
    }

    return collectValues(_n).then((failure) {
      if (failure != null) return failure;
      var matchState = {};
      if (_matcher.matches(collectedValues, matchState)) return null;
      return _matcher.describeMismatch(collectedValues, new StringDescription(),
          matchState, false);
    });
  }

  String toString() {
    return new StringDescription('$_n values that ')
        .addDescriptionOf(_matcher)
        .toString();
  }
}

/// See [inOrder].
class _InOrderMatcher extends StreamMatcher {
  final List<StreamMatcher> _matchers;

  _InOrderMatcher(Iterable streamMatchers)
      : _matchers = streamMatchers.map((matcher) =>
          new StreamMatcher.wrap(matcher)).toList();

  Future<Description> tryMatch(ScheduledStream stream) {
    var matchers = new Queue.from(_matchers);

    matchNext() {
      if (matchers.isEmpty) return new Future.value();
      var matcher = matchers.removeFirst();
      return matcher.tryMatch(stream).then((failure) {
        if (failure == null) return matchNext();
        var newFailure = new StringDescription(
              'matcher #${_matchers.length - matchers.length} failed');
        if (failure.length != 0) newFailure.add(':\n$failure');
        return newFailure;
      });
    }

    return matchNext();
  }

  String toString() => _matchers
      .map((matcher) => prefixLines(matcher.toString(), firstPrefix: '* '))
      .join('\n');
}

/// See [consumeThrough].
class _ConsumeThroughMatcher extends StreamMatcher {
  final StreamMatcher _matcher;

  _ConsumeThroughMatcher(streamMatcher)
      : _matcher = new StreamMatcher.wrap(streamMatcher);

  Future<Description> tryMatch(ScheduledStream stream) {
    consumeNext() {
      return stream.hasNext.then((hasNext) {
        if (!hasNext) return new StringDescription("unexpected end of stream");

        return _matcher.hasMatch(stream).then((failure) {
          if (failure != null) return stream.next().then((_) => consumeNext());
          return _matcher.tryMatch(stream);
        });
      });
    }

    return consumeNext();
  }

  String toString() {
    var matcherString = _matcher.toString();
    if (matcherString.contains("\n")) {
      return 'values followed by:\n' + prefixLines(matcherString, prefix: '  ');
    } else {
      return 'values followed by $matcherString';
    }
  }
}

/// See [consumeWhile].
class _ConsumeWhileMatcher extends StreamMatcher {
  final StreamMatcher _matcher;

  _ConsumeWhileMatcher(matcher)
      : _matcher = new StreamMatcher.wrap(matcher);

  Future<Description> tryMatch(ScheduledStream stream) {
    consumeNext() {
      return stream.hasNext.then((hasNext) {
        if (!hasNext) return new Future.value();

        return _matcher.hasMatch(stream).then((failure) {
          if (failure != null) return new Future.value();
          return _matcher.tryMatch(stream).then((_) => consumeNext());
        });
      });
    }

    return consumeNext();
  }

  String toString() {
    var matcherString = _matcher.toString();
    if (matcherString.contains("\n")) {
      return 'any number of\n' + prefixLines(matcherString, prefix: '  ');
    } else {
      return 'any number of $matcherString';
    }
  }
}

/// See [either].
class _EitherMatcher extends StreamMatcher {
  final StreamMatcher _matcher1;
  final StreamMatcher _matcher2;

  _EitherMatcher(streamMatcher1, streamMatcher2)
      : _matcher1 = new StreamMatcher.wrap(streamMatcher1),
        _matcher2 = new StreamMatcher.wrap(streamMatcher2);

  Future<Description> tryMatch(ScheduledStream stream) {
    var stream1 = stream.fork();
    var stream2 = stream.fork();

    return Future.wait([
      _matcher1.tryMatch(stream1).whenComplete(stream1.close),
      _matcher2.tryMatch(stream2).whenComplete(stream2.close)
    ]).then((failures) {
      var failure1 = failures.first;
      var failure2 = failures.last;

      // If both matchers matched, use the one that consumed more of the stream.
      if (failure1 == null && failure2 == null) {
        if (stream1.emittedValues.length >= stream2.emittedValues.length) {
          return _matcher1.tryMatch(stream);
        } else {
          return _matcher2.tryMatch(stream);
        }
      } else if (failure1 == null) {
        return _matcher1.tryMatch(stream);
      } else if (failure2 == null) {
        return _matcher2.tryMatch(stream);
      } else {
        return new StringDescription('both\n')
            .add(prefixLines(failure1.toString(), prefix: '  '))
            .add('\nand\n')
            .add(prefixLines(failure2.toString(), prefix: '  '))
            .toString();
      }
    });
  }

  String toString() {
    return new StringDescription('either\n')
        .add(prefixLines(_matcher1.toString(), prefix: '  '))
        .add('\nor\n')
        .add(prefixLines(_matcher2.toString(), prefix: '  '))
        .toString();
  }
}

/// See [allow].
class _AllowMatcher extends StreamMatcher {
  final StreamMatcher _matcher;

  _AllowMatcher(streamMatcher)
      : _matcher = new StreamMatcher.wrap(streamMatcher);

  Future<Description> tryMatch(ScheduledStream stream) {
    return _matcher.hasMatch(stream).then((failure) {
      if (failure != null) return null;
      return _matcher.tryMatch(stream);
    });
  }

  String toString() {
    return new StringDescription('allow\n')
        .add(prefixLines(_matcher.toString()))
        .toString();
  }
}

/// See [never].
class _NeverMatcher extends StreamMatcher {
  final StreamMatcher _matcher;

  _NeverMatcher(streamMatcher)
    : _matcher = new StreamMatcher.wrap(streamMatcher);

  Future<Description> tryMatch(ScheduledStream stream) {
    consumeNext() {
      return stream.hasNext.then((hasNext) {
        if (!hasNext) return new Future.value();

        return _matcher.hasMatch(stream).then((failure) {
          if (failure != null) {
            return stream.next().then((_) => consumeNext());
          }

          return new StringDescription("matched\n")
              .add(prefixLines(_matcher.toString(), prefix: '  '));
        });
      });
    }

    return consumeNext();
  }

  String toString() =>
    'never\n${prefixLines(_matcher.toString(), prefix: '  ')}';
}

/// See [isDone].
class _IsDoneMatcher extends StreamMatcher {
  _IsDoneMatcher();

  Future<Description> tryMatch(ScheduledStream stream) {
    return stream.hasNext.then((hasNext) {
      if (!hasNext) return null;
      return new StringDescription("stream wasn't finished");
    });
  }

  String toString() => 'is done';
}

/// Returns a [Future] that completes to the next value emitted by [stream]
/// without actually consuming that value.
Future _peek(ScheduledStream stream) {
  var fork = stream.fork();
  return fork.next().whenComplete(fork.close);
}