// Copyright (c) 2022, 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 '../../context.dart';

import '../collection_equality.dart';
import 'core.dart';

extension IterableChecks<T> on Subject<Iterable<T>> {
  Subject<int> get length => has((l) => l.length, 'length');

  Subject<T> get first => context.nest(() => ['has first element'], (actual) {
        final iterator = actual.iterator;
        if (!iterator.moveNext()) {
          return Extracted.rejection(which: ['has no elements']);
        }
        return Extracted.value(iterator.current);
      });

  Subject<T> get last => context.nest(() => ['has last element'], (actual) {
        final iterator = actual.iterator;
        if (!iterator.moveNext()) {
          return Extracted.rejection(which: ['has no elements']);
        }
        var current = iterator.current;
        while (iterator.moveNext()) {
          current = iterator.current;
        }
        return Extracted.value(current);
      });

  Subject<T> get single => context.nest(() => ['has single element'], (actual) {
        final iterator = actual.iterator;
        if (!iterator.moveNext()) {
          return Extracted.rejection(which: ['has no elements']);
        }
        final value = iterator.current;
        if (iterator.moveNext()) {
          return Extracted.rejection(which: ['has more than one element']);
        }
        return Extracted.value(value);
      });

  void isEmpty() {
    context.expect(() => const ['is empty'], (actual) {
      if (actual.isEmpty) return null;
      return Rejection(which: ['is not empty']);
    });
  }

  void isNotEmpty() {
    context.expect(() => const ['is not empty'], (actual) {
      if (actual.isNotEmpty) return null;
      return Rejection(which: ['is empty']);
    });
  }

  /// Expects that the iterable contains [element] according to
  /// [Iterable.contains].
  void contains(T element) {
    context.expect(() {
      return prefixFirst('contains ', literal(element));
    }, (actual) {
      if (actual.isEmpty) return Rejection(actual: ['an empty iterable']);
      if (actual.contains(element)) return null;
      return Rejection(
          which: prefixFirst('does not contain ', literal(element)));
    });
  }

  /// Expects that the iterable contains a value matching each expected value
  /// from [elements] in the given order, with any extra elements between
  /// them.
  ///
  /// For example, the following will succeed:
  ///
  /// ```dart
  /// check([1, 0, 2, 0, 3]).containsInOrder([1, 2, 3]);
  /// ```
  ///
  /// Values in [elements] may be a `T`, a `Condition<T>`, or a
  /// `Condition<Object?>`. If an expectation is a condition callback it will be
  /// checked against the actual values, and any other expectations, including
  /// those that are not a `T` or a condition callback, will be compared with
  /// the equality operator.
  ///
  /// ```dart
  /// check([1, 0, 2, 0, 3])
  ///   .containsInOrder([1, (Subject<int> v) => v.isGreaterThan(1), 3]);
  /// ```
  @Deprecated('Use `containsEqualInOrder` for expectations with values compared'
      ' with `==` or `containsMatchingInOrder` for other expectations')
  void containsInOrder(Iterable<Object?> elements) {
    context.expect(() => prefixFirst('contains, in order: ', literal(elements)),
        (actual) {
      final expected = elements.toList();
      if (expected.isEmpty) {
        throw ArgumentError('expected may not be empty');
      }
      var expectedIndex = 0;
      for (final element in actual) {
        final currentExpected = expected[expectedIndex];
        final matches = currentExpected is Condition<T>
            ? softCheck(element, currentExpected) == null
            : currentExpected is Condition<dynamic>
                ? softCheck(element, currentExpected) == null
                : currentExpected == element;
        if (matches && ++expectedIndex >= expected.length) return null;
      }
      return Rejection(which: [
        ...prefixFirst(
            'did not have an element matching the expectation at index '
            '$expectedIndex ',
            literal(expected[expectedIndex])),
      ]);
    });
  }

