import { Collector } from "../collector/types.js";
import { createAsyncEqualityMap } from "../equality-map.js";
import { createAsyncEqualitySet } from "../equality-set.js";
import { createQueue } from "../queue.js";
import { getRandomElementAsync } from "../random/index.js";
import { AsyncRandomOptions } from "../random/types.js";
import { selectionSorter } from "../sorting.js";
import { Sequence } from "../sync/types.js";
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence, MaybePromise } from "../types.js";
import { strictEquals, identity, operatorCompare, defaultArrayComparer, combineAsyncComparers, asAsyncIterable } from "../utils.js";
import { array, empty, wrap } from "./index.js";
import { AsyncSequence, AsyncSequencePipeline, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";

export class AsyncSequenceMarker { }

export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker implements AsyncSequence<TElement> {
  [Symbol.asyncIterator]() {
    return this.iterator();
  }

  abstract iterator(): AsyncIterator<TElement>;

  apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>): MaybePromise<TResult> {
    return pipeline(this);
  }

  select<TResult>(converter: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
    return new SelectAsyncSequence<TElement, TResult>(this, converter);
  }

  selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
    return new SelectManyAsyncSequence<TElement, TResult>(this, converter);
  }

  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
    return new WhereAsyncSequence<TElement>(this, predicate);
  }

  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
  groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
    return new GroupByAsyncSequence<any, any, any>(this, keySelector, elementSelector, keyComparer);
  }

  join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
  join<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
  join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
    return new JoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
  }

  groupJoin<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
  groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
  groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
    return new GroupJoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
  }

  async contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>) {
    if (!equater) {
      equater = strictEquals;
    }

    for await (const element of this) {
      if (await equater(element, obj)) {
        return true;
      }
    }

    return false;
  }

  async sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>) {
    if (this === sequence) {
      return true;
    }

    const that = wrap(sequence);

    const thisCount = await this.nonEnumeratedCount();
    const thatCount = await that.nonEnumeratedCount();

    if (thisCount >= 0 && thatCount >= 0 && thisCount !== thatCount) {
      return false;
    }

    if (!equater) {
      equater = strictEquals;
    }

    const thisIterator = this.iterator();
    const thatIterator = that.iterator();

    while (true) {
      const thisNext = await thisIterator.next();
      const thatNext = await thatIterator.next();

      if (thisNext.done) {
        return thatNext.done === true;
      }

      if (thatNext.done) {
        return false;
      }

      if (!await equater(thisNext.value, thatNext.value)) {
        return false;
      }
    }
  }

  append(obj: TElement): AsyncSequence<TElement> {
    return new AppendAsyncSequence<TElement>(this, obj);
  }

  prepend(obj: TElement): AsyncSequence<TElement> {
    return new PrependAsyncSequence<TElement>(this, obj);
  }

  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
    return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
  }

  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement> {
    if (sequences.length === 0) {
      return this;
    }

    const arr: AsyncSequence<TElement>[] = [this];

    for (const sequence of sequences) {
      arr.push(wrap(sequence));
    }

    return new ConcatAsyncSequence(arr);
  }

  async count(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    let count = 0;

    if (predicate) {
      for await (const element of this) {
        if (await predicate(element)) {
          count++;
        }
      }
    } else {
      const iterator = this.iterator();

      while (!(await iterator.next()).done) {
        count++;
      }
    }

    return count;
  }

  async nonEnumeratedCount() {
    return -1;
  }

  async fastCount() {
    const n = await this.nonEnumeratedCount();
    return n >= 0 ? n : await this.count();
  }

  async maxCount() {
    const n = await this.nonEnumeratedCount();
    return n >= 0 ? n : Infinity;
  }

  async #tryGetFirst(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    if (predicate) {
      for await (const element of this) {
        if (await predicate(element)) {
          return {
            found: true,
            element
          } as const;
        }
      }
    } else {
      const next = await this.iterator().next();

      if (!next.done) {
        return {
          found: true,
          element: next.value
        } as const;
      }
    }

    return {
      found: false
    } as const;
  }

  async first(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    const result = await this.#tryGetFirst(predicate);

    if (result.found) {
      return result.element;
    }

    throw new Error("No element was found.");
  }

  async firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
    const result = await this.#tryGetFirst(predicate);

    return result.found ? result.element : def;
  }

  async #tryGetLast(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    let found = false;
    let result: TElement | undefined = undefined;

    if (predicate) {
      for await (const element of this) {
        if (await predicate(element)) {
          found = true;
          result = element;
        }
      }
    } else {
      for await (const element of this) {
        found = true;
        result = element;
      }
    }

    return {
      found,
      element: result
    };
  }

  async last(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    const result = await this.#tryGetLast(predicate);

    if (result.found) {
      return result.element!;
    }

    throw new Error("No element was found.");
  }

  async lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
    const result = await this.#tryGetLast(predicate);

    return result.found ? result.element : def;
  }

  async #tryGetSingle(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    if (predicate) {
      let result: { found: true; element: TElement; } | undefined = undefined;

      for await (const element of this) {
        if (await predicate(element)) {
          if (result) {
            return {
              found: false,
              reason: 2
            } as const;
          }

          result = {
            found: true,
            element
          } as const;
        }
      }
    } else {
      const iterator = this.iterator();
      let next = await iterator.next();

      if (!next.done) {
        const result = {
          found: true,
          element: next.value
        } as const;

        next = await iterator.next();

        if (next.done) {
          return result;
        }

        return {
          found: false,
          reason: 2
        } as const;
      }
    }

    return {
      found: false,
      reason: 1
    } as const;
  }

  async single(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    const result = await this.#tryGetSingle(predicate);

    if (result.found == true) {
      return result.element;
    }

    let reason: string;
    switch (result.reason) {
      case 1:
        reason = "No element was found.";
        break;
      case 2:
        reason = "More than one element was found.";
        break;
      default:
        reason = "";
    }
    throw new Error(reason);
  }

  async singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
    const result = await this.#tryGetSingle(predicate);

    return result.found ? result.element : def;
  }

  async #tryElementAt(index: number) {
    let i = index;

    for await (const element of this) {
      if (i === 0) {
        return {
          found: true,
          element
        } as const;
      }

      i--;
    }

    return {
      found: false
    } as const;
  }

  async elementAt(index: number) {
    const result = await this.#tryElementAt(index);

    if (result.found) {
      return result.element;
    }

    throw new Error("No element found at given index.");
  }

  async elementAtOrDefault(index: number, def?: TElement) {
    const result = await this.#tryElementAt(index);

    return result.found ? result.element : def;
  }

  async aggregate<TAccumulator, TResult>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: MaybeAsyncConverter<TAccumulator, TResult>) {
    const iterator = this.iterator();

    if (seed === undefined) {
      const next = await iterator.next();

      if (next.done) {
        throw new Error("Aggregation requires at least one element.");
      }

      seed = next.value as unknown as TAccumulator;
    }

    let acc = seed;

    while (true) {
      const next = await iterator.next();

      if (next.done) {
        break;
      }

      acc = await accumulator(acc, next.value);
    }

    if (resultSelector) {
      return await resultSelector(acc);
    }

    return acc as unknown as TResult;
  }

  async #find<TResult>(sorter: MaybeAsyncAnyPredicate<number>, selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparer<TResult>) {
    const iterator = this.iterator();

    let next = await iterator.next();

    if (next.done) {
      throw new Error("Sequence contains no element.");
    }

    if (!selector) {
      selector = identity as MaybeAsyncConverter<TElement, TResult>;
    }

    if (!comparer) {
      comparer = operatorCompare;
    }

    let result = next.value;
    let convertedResult = await selector(result);

    while (true) {
      next = await iterator.next();

      if (next.done) {
        break;
      }

      const value = next.value;
      const convertedValue = await selector(value);

      if (await sorter(await comparer(convertedResult, convertedValue))) {
        result = value;
        convertedResult = convertedValue;
      }
    }

    return result;
  }

  min(comparer?: MaybeAsyncComparer<TElement>) {
    return this.#find(x => x > 0, undefined, comparer);
  }

  minBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>) {
    return this.#find(x => x > 0, converter, comparer);
  }

  max(comparer?: MaybeAsyncComparer<TElement>) {
    return this.#find(x => x < 0, undefined, comparer);
  }

  maxBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>) {
    return this.#find(x => x < 0, converter, comparer);
  }

  order(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
    return new OrderAsyncSequence<TElement>(this, false, comparer);
  }

  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
    return new OrderByAsyncSequence<TElement, TBy>(this, false, selector, comparer);
  }

  orderDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
    return new OrderAsyncSequence<TElement>(this, true, comparer);
  }

  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
    return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
  }

  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<AsyncSequence<TElement>> {
    return new PartitionAsyncSequence<TElement>(this, equater);
  }

  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<AsyncSequence<TElement>> {
    return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
  }

  distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
    return new DistinctAsyncSequence<TElement>(this, equater);
  }

  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
    return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
  }

  union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
    return new UnionAsyncSequence<TElement>(this, wrap(sequence), equater);
  }

  unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
    return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater);
  }

  except(sequence: MaybeAsyncSequence<TElement>): AsyncSequence<TElement> {
    return new ExceptAsyncSequence<TElement>(this, wrap(sequence));
  }

  exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
    return new ExceptByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
  }

  intersect(sequence: MaybeAsyncSequence<TElement>): AsyncSequence<TElement> {
    return new IntersectAsyncSequence<TElement>(this, wrap(sequence));
  }

  intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
    return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
  }

  async all(predicate: MaybeAsyncAnyPredicate<TElement>) {
    const n = await this.nonEnumeratedCount();

    if (n === 0) {
      return false;
    }

    for await (const element of this) {
      if (!await predicate(element)) {
        return false;
      }
    }

    return true;
  }

  async any(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    const n = await this.nonEnumeratedCount();

    if (n === 0) {
      return false;
    }

    if (predicate) {
      for await (const element of this) {
        if (await predicate(element)) {
          return true;
        }
      }

      return false;
    }

    return n < 0 ? !(await this.iterator().next()).done : n > 0;
  }

  async none(predicate?: MaybeAsyncAnyPredicate<TElement>) {
    const n = await this.nonEnumeratedCount();

    if (n === 0) {
      return true;
    }

    if (predicate) {
      for await (const element of this) {
        if (predicate(element)) {
          return false;
        }
      }

      return true;
    }

    return n < 0 && (await this.iterator().next()).done === true;
  }

  skip(n: number): AsyncSequence<TElement> {
    if (n < 0) {
      throw new Error("Cannot skip a negative number of elements.");
    }

    return n === 0 ? this : new SkipAsyncSequence<TElement>(this, n);
  }

  skipLast(n: number): AsyncSequence<TElement> {
    if (n < 0) {
      throw new Error("Cannot skip a negative number of elements.");
    }

    return n === 0 ? this : new SkipLastAsyncSequence<TElement>(this, n);
  }

  skipWhile(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
    return new SkipWhileAsyncSequence<TElement>(this, predicate);
  }

  take(n: number): AsyncSequence<TElement> {
    if (n < 0) {
      throw new Error("Cannot take a negative number of elements.");
    }

    return n === 0 ? empty<TElement>() : new TakeAsyncSequence<TElement>(this, n);
  }

  takeLast(n: number): AsyncSequence<TElement> {
    if (n < 0) {
      throw new Error("Cannot take a negative number of elements.");
    }

    return n === 0 ? empty<TElement>() : new TakeLastAsyncSequence<TElement>(this, n);
  }

  takeWhile(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
    return new TakeWhileAsyncSequence<TElement>(this, predicate);
  }

  peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement> {
    return new PeekAsyncSequence(this, action);
  }

  async forEach(action: MaybeAsyncAction<TElement>) {
    for await (const element of this) {
      await action(element);
    }
  }

  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]> {
    return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
  }

  indexed(): AsyncSequence<[number, TElement]> {
    return new IndexedAsyncSequence<TElement>(this);
  }

  reversed(): AsyncSequence<TElement> {
    return new ReversedAsyncSequence<TElement>(this);
  }

  chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
  chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
  chunked<TResult>(size: number, transformer?: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TResult> {
    if (size <= 0) {
      throw new Error("Chunk size must be positive.");
    }

    const result = new ChunkedAsyncSequence<TElement>(this, size);
    return transformer ? result.select(transformer) : result;
  }

  async random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
    return (await getRandomElementAsync(this, options)).element;
  }

  cached(): AsyncSequence<TElement> {
    return new CacheAsyncSequence<TElement>(this);
  }

  async asArray(): Promise<TElement[]> {
    return await this.toArray();
  }

  async toArray() {
    const array: TElement[] = [];

    for await (const element of this) {
      array.push(element);
    }

    return array;
  }

  toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
  async toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector?: MaybeAsyncConverter<TElement, any>): Promise<Map<TKey, any>> {
    valueSelector ??= identity;

    const map = new Map<TKey, any>();

    for await (const element of this) {
      const key = await keySelector(element);
      const value = await valueSelector(element);

      map.set(key, value);
    }

    return map;
  }

  async toSet() {
    const set = new Set<TElement>();

    for await (const element of this) {
      set.add(element);
    }

    return set;
  }

  toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
  async toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector?: MaybeAsyncConverter<TElement, any>): Promise<Record<TKey, any>> {
    valueSelector ??= identity;

    const obj: Record<PropertyKey, any> = {};

    for await (const element of this) {
      const key = await keySelector(element);
      const value = await valueSelector(element);

      obj[key] = value;
    }

    return obj;
  }

  async collect<TResult>(collector: Collector<TElement, any, TResult>) {
    const acc = collector.initialize();

    for await (const e of this) {
      collector.accumulate(acc, e);
    }

    return collector.finalize(acc);
  }
}

