// 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 MapChecks<K, V> on Subject<Map<K, V>> {
  Subject<Iterable<MapEntry<K, V>>> get entries =>
      has((m) => m.entries, 'entries');
  Subject<Iterable<K>> get keys => has((m) => m.keys, 'keys');
  Subject<Iterable<V>> get values => has((m) => m.values, 'values');
  Subject<int> get length => has((m) => m.length, 'length');
  Subject<V> operator [](K key) {
    return context.nest(
        () => prefixFirst('contains a value for ', literal(key)), (actual) {
      if (!actual.containsKey(key)) {
        return Extracted.rejection(
            which: prefixFirst('does not contain the key ', literal(key)));
      }
      return Extracted.value(actual[key] as V);
    });
  }

  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 not empty']);
    });
  }

  /// Expects that the map contains [key] according to [Map.containsKey].
  void containsKey(K key) {
    context.expect(() => prefixFirst('contains key ', literal(key)), (actual) {
      if (actual.containsKey(key)) return null;
      return Rejection(
          which: prefixFirst('does not contain key ', literal(key)));
    });
  }

  /// Expects that the map contains some key such that [keyCondition] is
  /// satisfied.
  void containsKeyThat(Condition<K> keyCondition) {
    context.expect(() {
      final conditionDescription = describe(keyCondition);
      assert(conditionDescription.isNotEmpty);
      return [
        'contains a key that:',
        ...conditionDescription,
      ];
    }, (actual) {
      if (actual.isEmpty) return Rejection(actual: ['an empty map']);
      for (var k in actual.keys) {
        if (softCheck(k, keyCondition) == null) return null;
      }
      return Rejection(which: ['Contains no matching key']);
    });
  }

  /// Expects that the map contains [value] according to [Map.containsValue].
  void containsValue(V value) {
    context.expect(() => prefixFirst('contains value ', literal(value)),
        (actual) {
      if (actual.containsValue(value)) return null;
      return Rejection(
          which: prefixFirst('does not contain value ', literal(value)));
    });
  }

  /// Expects that the map contains some value such that [valueCondition] is
  /// satisfied.
  void containsValueThat(Condition<V> valueCondition) {
    context.expect(() {
      final conditionDescription = describe(valueCondition);
      assert(conditionDescription.isNotEmpty);
      return [
        'contains a value that:',
        ...conditionDescription,
      ];
    }, (actual) {
      if (actual.isEmpty) return Rejection(actual: ['an empty map']);
      for (var v in actual.values) {
        if (softCheck(v, valueCondition) == null) return null;
      }
      return Rejection(which: ['Contains no matching value']);
    });
  }

  /// Expects that the map contains entries that are deeply equal to the entries
  /// of [expected].
  ///
  /// {@macro deep_collection_equals}
  void deepEquals(Map<Object?, 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);
      });
}