// 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.

part of dart.collection.dev;

/**
 * Skeleton class for an unmodifiable [List].
 */
abstract class NonExtensibleListMixin<E>
    extends Iterable<E> implements List<E> {

  Iterator<E> get iterator => new ListIterator(this);

  void forEach(f(E element)) {
    for (int i = 0; i < this.length; i++) f(this[i]);
  }

  bool contains(E value) {
    for (int i = 0; i < length; i++) {
      if (this[i] == value) return true;
    }
    return false;
  }

  reduce(initialValue, combine(previousValue, E element)) {
    var value = initialValue;
    for (int i = 0; i < this.length; i++) {
      value = combine(value, this[i]);
    }
    return value;
  }

  bool every(bool f(E element)) {
    for (int i = 0; i < this.length; i++) {
      if (!f(this[i])) return false;
    }
    return true;
  }

  bool any(bool f(E element)) {
    for (int i = 0; i < this.length; i++) {
      if (f(this[i])) return true;
    }
    return false;
  }

  bool get isEmpty {
    return this.length == 0;
  }

  E elementAt(int index) {
    return this[index];
  }

  int indexOf(E value, [int start = 0]) {
    for (int i = start; i < length; i++) {
      if (this[i] == value) return i;
    }
    return -1;
  }

  int lastIndexOf(E value, [int start]) {
    if (start == null) start = length - 1;
    for (int i = start; i >= 0; i--) {
      if (this[i] == value) return i;
    }
    return -1;
  }

  E get first {
    if (length > 0) return this[0];
    throw new StateError("No elements");
  }

  E get last {
    if (length > 0) return this[length - 1];
    throw new StateError("No elements");
  }

  E get single {
    if (length == 1) return this[0];
    if (length == 0) throw new StateError("No elements");
    throw new StateError("More than one element");
  }

  List<E> getRange(int start, int length) {
    List<E> result = <E>[];
    for (int i = 0; i < length; i++) {
      result.add(this[start + i]);
    }
    return result;
  }

  void operator []=(int index, E value) {
    throw new UnsupportedError(
        "Cannot modify an unmodifiable list");
  }

  void set length(int newLength) {
    throw new UnsupportedError(
        "Cannot change the length of an unmodifiable list");
  }

  void add(E value) {
    throw new UnsupportedError(
        "Cannot add to an unmodifiable list");
  }

  void addLast(E value) {
    throw new UnsupportedError(
        "Cannot add to an unmodifiable list");
  }

  void addAll(Iterable<E> iterable) {
    throw new UnsupportedError(
        "Cannot add to an unmodifiable list");
  }

  void remove(E element) {
    throw new UnsupportedError(
        "Cannot remove from an unmodifiable list");
  }

  void removeAll(Iterable elements) {
    throw new UnsupportedError(
        "Cannot remove from an unmodifiable list");
  }

  void retainAll(Iterable elements) {
    throw new UnsupportedError(
        "Cannot remove from an unmodifiable list");
  }

  void removeMatching(bool test(E element)) {
    throw new UnsupportedError(
        "Cannot remove from an unmodifiable list");
  }
  void sort([Comparator<E> compare]) {
    throw new UnsupportedError(
        "Cannot modify an unmodifiable list");
  }

  void clear() {
    throw new UnsupportedError(
        "Cannot clear an unmodifiable list");
  }

  E removeAt(int index) {
    throw new UnsupportedError(
        "Cannot remove from an unmodifiable list");
  }

  E removeLast() {
    throw new UnsupportedError(
        "Cannot remove from an unmodifiable list");
  }

  void setRange(int start, int length, List<E> from, [int startFrom]) {
    throw new UnsupportedError(
        "Cannot modify an unmodifiable list");
  }

  void removeRange(int start, int length) {
    throw new UnsupportedError(
        "Cannot remove from an unmodifiable list");
  }

  void insertRange(int start, int length, [E initialValue]) {
    throw new UnsupportedError(
        "Cannot insert range in an unmodifiable list");
  }
}

/**
 * Iterates over a [List] in growing index order.
 */
class ListIterator<E> implements Iterator<E> {
  final List<E> _list;
  int _position;
  E _current;

  ListIterator(this._list) : _position = -1;

  bool moveNext() {
    int nextPosition = _position + 1;
    if (nextPosition < _list.length) {
      _current = _list[nextPosition];
      _position = nextPosition;
      return true;
    }
    _position = _list.length;
    _current = null;
    return false;
  }

  E get current => _current;
}

class MappedList<S, T> extends NonExtensibleListMixin<T> {
  final List<S> _list;
  // TODO(ahe): Restore type when feature is implemented in dart2js
  // checked mode. http://dartbug.com/7733
  final /* _Transformation<S, T> */ _f;

  MappedList(this._list, T this._f(S element));

  T operator[](int index) => _f(_list[index]);
  int get length => _list.length;
}

/**
 * An immutable view of a [List].
 */
class ListView<E> extends NonExtensibleListMixin<E> {
  final List<E> _list;
  final int _offset;
  final int _length;

  /**
   * If the given length is `null` then the ListView's length is bound by
   * the backed [list].
   */
  ListView(List<E> list, this._offset, this._length) : _list = list {
    if (_offset is! int || _offset < 0) {
      throw new ArgumentError(_offset);
    }
    if (_length != null &&
        (_length is! int || _length < 0)) {
      throw new ArgumentError(_length);
    }
  }

  int get length {
    int originalLength = _list.length;
    int skipLength = originalLength - _offset;
    if (skipLength < 0) return 0;
    if (_length == null || _length > skipLength) return skipLength;
    return _length;
  }

  E operator[](int index) {
    int skipIndex = index + _offset;
    if (index < 0 ||
        (_length != null && index >= _length) ||
        index + _offset >= _list.length) {
      throw new RangeError.value(index);
    }
    return _list[index + _offset];
  }

  ListView<E> skip(int skipCount) {
    if (skipCount is! int || skipCount < 0) {
      throw new ArgumentError(skipCount);
    }
    return new ListView(_list, _offset + skipCount, _length);
  }

  ListView<E> take(int takeCount) {
    if (takeCount is! int || takeCount < 0) {
      throw new ArgumentError(takeCount);
    }
    int newLength = takeCount;
    if (_length != null && takeCount > _length) newLength = _length;
    return new ListView(_list, _offset, newLength);
  }
}