export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implements AsyncSequence<TElement> {
  #sequence: AsyncSequence<TElement>;

  constructor(sequence: AsyncSequence<TElement>) {
    super();

    this.#sequence = sequence;
  }

  get sequence() {
    return this.#sequence;
  }

  [Symbol.asyncIterator]() {
    return this.iterator();
  }

  iterator() {
    return this.#sequence.iterator();
  }

  apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>) {
    return this.#sequence.apply(pipeline);
  }

  count(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<number> {
    return this.#sequence.count(predicate);
  }

  nonEnumeratedCount(): Promise<number> {
    return this.#sequence.nonEnumeratedCount();
  }

  fastCount(): Promise<number> {
    return this.#sequence.fastCount();
  }

  maxCount(): Promise<number> {
    return this.#sequence.maxCount();
  }

  select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
    return this.#sequence.select(selector);
  }

  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
    return this.#sequence.selectMany(selector);
  }

  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
    return this.#sequence.where(predicate);
  }

  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
  groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
    return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
  }

  join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
  join<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
  join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
    return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
  }

  groupJoin<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
  groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
  groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
    return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
  }

  contains(obj: TElement, equater?: MaybeAsyncEquater<TElement> | undefined): Promise<boolean> {
    return this.#sequence.contains(obj, equater);
  }

  sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): Promise<boolean> {
    return this.#sequence.sequenceEquals(sequence, equater);
  }

  append(obj: TElement): AsyncSequence<TElement> {
    return this.#sequence.append(obj);
  }

  prepend(obj: TElement): AsyncSequence<TElement> {
    return this.#sequence.prepend(obj);
  }

  remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
    return this.#sequence.remove(obj, all, equater);
  }

  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement> {
    return this.#sequence.concat(...sequences);
  }

  first(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
    return this.#sequence.first(predicate);
  }

  firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
    return this.#sequence.firstOrDefault(predicate, def);
  }

  last(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
    return this.#sequence.last(predicate);
  }

  lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
    return this.#sequence.lastOrDefault(predicate, def);
  }

  single(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
    return this.#sequence.single(predicate);
  }

  singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
    return this.#sequence.singleOrDefault(predicate, def);
  }

  elementAt(index: number): Promise<TElement> {
    return this.#sequence.elementAt(index);
  }

  elementAtOrDefault(index: number, def?: TElement | undefined): Promise<TElement | undefined> {
    return this.#sequence.elementAtOrDefault(index, def);
  }

  aggregate(accumulator: MaybeAsyncAccumulator<TElement, TElement>): Promise<TElement>;
  aggregate<TAccumulator>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator | undefined): Promise<TAccumulator>;
  aggregate<TAccumulator, TResult>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator | undefined, resultSelector?: MaybeAsyncConverter<TAccumulator, TResult> | undefined): Promise<TResult>;
  aggregate(accumulator: any, seed?: any, resultSelector?: any) {
    return this.#sequence.aggregate(accumulator, seed, resultSelector);
  }

  min(): Promise<TElement> {
    return this.#sequence.min();
  }

  minBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement> {
    return this.#sequence.minBy(selector);
  }

  max(): Promise<TElement> {
    return this.#sequence.max();
  }

  maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement> {
    return this.#sequence.maxBy(selector);
  }

  order(comparer?: MaybeAsyncComparer<TElement> | undefined): AsyncSequence<TElement> {
    return this.#sequence.order(comparer);
  }

  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy> | undefined): AsyncSequence<TElement> {
    return this.#sequence.orderBy(selector, comparer);
  }

  orderDescending(comparer?: MaybeAsyncComparer<TElement> | undefined): AsyncSequence<TElement> {
    return this.#sequence.orderDescending(comparer);
  }

  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy> | undefined): AsyncSequence<TElement> {
    return this.#sequence.orderByDescending(selector, comparer);
  }

  partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
    return this.#sequence.partition(equater);
  }

  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
    return this.#sequence.partitionBy(selector, equater);
  }

  distinct(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
    return this.#sequence.distinct(equater);
  }

  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
    return this.#sequence.distinctBy(selector, equater);
  }

  union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
    return this.#sequence.union(wrap(sequence), equater);
  }

  unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
    return this.#sequence.unionBy(wrap(sequence), selector, equater);
  }

  except(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
    return this.#sequence.except(wrap(sequence), equater);
  }

  exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
    return this.#sequence.exceptBy(wrap(sequence), selector, equater);
  }

  intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
    return this.#sequence.intersect(wrap(sequence), equater);
  }

  intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
    return this.#sequence.intersectBy(wrap(sequence), selector, equater);
  }

  all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean> {
    return this.#sequence.all(predicate);
  }

  any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
  any(): Promise<boolean>;
  any(predicate?: any) {
    return this.#sequence.any(predicate);
  }

  none(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
  none(): Promise<boolean>;
  none(predicate?: any) {
    return this.#sequence.none(predicate);
  }

  skip(n: number): AsyncSequence<TElement> {
    return this.#sequence.skip(n);
  }

  skipLast(n: number): AsyncSequence<TElement> {
    return this.#sequence.skipLast(n);
  }

  skipWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
    return this.#sequence.skipWhile(condition);
  }

  take(n: number): AsyncSequence<TElement> {
    return this.#sequence.take(n);
  }

  takeLast(n: number): AsyncSequence<TElement> {
    return this.#sequence.takeLast(n);
  }

  takeWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
    return this.#sequence.takeWhile(condition);
  }

  peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement> {
    return this.#sequence.peek(action);
  }

  forEach(action: MaybeAsyncAction<TElement>): Promise<void> {
    return this.#sequence.forEach(action);
  }

  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]> {
    return this.#sequence.zip(wrap(sequence));
  }

  indexed(): AsyncSequence<[number, TElement]> {
    return this.#sequence.indexed();
  }

  reversed(): AsyncSequence<TElement> {
    return this.#sequence.reversed();
  }

  chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
  chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
  chunked(size: number, transformer?: any): any {
    return this.#sequence.chunked(size, transformer);
  }

  random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
    return this.#sequence.random(options);
  }

  cached(): AsyncSequence<TElement> {
    return this.#sequence.cached();
  }

  asArray(): Promise<TElement[]> {
    return this.#sequence.asArray();
  }

  toArray(): Promise<TElement[]> {
    return this.#sequence.toArray();
  }

  toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
  toMap(keySelector: any, valueSelector?: any) {
    return this.#sequence.toMap(keySelector, valueSelector);
  }

  toSet(): Promise<Set<TElement>> {
    return this.#sequence.toSet();
  }

  toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
  toObject(keySelector: any, valueSelector?: any) {
    return this.#sequence.toObject(keySelector, valueSelector);
  }

  collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult> {
    return this.#sequence.collect(collector);
  }
}

