extension First<T> on Iterable<T> {
  T? firstWhereOrNull(
    bool Function(T element) test,
  ) {
    try {
      return firstWhere(test);
    } on StateError {
      return null;
    }
  }

  T? get firstOrNull {
    try {
      return first;
    } on StateError {
      return null;
    }
  }

  /// splits a list into a map of {id:list<T>} pairs
  ///
  /// the id is supplied by the [deriveKey] method
  Map<V, List<T>> divideByKey<V>(
    V Function(T e) deriveKey,
  ) {
    final result = <V, List<T>>{};
    for (final e in this) {
      final key = deriveKey(e);
      if (result[key] == null) result[key] = <T>[];
      result[key]!.add(e);
    }
    return result;
  }

  T get secondLastItem => toList().reversed.elementAt(1);
}

extension IntersperseDivider<T> on List<T> {
  void intersperseDivider(T divider) {
    final prevState = toList();
    clear();
    for (int i = 0; i < prevState.length; i++) {
      // Add the current widget to the new list
      add(prevState.elementAt(i));
      if (i == prevState.length - 1) break;
      add(divider);
    }
  }
}

extension Math<T extends num> on Iterable<T> {
  T? deriveMaximum() => fold(
        firstOrNull,
        (prev, e) => prev == null
            ? null
            : e > prev
                ? e
                : prev,
      );
  T? deriveMinimum() => fold(
        firstOrNull,
        (prev, e) => prev == null
            ? null
            : e < prev
                ? e
                : prev,
      );

  num calculateAverage() =>
      fold<num>(
        0,
        (prev, e) => prev += e,
      ) /
      length;

  num calculateSum() => fold<num>(
        0,
        (prev, e) => prev += e,
      );
}