import Function from "./Function";
import InfiniteIterator from "./InfiniteIterator";
import Predicate from "./Predicate";
import Stream from "./Stream";

export default class InfiniteStream<E> implements Stream<E> {
  private it: InfiniteIterator<E>;

  constructor(private initial: E, private func: Function<E, E>) {
    this.it = InfiniteIterator.of(initial, func);
  }

  public static of<E>(initial: E, func: Function<E, E>): InfiniteStream<E> {
    return new InfiniteStream<E>(initial, func);
  }

  public filter(filter: Predicate<E>): InfiniteStream<E> {
    let it = this.it;

    let initial: E;
    do {
      initial = it.next().value;
    } while (!filter(initial));

    return InfiniteStream.of(initial, previous => {
      let e: E;
      do {
        e = it.next().value;
      } while (!filter(e));
      return e;
    });
  }

  public map<R>(map: Function<E, R>): InfiniteStream<R> {
    let it = this.it;
    return InfiniteStream.of(map(it.next().value), previous => map(it.next().value));
  }

  public limit(size: number): E[] {
    let values: E[] = [];
    while (size-- > 0) {
      values.push(this.it.next().value);
    }
    return values;
  }

  public skip(amount: number): this {
    while (amount-- > 0) {
      this.it.next();
    }
    return this;
  }
}