export class GroupedAsyncSequenceImpl<TElement, TKey> extends DelegatedAsyncSequence<TElement> implements GroupedAsyncSequence<TKey, TElement> {
  readonly #key: TKey;

  constructor(key: TKey, grouping: AsyncSequence<TElement>) {
    super(grouping);

    this.#key = key;
  }

  public get key() {
    return this.#key;
  }
}

abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TElement> implements OrderedAsyncSequence<TElement> {
  readonly #sequence: AsyncSequence<TElement>;
  readonly #sorter: MaybeAsyncComparer<TElement>;
  readonly #descending: boolean;

  constructor(sequence: AsyncSequence<TElement>, sorter: MaybeAsyncComparer<TElement>, descending: boolean) {
    super();

    this.#sequence = sequence;
    this.#sorter = sorter;
    this.#descending = descending;
  }

  override async nonEnumeratedCount() {
    return await this.#sequence.nonEnumeratedCount();
  }

  override async maxCount() {
    return await this.#sequence.maxCount();
  }

  get comparer() {
    return this.#sorter;
  }

  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
    return new ThenOrderAsyncSequence(this, false, comparer);
  }

  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
    return new ThenOrderByAsyncSequence<TElement, TBy>(this, false, selector, comparer);
  }

  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
    return new ThenOrderAsyncSequence(this, true, comparer);
  }

  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
    return new ThenOrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
  }

  override async *iterator() {
    const arr: TElement[] = [];

    for await (const obj of this.#sequence) {
      arr.push(obj);
    }

    await selectionSorter.sort(arr, this.#descending, this.#sorter);

    yield* arr;
  }
}

