import { Collector } from "../collector/types.js";
import { AsyncRandomOptions } from "../random/types.js";
import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, Predicate, MaybeAsyncAction } from "../types.js";

export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>> {
  iterator(): AsyncIterator<Awaited<TElement>>;

  apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;

  count(predicate?: MaybeAsyncPredicate<TElement>): Promise<number>;
  nonEnumeratedCount(): Promise<number>;
  fastCount(): Promise<number>;
  maxCount(): Promise<number>;

  select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;

  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;

  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;

  join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
  join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult>;

  groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
  groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult>;

  contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;

  sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;

  append(obj: TElement): AsyncSequence<TElement>;

  prepend(obj: TElement): AsyncSequence<TElement>;

  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;

  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;

  first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
  firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;

  last(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
  lastOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;

  single(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
  singleOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;

  elementAt(index: number): Promise<TElement>;
  elementAtOrDefault(index: number, def?: TElement): Promise<TElement | undefined>;

  aggregate(accumulator: MaybeAsyncAccumulator<TElement, TElement>): Promise<TElement>;
  aggregate<TAccumulator>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator): Promise<TAccumulator>;
  aggregate<TAccumulator, TResult>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: MaybeAsyncConverter<TAccumulator, TResult>): Promise<TResult>;

  min(): Promise<TElement>;
  minBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;

  max(): Promise<TElement>;
  maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;

  order(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;

  orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;

  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<Awaited<TElement>[]>;
  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<Awaited<TElement>[]>;

  distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;

  union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
  unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;

  except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;

  intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;

  all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
  any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
  any(): Promise<boolean>;
  none(predicate: Predicate<TElement>): Promise<boolean>;
  none(): Promise<boolean>;

  skip(n: number): AsyncSequence<TElement>;
  skipLast(n: number): AsyncSequence<TElement>;
  skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;

  take(n: number): AsyncSequence<TElement>;
  takeLast(n: number): AsyncSequence<TElement>;
  takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;

  peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement>;

  forEach(action: MaybeAsyncAction<TElement>): Promise<void>;

  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;

  indexex(): AsyncSequence<[number, Awaited<TElement>]>;

  reversed(): AsyncSequence<TElement>;

  chunked(size: number): AsyncSequence<TElement[]>;

  random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;

  cached(): AsyncSequence<TElement>;

  toArray(): Promise<TElement[]>;
  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
  toSet(): Promise<Set<TElement>>;
  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;

  collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>;
}

export interface GroupedAsyncSequence<TKey, TElement> extends AsyncSequence<TElement> {
  get key(): TKey;
}

export interface OrderedAsyncSequence<TElement> extends AsyncSequence<TElement> {
  get comparer(): MaybeAsyncComparer<TElement>;

  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;

  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;

  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;

  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
}