import { wrap as wrapSync } from "../sync/index.js";
import { Sequence } from "../sync/types.js";
import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybePromiseLike } from "../types.js";
import { isAsyncIterable } from "../utils.js";
import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY, ConcatAsyncSequence } from "./impl.js";
import { AsyncSequence } from "./types.js";

export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> {
  return new WrappedSequence(sequence);
}

export function wrap<T>(iterable: MaybeAsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
  if (isAsyncSequence<T>(iterable)) {
    return iterable;
  }

  if (isAsyncIterable(iterable)) {
    return sequence(iterable);
  }

  return asAsync(wrapSync(iterable));
}

export function sequence<T>(iterable: AsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
  return new WrappedAsyncIterable(iterable);
}

export function empty<T>(): AsyncSequence<T> {
  return EMPTY;
}

export function single<T>(obj: MaybePromiseLike<T>): AsyncSequence<T> {
  return new WrappedObjectAsync(obj);
}

export function array<T>(array: ReadonlyArray<MaybePromiseLike<T>>): AsyncSequence<T> {
  return new WrappedArrayAsync(array);
}

export function arrayLike<T>(arrayLike: ArrayLike<MaybePromiseLike<T>>): AsyncSequence<T> {
  return new WrappedArrayLikeAsync(arrayLike);
}

export function of<T>(...elements: MaybePromiseLike<T>[]): AsyncSequence<T> {
  switch (elements.length) {
    case 0:
      return empty();
    case 1:
      return single(elements[0]);
    default:
      return array(elements);
  }
}

export function concat<T>(...sequences: AsyncSequence<T>[]): AsyncSequence<T> {
  return new ConcatAsyncSequence<T>(sequences);
}

export function func<T>(f: () => MaybePromiseLike<T>): AsyncSequence<T> {
  return new FunctionAsyncSequence(f);
}

export function generator<T>(generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>): AsyncSequence<T> {
  return new GeneratorAsyncSequence(generator);
}

export function range(max: number): AsyncSequence<number>
export function range(min: number, max: number): AsyncSequence<number>
export function range(min: number, max: number, step: number): AsyncSequence<number>
export function range(a: number, b?: number, c?: number): AsyncSequence<number> {
  if (b === undefined) {
    b = a;
    a = 0;
  }

  if (c === undefined) {
    c = 1;
  }

  return new RangeAsyncSequence(a, b, c);
}

export function repeat<T>(value: MaybePromiseLike<T>, count?: number): AsyncSequence<T> {
  if (count == undefined) {
    return new RepeatForeverAsyncSequence(value);
  }

  if (count < 0) {
    throw new Error("count < 0");
  }

  if (count === 0) {
    return empty();
  }

  if (count === 1) {
    return new WrappedObjectAsync(value);
  }

  return new RepeatAsyncSequence(value, count);
}

export function isAsyncSequence<T = any>(obj: any): obj is AsyncSequence<T> {
  return obj instanceof AsyncSequenceMarker;
}