class EmptyAsyncSequence<T> extends BaseAsyncSequence<T> {
  override async nonEnumeratedCount() {
    return 0;
  }

  override async *iterator() { }
}

export const EMPTY = new EmptyAsyncSequence<any>();

export class RangeAsyncSequence extends BaseAsyncSequence<number> {
  readonly #min: number;
  readonly #max: number;
  readonly #step: number;

  constructor(min: number, max: number, step: number) {
    super();

    this.#min = min;
    this.#max = max;
    this.#step = step;
  }

  override async nonEnumeratedCount() {
    return Math.ceil((this.#max - this.#min) / this.#step);
  }

  override async *iterator() {
    for (let i = this.#min; i < this.#max; i += this.#step) {
      yield i;
    }
  }
}

export class RepeatAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #value: MaybePromiseLike<T>;
  readonly #count: number;

  constructor(value: MaybePromiseLike<T>, count: number) {
    super();

    this.#value = value;
    this.#count = count;
  }

  override async nonEnumeratedCount() {
    return this.#count;
  }

  override async *iterator() {
    let i = this.#count;

    while (i-- > 0) {
      yield this.#value;
    }
  }
}

export class RepeatForeverAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #value: MaybePromiseLike<T>;

  constructor(value: MaybePromiseLike<T>) {
    super();

    this.#value = value;
  }

