prefer-iterable-every

// Bad: filtered emptiness means every item fails the predicate.
void validateItems(List<int> items) {
  if (items.where((x) => x > 0).isEmpty) {
    print('No items are positive');
  }
}

// Bad: .where().length == list.length pattern
void checkAllValid(List<String> values) {
  bool allNonEmpty = values.where((v) => v.isNotEmpty).length == values.length;
  if (allNonEmpty) {
    print('All strings are non-empty');
  }
}

// Bad: the predicate must be negated when replacing filtered emptiness.
void processCollection() {
  final data = [2, 4, 6, 8];
  final allOdd = data.where((n) => n % 2 == 0).isEmpty;
}

// Bad: nested where with length comparison
void checkMatrix(List<List<int>> matrix) {
  if (matrix.where((row) => row.isNotEmpty).length == matrix.length) {
    print('All rows are non-empty');
  }
}

// Bad: where with complex predicate and length check
void checkAllPositive(List<int> numbers) {
  final allPositive = numbers.where((n) => n > 0 && n < 100).length == numbers.length;
}

// Bad: filtered emptiness in a variable declaration.
void verifyList(List<String> items) {
  bool allEmpty = items.where((i) => i.isNotEmpty).isEmpty;
}

// Regression: the violation must still be found inside Dart 3 containers
// (pattern declaration, labeled statement, switch expression and subject,
// collection if/spread, record field).
void containersRegression(int rcount, List<int> items) {
  final (ra, _) = (items.where((x) => x > 1).isEmpty, 0);
  lbl: {
    final rb = items.where((x) => x > 1).isEmpty;
    print(rb);
  }
  final rc = switch (rcount) {
    0 => items.where((x) => x > 1).isEmpty,
    _ => null,
  };
  final rd = switch (items.where((x) => x > 1).isEmpty) {
    _ => 0,
  };
  final re = [if (rcount > 0) items.where((x) => x > 1).isEmpty];
  final rf = [...[items.where((x) => x > 1).isEmpty]];
  final rg = (p: items.where((x) => x > 1).isEmpty, q: 0);
  print([ra, rc, rd, re, rf, rg]);
}

bool parenthesized(List<int> items) =>
    (items.where((x) => x > 0).isEmpty);

void universalComparisons(List<int> items) {
  final equalsTrue = items.where((x) => x > 0).isEmpty == true;
  final differsFalse = items.where((x) => x > 0).isEmpty != false;
  final reversedTrue = true == items.where((x) => x > 0).isEmpty;
  final reversedFalse = false != (items.where((x) => x > 0).isEmpty);
  final negatedComparison = !(items.where((x) => x > 0).isEmpty == false);
  final repeatedComparison = (items.where((x) => x > 0).isEmpty == false) == false;
  final doubleNegation = !(!items.where((x) => x > 0).isEmpty);
}

class CollectionOwner {
  final List<int> items = [];
  final List<int> others = [];

  bool allPositive() =>
      this.items.where((x) => x > 0).length == this.items.length;

  bool unrelated() =>
      this.items.where((x) => x > 0).length == this.others.length;
}

bool noEmptySet(Set<String> values) =>
    values.where((value) => value.isEmpty).isEmpty;

bool noEvenIterable(Iterable<int> values) =>
    values.where((value) => value.isEven).isEmpty;

bool noneMatch(List<int> values, bool Function(int) predicate) =>
    values.where(predicate).isEmpty;