import Exceptional from "./Exceptional";

export default class EtudeParser<T> {
  private objects: Object[];

  private constructor(private t: T, private exception: Error) {
    this.objects = [];
  }

  private isInvalid(): boolean {
    return this.exception != null;
  }

  public static of<T>(t: T, exception: Error = null): EtudeParser<T> {
    return new EtudeParser<T>(t, exception);
  }

  public map<S>(func: (T) => S): EtudeParser<S> {
    return this.isInvalid()
      ? EtudeParser.of(null, this.exception)
      : EtudeParser.of(func(this.t));
  }

  public filter(predicate: (T) => boolean, exception: Error): EtudeParser<T> {
    return this.isInvalid()
      ? this
      : (predicate(this.t)
        ? this
        : EtudeParser.of(this.t, exception)
      );
  }

  public parse<S>(func: (T) => Exceptional<S>): EtudeParser<T> {
    if (this.isInvalid()) {
      return this;
    }

    const exceptional: Exceptional<S> = func(this.t);
    if (!exceptional.isPresent()) {
      return EtudeParser.of(this.t, exceptional.getException());
    }

    this.objects.push(exceptional.get());

    return this;
  }

  public get<T>(func: (o: Object[]) => T): Exceptional<T> {
    return this.isInvalid()
      ? Exceptional.empty(this.exception)
      : Exceptional.of(func(this.objects));
  }
}