  override async nonEnumeratedCount() {
    return Infinity;
  }

  override async *iterator() {
    while (true) {
      yield this.#value;
    }
  }
}

export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
  readonly #obj: MaybePromiseLike<T>;

  constructor(obj: MaybePromiseLike<T>) {
    super();

    this.#obj = obj;
  }

  override async nonEnumeratedCount() {
    return 1;
  }

  override async *iterator() {
    yield this.#obj;
  }
}

export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
  readonly #array: ReadonlyArray<MaybePromiseLike<T>>;

  constructor(array: ReadonlyArray<MaybePromiseLike<T>>) {
    super();

    this.#array = array;
  }

  override async nonEnumeratedCount() {
    return this.#array.length;
  }

  override async *iterator() {
    yield* this.#array;
  }
}

export class WrappedArrayLikeAsync<T> extends BaseAsyncSequence<T> {
  readonly #arrayLike: ArrayLike<MaybePromiseLike<T>>;

  constructor(arrayLike: ArrayLike<MaybePromiseLike<T>>) {
    super();

    this.#arrayLike = arrayLike;
  }

  override async nonEnumeratedCount() {
    return this.#arrayLike.length;
  }

  override async *iterator() {
    for (let i = 0; i < this.#arrayLike.length; i++) {
      yield this.#arrayLike[i];
    }
  }
}

export class WrappedAsyncIterable<T> extends BaseAsyncSequence<T> {
  readonly #iterable: AsyncIterable<MaybePromiseLike<T>>;

  constructor(iterable: AsyncIterable<MaybePromiseLike<T>>) {
    super();

    this.#iterable = iterable;
  }

  override async *iterator() {
    yield* this.#iterable;
  }
}

export class GeneratorAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>;

  constructor(generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>) {
    super();

    this.#generator = generator;
  }

  override async *iterator() {
    yield* this.#generator();
  }
}

export class FunctionAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #f: () => MaybePromiseLike<T>;

  constructor(f: () => MaybePromiseLike<T>) {
    super();

    this.#f = f;
  }

  override async nonEnumeratedCount() {
    return Infinity;
  }

  override async *iterator() {
    while (true) {
      yield await this.#f();
    }
  }
}

export class WrappedSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: Sequence<MaybePromiseLike<T>>;

  constructor(sequence: Sequence<MaybePromiseLike<T>>) {
    super();

    this.#sequence = sequence;
  }

  override async nonEnumeratedCount() {
    return this.#sequence.nonEnumeratedCount();
  }

  override async fastCount() {
    return this.#sequence.fastCount();
  }

  override async maxCount() {
    return this.#sequence.maxCount();
  }

  override async *iterator() {
    yield* this.#sequence;
  }
}

export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequences: Iterable<AsyncSequence<T>>;

  constructor(sequences: Iterable<AsyncSequence<T>>) {
    super();

    this.#sequences = sequences;
  }

  override async nonEnumeratedCount() {
    let n = 0;

    for (const sequence of this.#sequences) {
      const m = await sequence.nonEnumeratedCount();

      if (m < 0) {
        return -1;
      }

      n += m;
    }

    return n;
  }

  override async *iterator() {
    for (const sequence of this.#sequences) {
      yield* sequence;
    }
  }
}

class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #equater: MaybeAsyncEquater<T> | undefined;

  constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
    super();

    this.#sequence = sequence;
    this.#equater = equater;
  }

  override async *iterator() {
    const set = createAsyncEqualitySet(this.#equater);

    for await (const obj of this.#sequence) {
      if (await set.add(obj)) {
        yield obj;
      }
    }
  }
}

class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #selector: MaybeAsyncConverter<T, U>;
  readonly #equater: MaybeAsyncEquater<U> | undefined;

  constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
    super();

    this.#sequence = sequence;
    this.#selector = selector;
    this.#equater = equater;
  }

  override async *iterator() {
    const set = createAsyncEqualitySet(this.#equater);

    for await (const obj of this.#sequence) {
      if (await set.add(await this.#selector(obj))) {
        yield obj;
      }
    }

    set.clear();
  }
}

class WhereAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #predicate: MaybeAsyncAnyPredicate<T>;

  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
    super();

    this.#sequence = sequence;
    this.#predicate = predicate;
  }

  override async *iterator() {
    for await (const obj of this.#sequence) {
      if (await this.#predicate(obj)) {
        yield obj;
      }
    }
  }
}

class SelectManyAsyncSequence<T, U> extends BaseAsyncSequence<U> {
  readonly #sequence: AsyncSequence<T>;
  readonly #converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>;

  constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>) {
    super();

    this.#sequence = sequence;
    this.#converter = converter;
  }

  override async *iterator() {
    for await (const obj of this.#sequence) {
      yield* await this.#converter(obj);
    }
  }
}

class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, T]> {
  readonly #sequence: AsyncSequence<T>;

  constructor(sequence: AsyncSequence<T>) {
    super();

    this.#sequence = sequence;
  }

  override async *iterator() {
    let i = 0;

    for await (const obj of this.#sequence) {
      yield [i++, obj] as [number, T];
    }
  }
}

class SelectAsyncSequence<T, U> extends BaseAsyncSequence<U> {
  readonly #sequence: AsyncSequence<T>;
  readonly #converter: MaybeAsyncConverter<T, U>;

  constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, U>) {
    super();

    this.#sequence = sequence;
    this.#converter = converter;
  }

  override async nonEnumeratedCount() {
    return await this.#sequence.nonEnumeratedCount();
  }

  override async *iterator() {
    for await (const obj of this.#sequence) {
      yield await this.#converter(obj);
    }
  }
}

class SkipWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #predicate: MaybeAsyncAnyPredicate<T>;

  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
    super();

    this.#sequence = sequence;
    this.#predicate = predicate;
  }

  override async *iterator() {
    const iterator = this.#sequence.iterator();

    while (true) {
      const next = await iterator.next();

      if (next.done) {
        return;
      }

      if (await this.#predicate(next.value)) {
        continue;
      }

      yield next.value;
      break;
    }

    yield* asAsyncIterable(iterator);
  }
}

class SkipLastAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #n: number;

  constructor(sequence: AsyncSequence<T>, n: number) {
    super();

    this.#sequence = sequence;
    this.#n = n;
  }

  override async nonEnumeratedCount() {
    const n = await this.#sequence.nonEnumeratedCount();
    return n < 0 ? -1 : Math.max(0, n - this.#n);
  }

  override async *iterator() {
    const iterator = this.#sequence.iterator();
    const buffer = new Array<T>(this.#n); // n > 0
    let i = 0;

    do {
      const next = await iterator.next();

      if (next.done) {
        return;
      }

      buffer[i++] = next.value;
    } while (i < this.#n);

    i = 0;

    for await (const obj of asAsyncIterable(iterator)) {
      yield buffer[i];
      buffer[i] = obj;
      i = (i + 1) % this.#n;
    }
  }
}

class SkipAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #n: number;

  constructor(sequence: AsyncSequence<T>, n: number) {
    super();

    this.#sequence = sequence;
    this.#n = n;
  }

  override async nonEnumeratedCount() {
    const n = await this.#sequence.nonEnumeratedCount();
    return n < 0 ? -1 : Math.max(0, n - this.#n);
  }

  override async *iterator() {
    const iterator = this.#sequence.iterator();
    let i = 0;

    do {
      if ((await iterator.next()).done) {
        return;
      }

      i++;
    } while (i < this.#n);

    yield* asAsyncIterable(iterator);
  }
}

class TakeWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #predicate: MaybeAsyncAnyPredicate<T>;

  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
    super();

    this.#sequence = sequence;
    this.#predicate = predicate;
  }

  override async *iterator() {
    for await (const obj of this.#sequence) {
      if (!await this.#predicate(obj)) {
        return;
      }

      yield obj;
    }
  }
}

class TakeLastAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #n: number;

  constructor(sequence: AsyncSequence<T>, n: number) {
    super();

    this.#sequence = sequence;
    this.#n = n;
  }

  override async nonEnumeratedCount() {
    const n = await this.#sequence.nonEnumeratedCount();
    return n < 0 ? -1 : Math.min(this.#n, n);
  }

  override async *iterator() {
    const queue = createQueue<T>(this.#n);

    for await (const obj of this.#sequence) {
      queue.enqueue(obj);
    }

    yield* queue;
  }
}

class TakeAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #n: number;

  constructor(sequence: AsyncSequence<T>, n: number) {
    super();

    this.#sequence = sequence;
    this.#n = n;
  }

  override async nonEnumeratedCount() {
    const n = await this.#sequence.nonEnumeratedCount();
    return n < 0 ? -1 : Math.min(this.#n, n);
  }

  override async *iterator() {
    const iterator = this.#sequence.iterator();
    let i = this.#n;

    while (i > 0) {
      const next = await iterator.next();

      if (next.done) {
        return;
      }

      yield next.value as T;
      i--;
    }
  }
}

class OrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
  constructor(sequence: AsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparer<T>) {
    super(sequence, sorter ?? defaultArrayComparer, descending);
  }
}

class OrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
  constructor(sequence: AsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
    super(sequence, OrderByAsyncSequence.#createSorter(selector, sorter), descending);
  }

  static #createSorter<T, U>(selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
    sorter ??= defaultArrayComparer;
    return async (a: T, b: T) => sorter(await selector(a), await selector(b));
  }
}

class ThenOrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
  constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparer<T>) {
    super(sequence, combineAsyncComparers(sequence.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
  }
}

class ThenOrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
  constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
    super(sequence, ThenOrderByAsyncSequence.#createCombinedSorter(sequence.comparer, selector, sorter), descending);
  }

  static #createCombinedSorter<T, U>(baseSorter: MaybeAsyncComparer<T>, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
    baseSorter ??= defaultArrayComparer;
    sorter ??= defaultArrayComparer;
    return combineAsyncComparers(baseSorter, async (a: T, b: T) => sorter(await selector(a), await selector(b)));
  }
}

class AppendAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #obj: T;

  constructor(sequence: AsyncSequence<T>, obj: T) {
    super();

    this.#sequence = sequence;
    this.#obj = obj;
  }

  override async nonEnumeratedCount() {
    const n = await this.#sequence.nonEnumeratedCount();
    return n < 0 ? -1 : n + 1;
  }

  override async maxCount() {
    return await this.#sequence.maxCount() + 1;
  }

  override async *iterator() {
    yield* this.#sequence;
    yield this.#obj;
  }
}

class PrependAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #obj: T;

  constructor(sequence: AsyncSequence<T>, obj: T) {
    super();

    this.#sequence = sequence;
    this.#obj = obj;
  }

  override async nonEnumeratedCount() {
    const n = await this.#sequence.nonEnumeratedCount();
    return n < 0 ? -1 : n + 1;
  }

  override async maxCount() {
    return await this.#sequence.maxCount() + 1;
  }

  override async *iterator() {
    yield this.#obj;
    yield* this.#sequence;
  }
}

class PeekAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #action: MaybeAsyncAction<T>;

  constructor(sequence: AsyncSequence<T>, action: MaybeAsyncAction<T>) {
    super();

    this.#sequence = sequence;
    this.#action = action;
  }

  override async *iterator() {
    for await (const obj of this.#sequence) {
      await this.#action(obj);
      yield obj;
    }
  }
}