  /// Expects that the iterable contains a value matching each condition in
  /// [conditions] in the given order, with any extra elements between them.
  ///
  /// For example, the following will succeed:
  ///
  /// ```dart
  /// check([1, 10, 2, 10, 3]).containsMatchingInOrder([
  ///   (it) => it.isLessThan(2),
  ///   (it) => it.isLessThan(3),
  ///   (it) => it.isLessThan(4),
  /// ]);
  /// ```
  void containsMatchingInOrder(Iterable<Condition<T>> conditions) {
    context
        .expect(() => prefixFirst('contains, in order: ', literal(conditions)),
            (actual) {
      final expected = conditions.toList();
      if (expected.isEmpty) {
        throw ArgumentError('expected may not be empty');
      }
      var expectedIndex = 0;
      for (final element in actual) {
        final currentExpected = expected[expectedIndex];
        final matches = softCheck(element, currentExpected) == null;
        if (matches && ++expectedIndex >= expected.length) return null;
      }
      return Rejection(which: [
        ...prefixFirst(
            'did not have an element matching the expectation at index '
            '$expectedIndex ',
            literal(expected[expectedIndex])),
      ]);
    });
  }

  /// Expects that the iterable contains a value equals to each expected value
  /// from [elements] in the given order, with any extra elements between
  /// them.
  ///
  /// For example, the following will succeed:
  ///
  /// ```dart
  /// check([1, 0, 2, 0, 3]).containsInOrder([1, 2, 3]);
  /// ```
  ///
  /// Values, will be compared with the equality operator.
  void containsEqualInOrder(Iterable<T> elements) {
    context.expect(() => prefixFirst('contains, in order: ', literal(elements)),
        (actual) {
      final expected = elements.toList();
      if (expected.isEmpty) {
        throw ArgumentError('expected may not be empty');
      }
      var expectedIndex = 0;
      for (final element in actual) {
        final currentExpected = expected[expectedIndex];
        final matches = currentExpected == element;
        if (matches && ++expectedIndex >= expected.length) return null;
      }
      return Rejection(which: [
        ...prefixFirst(
            'did not have an element equal to the expectation at index '
            '$expectedIndex ',
            literal(expected[expectedIndex])),
      ]);
    });
  }

  /// Expects that the iterable contains at least on element such that
  /// [elementCondition] is satisfied.
  void any(Condition<T> elementCondition) {
    context.expect(() {
      final conditionDescription = describe(elementCondition);
      assert(conditionDescription.isNotEmpty);
      return [
        'contains a value that:',
        ...conditionDescription,
      ];
    }, (actual) {
      if (actual.isEmpty) return Rejection(actual: ['an empty iterable']);
      for (var e in actual) {
        if (softCheck(e, elementCondition) == null) return null;
      }
      return Rejection(which: ['Contains no matching element']);
    });
  }

  /// Expects there are no elements in the iterable which fail to satisfy
  /// [elementCondition].
  ///
  /// Empty iterables will pass always pass this expectation.
  void every(Condition<T> elementCondition) {
    context.expect(() {
      final conditionDescription = describe(elementCondition);
      assert(conditionDescription.isNotEmpty);
      return [
        'only has values that:',
        ...conditionDescription,
      ];
    }, (actual) {
      final iterator = actual.iterator;
      for (var i = 0; iterator.moveNext(); i++) {
        final element = iterator.current;
        final failure = softCheck(element, elementCondition);
        if (failure == null) continue;
        final which = failure.rejection.which;
        return Rejection(which: [
          'has an element at index $i that:',
          ...indent(failure.detail.actual.skip(1)),
          ...indent(prefixFirst('Actual: ', failure.rejection.actual),
              failure.detail.depth + 1),
          if (which != null && which.isNotEmpty)
            ...indent(prefixFirst('Which: ', which), failure.detail.depth + 1),
        ]);
      }
      return null;
    });
  }

  /// Expects that the iterable contains elements that are deeply equal to the
  /// elements of [expected].
  ///
  /// {@macro deep_collection_equals}
  void deepEquals(Iterable<Object?> expected) => context
          .expect(() => prefixFirst('is deeply equal to ', literal(expected)),
              (actual) {
        final which = deepCollectionEquals(actual, expected);
        if (which == null) return null;
        return Rejection(which: which);
      });

