import { AsyncSequence } from "../async/types.js";
import { Collector } from "../collector/types.js";
import { RandomOptions } from "../random/types.js";
import { Predicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";

export interface Sequence<TElement> extends Iterable<TElement> {
  iterator(): Iterator<TElement>;

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

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

  select<TResult>(selector: Converter<TElement, TResult>): Sequence<TResult>;
  selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>): Sequence<TResult>;

  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
  where(predicate: Predicate<TElement>): Sequence<TElement>;

  groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>>;

  join<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<[TElement, TOther]>;
  join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;

  groupJoin<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
  groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;

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

  sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>): boolean;

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

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

  remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Sequence<TElement>;

  concat(...sequences: Sequence<TElement>[]): Sequence<TElement>;

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

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

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

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

  aggregate(accumulator: Accumulator<TElement, TElement>): TElement;
  aggregate<TAccumulator>(accumulator: Accumulator<TElement, TAccumulator>, seed?: TAccumulator): TAccumulator;
  aggregate<TAccumulator, TResult>(accumulator: Accumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: Converter<TAccumulator, TResult>): TResult;

  min(comparer?: Comparer<TElement>): TElement;
  minBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement;

  max(comparer?: Comparer<TElement>): TElement;
  maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement;

  order(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
  orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;

  orderDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
  orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;

  partition(equater?: Equater<TElement>): Sequence<TElement[]>;
  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement[]>;

  distinct(equater?: Equater<TElement>): Sequence<TElement>;
  distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;

  union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
  unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;

  except(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
  exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;

  intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
  intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;

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

  skip(n: number): Sequence<TElement>;
  skipLast(n: number): Sequence<TElement>;
  skipWhile(condition: Predicate<TElement>): Sequence<TElement>;

  take(n: number): Sequence<TElement>;
  takeLast(n: number): Sequence<TElement>;
  takeWhile(condition: Predicate<TElement>): Sequence<TElement>;

  peek(action: Action<TElement>): Sequence<TElement>;

  forEach(action: Action<TElement>): void;

  zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]>;

  indexed(): Sequence<[number, TElement]>;

  reversed(): Sequence<TElement>;

  chunked(size: number): Sequence<Sequence<TElement>>;

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

  cached(): Sequence<TElement>;

  awaited(): AsyncSequence<Awaited<TElement>>;

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

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

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

export interface OrderedSequence<TElement> extends Sequence<TElement> {
  get comparer(): Comparer<TElement> | undefined;

  thenSelf(comparer?: Comparer<TElement>): OrderedSequence<TElement>;

  thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;

  thenSelfDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;

  thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
}