class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
  readonly #first: AsyncSequence<T>;
  readonly #second: AsyncSequence<U>;

  constructor(first: AsyncSequence<T>, second: AsyncSequence<U>) {
    super();

    this.#first = first;
    this.#second = second;
  }

  override async nonEnumeratedCount() {
    const first = await this.#first.nonEnumeratedCount();
    const second = await this.#second.nonEnumeratedCount();

    return first < 0 || second < 0 ? -1 : Math.min(first, second);
  }

  override async *iterator() {
    const firstIterator = this.#first.iterator();
    const secondIterator = this.#second.iterator();

    while (true) {
      const firstNext = await firstIterator.next();
      const secondNext = await secondIterator.next();

      if (firstNext.done || secondNext.done) {
        return;
      }

      yield [firstNext.value, secondNext.value] as [T, U];
    }
  }
}

class UnionAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #first: AsyncSequence<T>;
  readonly #second: AsyncSequence<T>;
  readonly #equater: MaybeAsyncEquater<T> | undefined;

  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
    super();

    this.#first = first;
    this.#second = second;
    this.#equater = equater;
  }

  override async *iterator() {
    const set = createAsyncEqualitySet(this.#equater);

    for await (const obj of this.#first) {
      if (await set.add(obj)) {
        yield obj;
      }
    }

    for await (const obj of this.#second) {
      if (await set.add(obj)) {
        yield obj;
      }
    }

    set.clear();
  }
}

class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
  readonly #first: AsyncSequence<T>;
  readonly #second: AsyncSequence<T>;
  readonly #selector: MaybeAsyncConverter<T, U>;
  readonly #equater: MaybeAsyncEquater<U> | undefined;

  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
    super();

    this.#first = first;
    this.#second = second;
    this.#selector = selector;
    this.#equater = equater;
  }

  override async *iterator() {
    const set = createAsyncEqualitySet(this.#equater);

    for await (const obj of this.#first) {
      if (await set.add(await this.#selector(obj))) {
        yield obj;
      }
    }

    for await (const obj of this.#second) {
      if (await set.add(await this.#selector(obj))) {
        yield obj;
      }
    }

    set.clear();
  }
}

class ExceptAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #first: AsyncSequence<T>;
  readonly #second: AsyncSequence<T>;
  readonly #equater: MaybeAsyncEquater<T> | undefined;

  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
    super();

    this.#first = first;
    this.#second = second;
    this.#equater = equater;
  }

  override async *iterator() {
    const set = createAsyncEqualitySet(this.#equater);

    for await (const obj of this.#second) {
      await set.add(obj);
    }

    for await (const obj of this.#first) {
      if (await set.add(obj)) {
        yield obj;
      }
    }

    set.clear();
  }
}

class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
  readonly #first: AsyncSequence<T>;
  readonly #second: AsyncSequence<T>;
  readonly #selector: MaybeAsyncConverter<T, U>;
  readonly #equater: MaybeAsyncEquater<U> | undefined;

  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
    super();

    this.#first = first;
    this.#second = second;
    this.#selector = selector;
    this.#equater = equater;
  }

  override async *iterator() {
    const set = createAsyncEqualitySet(this.#equater);

    for await (const obj of this.#second) {
      await set.add(await this.#selector(obj));
    }

    for await (const obj of this.#first) {
      if (await set.add(await this.#selector(obj))) {
        yield obj;
      }
    }

    set.clear();
  }
}

class IntersectAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #first: AsyncSequence<T>;
  readonly #second: AsyncSequence<T>;
  readonly #equater: MaybeAsyncEquater<T> | undefined;

  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
    super();

    this.#first = first;
    this.#second = second;
    this.#equater = equater;
  }

  override async *iterator() {
    const set = createAsyncEqualitySet(this.#equater);

    for await (const obj of this.#second) {
      await set.add(obj);
    }

    for await (const obj of this.#first) {
      if (await set.remove(obj)) {
        yield obj;
      }
    }

    set.clear();
  }
}

class IntersectByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
  readonly #first: AsyncSequence<T>;
  readonly #second: AsyncSequence<T>;
  readonly #selector: MaybeAsyncConverter<T, U>;
  readonly #equater: MaybeAsyncEquater<U> | undefined;

  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
    super();

    this.#first = first;
    this.#second = second;
    this.#selector = selector;
    this.#equater = equater;
  }

  override async *iterator() {
    const set = createAsyncEqualitySet(this.#equater);

    for await (const obj of this.#second) {
      await set.add(await this.#selector(obj));
    }

    for await (const obj of this.#first) {
      if (await set.remove(await this.#selector(obj))) {
        yield obj;
      }
    }

    set.clear();
  }
}

class ReversedAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;

  constructor(sequence: AsyncSequence<T>) {
    super();

    this.#sequence = sequence;
  }

  override async *iterator() {
    const buffer: T[] = [];

    for await (const obj of this.#sequence) {
      buffer.push(obj);
    }

    for (let i = buffer.length - 1; i >= 0; i--) {
      yield buffer[i];
    }
  }
}

class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<GroupedAsyncSequence<TKey, TResult>> {
  readonly #sequence: AsyncSequence<TElement>;
  readonly #keySelector: MaybeAsyncConverter<TElement, TKey>;
  readonly #elementSelector: MaybeAsyncConverter<TElement, TResult>;
  readonly #keyComparer: MaybeAsyncEquater<TKey> | undefined;

  constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>) {
    super();

    this.#sequence = sequence;
    this.#keySelector = keySelector;
    this.#elementSelector = elementSelector ?? identity as MaybeAsyncConverter<TElement, TResult>;
    this.#keyComparer = keyComparer;
  }

  override async *iterator() {
    const groupings = createAsyncEqualityMap<TKey, TResult[]>(this.#keyComparer);

    for await (const obj of this.#sequence) {
      const key = await this.#keySelector(obj);
      const value = await this.#elementSelector(obj);

      const grouping = await groupings.get(key);

      if (grouping) {
        grouping.push(value);
      } else {
        await groupings.set(key, [value]);
      }
    }

    for (const entry of groupings) {
      yield new GroupedAsyncSequenceImpl(entry[0], array(entry[1]));
    }
  }
}

class ChunkedAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
  readonly #sequence: AsyncSequence<T>;
  readonly #size: number;

  constructor(sequence: AsyncSequence<T>, size: number) {
    super();

    this.#sequence = sequence;
    this.#size = size;
  }

  override async nonEnumeratedCount() {
    const n = await this.#sequence.nonEnumeratedCount();
    return n < 0 ? -1 : Math.ceil(n / this.#size);
  }

  override async *iterator() {
    let chunk: T[] = [];

    for await (const obj of this.#sequence) {
      chunk.push(obj);

      if (chunk.length === this.#size) {
        yield array(chunk);
        chunk = [];
      }
    }

    if (chunk.length > 0) {
      yield array(chunk);
    }
  }
}

class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence<TResult> {
  readonly #first: AsyncSequence<TOuter>;
  readonly #second: AsyncSequence<TInner>;
  readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
  readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
  readonly #resultSelector: MaybeAsyncBiConverter<TOuter, TInner, TResult>;
  readonly #keyComparer: MaybeAsyncEquater<TKey>;

  constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, TInner, TResult>, keyComparer?: MaybeAsyncEquater<TKey>) {
    super();

    this.#first = first;
    this.#second = second;
    this.#firstKeySelector = firstKeySelector;
    this.#secondKeySelector = secondKeySelector;
    this.#resultSelector = resultSelector ?? identity as MaybeAsyncBiConverter<TOuter, TInner, TResult>;
    this.#keyComparer = keyComparer ?? strictEquals;
  }

  override async *iterator() {
    for await (const firstObj of this.#first) {
      const firstKey = await this.#firstKeySelector(firstObj);

      for await (const secondObj of this.#second) {
        const secondKey = await this.#secondKeySelector(secondObj);

        if (await this.#keyComparer(firstKey, secondKey)) {
          yield await this.#resultSelector(firstObj, secondObj);
        }
      }
    }
  }
}

