import type { Mapper, Supplier } from "./mod.ts";

export interface IEither<E, T> {
  mapBoth: <Ee, Tt>(
    errBranch: Mapper<E, Ee>,
    okBranch: Mapper<T, Tt>,
  ) => IEither<Ee, Tt>;
  flatMap: <Tt>(mapper: Mapper<T, IEither<E, Tt>>) => IEither<E, Tt>;
  mapRight: <Tt>(mapper: Mapper<T, Tt>) => IEither<E, Tt>;
  mapLeft: <Ee>(mapper: Mapper<E, Ee>) => IEither<Ee, T>;
}

export class Either<E, T> implements IEither<E, T> {
  private constructor(private readonly err?: E, private readonly ok?: T) {}

  public mapBoth<Ee, Tt>(
    errBranch: Mapper<E, Ee>,
    okBranch: Mapper<T, Tt>,
  ): Either<Ee, Tt> {
    if (this.err) return Either.left(errBranch(this.err));
    return Either.right(okBranch(this.ok!));
  }

  public flatMap<Tt>(mapper: Mapper<T, Either<E, Tt>>) {
    if (this.ok) return mapper(this.ok);
    return Either.left<E, Tt>(this.err!);
  }

  public mapRight<Tt>(mapper: Mapper<T, Tt>): IEither<E, Tt> {
    if (this.ok) return Either.right(mapper(this.ok));
    return Either.left<E, Tt>(this.err!);
  }

  public mapLeft<Ee>(mapper: Mapper<E, Ee>) {
    if (this.err) return Either.left<Ee, T>(mapper(this.err));
    return Either.right<Ee, T>(this.ok!);
  }

  static left<E, T>(e: E) {
    return new Either<E, T>(e);
  }

  static right<E, T>(t: T) {
    return new Either<E, T>(undefined, t);
  }

  static fromFailable<E, T>(s: Supplier<T>) {
    try {
      return Either.right<E, T>(s());
    } catch (e) {
      return Either.left<E, T>(e as E);
    }
  }

  static async fromFailableAsync<E, T>(s: Promise<T>) {
    try {
      return Either.right<E, T>(await s);
    } catch (e) {
      return Either.left<E, T>(e as E);
    }
  }
}