  /// Expects that the iterable contains elements which equal those of
  /// [expected] in any order.
  ///
  /// Should not be used for very large collections, runtime is O(n^2.5) in the
  /// worst case where the iterables contain many equal elements, and O(n^2) in
  /// more typical cases.
  void unorderedEquals(Iterable<T> expected) {
    context.expect(() => prefixFirst('unordered equals ', literal(expected)),
        (actual) {
      final which = unorderedCompare(
        actual,
        expected,
        (actual, expected) => expected == actual,
        (expected, index, count) => [
          ...prefixFirst(
              'has no element equal to the expected element at index '
              '$index: ',
              literal(expected)),
          if (count > 1) 'or ${count - 1} other elements',
        ],
        (actual, index, count) => [
          ...prefixFirst(
              'has an unexpected element at index $index: ', literal(actual)),
          if (count > 1) 'and ${count - 1} other unexpected elements',
        ],
      );
      if (which == null) return null;
      return Rejection(which: which);
    });
  }

  /// Expects that the iterable contains elements which match all conditions of
  /// [expected] in any order.
  ///
  /// Should not be used for very large collections, runtime is O(n^2.5) in the
  /// worst case where conditions match many elements, and O(n^2) in more
  /// typical cases.
  void unorderedMatches(Iterable<Condition<T>> expected) {
    context.expect(() => prefixFirst('unordered matches ', literal(expected)),
        (actual) {
      final which = unorderedCompare(
        actual,
        expected,
        (actual, expected) => softCheck(actual, expected) == null,
        (expected, index, count) => [
          'has no element matching the condition at index $index:',
          ...describe(expected),
          if (count > 1) 'or ${count - 1} other conditions',
        ],
        (actual, index, count) => [
          ...prefixFirst(
              'has an unmatched element at index $index: ', literal(actual)),
          if (count > 1) 'and ${count - 1} other unmatched elements',
        ],
      );
      if (which == null) return null;
      return Rejection(which: which);
    });
  }

  /// Expects that the iterable contains elements that correspond by the
  /// [elementCondition] exactly to each element in [expected].
  ///
  /// Fails if the iterable has a different length than [expected].
  ///
  /// For each element in the iterable, calls [elementCondition] with the
  /// corresponding element from [expected] to get the specific condition for
  /// that index.
  ///
  /// [description] is used in the Expected clause. It should be a predicate
  /// without the object, for example with the description 'is less than' the
  /// full expectation will be: "pairwise is less than $expected"
  @Deprecated('Use `pairwiseMatches`')
  void pairwiseComparesTo<S>(List<S> expected,
          Condition<T> Function(S) elementCondition, String description) =>
      pairwiseMatches(expected, elementCondition, description);

  /// Expects that the iterable contains elements that correspond by the
  /// [elementCondition] exactly to each element in [expected].
  ///
  /// Fails if the iterable has a different length than [expected].
  ///
  /// For each element in the iterable, calls [elementCondition] with the
  /// corresponding element from [expected] to get the specific condition for
  /// that index.
  ///
  /// [description] is used in the Expected clause. It should be a predicate
  /// without the object, for example with the description 'is less than' the
  /// full expectation will be: "pairwise is less than $expected"
  void pairwiseMatches<S>(List<S> expected,
      Condition<T> Function(S) elementCondition, String description) {
    context.expect(() {
      return prefixFirst('pairwise $description ', literal(expected));
    }, (actual) {
      final iterator = actual.iterator;
      for (var i = 0; i < expected.length; i++) {
        final expectedValue = expected[i];
        if (!iterator.moveNext()) {
          return Rejection(which: [
            'has too few elements, there is no element to match at index $i'
          ]);
        }
        final actualValue = iterator.current;
        final failure = softCheck(actualValue, elementCondition(expectedValue));
        if (failure == null) continue;
        final innerDescription = describe<T>(elementCondition(expectedValue));
        final which = failure.rejection.which;
        return Rejection(which: [
          'does not have an element at index $i that:',
          ...innerDescription,
          ...prefixFirst(
              'Actual element at index $i: ', failure.rejection.actual),
          if (which != null) ...prefixFirst('Which: ', which),
        ]);
      }
      if (!iterator.moveNext()) return null;
      return Rejection(which: [
        'has too many elements, expected exactly ${expected.length}'
      ]);
    });
  }
}