class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence<TResult> {
  readonly #first: AsyncSequence<TOuter>;
  readonly #second: AsyncSequence<TInner>;
  readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
  readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
  readonly #resultSelector: MaybeAsyncBiConverter<TOuter, AsyncSequence<TInner>, TResult>;
  readonly #keyComparer: MaybeAsyncEquater<TKey>;

  constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, AsyncSequence<TInner>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>) {
    super();

    this.#first = first;
    this.#second = second;
    this.#firstKeySelector = firstKeySelector;
    this.#secondKeySelector = secondKeySelector;
    this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, AsyncSequence<TInner>, TResult>;
    this.#keyComparer = keyComparer ?? strictEquals;
  }

  static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: AsyncSequence<TInner>) {
    return new GroupedAsyncSequenceImpl(first, second);
  }

  override async *iterator() {
    for await (const firstObj of this.#first) {
      const firstKey = await this.#firstKeySelector(firstObj);
      const secondObjs: TInner[] = [];

      for await (const secondObj of this.#second) {
        const secondKey = await this.#secondKeySelector(secondObj);

        if (await this.#keyComparer(firstKey, secondKey)) {
          secondObjs.push(secondObj);
        }
      }

      // yield this.#resultSelector(firstObj, this.#second.where(secondObj => this.#keyComparer(firstKey, this.#secondKeySelector(secondObj))));
      yield this.#resultSelector(firstObj, array(secondObjs));
    }
  }
}

class RemoveAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  readonly #obj: T;
  readonly #all: boolean;
  readonly #equater: MaybeAsyncEquater<T>;

  constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEquater<T>) {
    super();

    this.#sequence = sequence;
    this.#obj = obj;
    this.#all = all ?? false;
    this.#equater = equater ?? strictEquals;
  }

  override async *iterator() {
    let gotOne = false;

    for await (const obj of this.#sequence) {
      if (await this.#equater(this.#obj, obj)) {
        if (this.#all) {
          continue;
        }

        if (!gotOne) {
          gotOne = true;
          continue;
        }
      }

      yield obj;
    }
  }
}

class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
  readonly #sequence: AsyncSequence<T>;
  #cache: T[] | undefined;

  constructor(sequence: AsyncSequence<T>) {
    super();

    this.#sequence = sequence;
  }

  override async *iterator() {
    if (this.#cache) {
      yield* this.#cache;
    } else {
      const cache = [];

      for await (const e of this.#sequence) {
        cache.push(e);
        yield e;
      }

      this.#cache = cache;
    }
  }
}

class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
  readonly #sequence: AsyncSequence<T>;
  readonly #equater: MaybeAsyncEquater<T>;

  constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEquater<T> | undefined) {
    super();

    this.#sequence = sequence;
    this.#equater = equater ?? strictEquals;
  }

  override async *iterator() {
    const partitions = createAsyncEqualityMap<T, T[]>(this.#equater);

    for await (const obj of this.#sequence) {
      const partition = await partitions.get(obj);

      if (partition) {
        partition.push(obj);
      } else {
        await partitions.set(obj, [obj]);
      }
    }

    for (const partition of partitions.values()) {
      yield array(partition);
    }
  }
}

class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<AsyncSequence<TElement>> {
  readonly #sequence: AsyncSequence<TElement>;
  readonly #selector: MaybeAsyncConverter<TElement, TBy>;
  readonly #equater: MaybeAsyncEquater<TBy>;

  constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEquater<TBy> | undefined) {
    super();

    this.#sequence = sequence;
    this.#selector = selector;
    this.#equater = equater ?? strictEquals;
  }

  override async *iterator() {
    const partitions = createAsyncEqualityMap<TBy, TElement[]>(this.#equater);

    for await (const obj of this.#sequence) {
      const key = await this.#selector(obj);
      const partition = await partitions.get(key);

      if (partition) {
        partition.push(obj);
      } else {
        await partitions.set(key, [obj]);
      }
    }

    for (const partition of partitions.values()) {
      yield array(partition);
    }
  }
}