import { mathRandom } from "../random/index.js";
import { RandomGenerator } from "../random/types.js";
import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, WrappedArray, EMPTY, ZippedSequence } from "./impl.js";
import { Sequence } from "./types.js";

export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
  if (isSequence<T>(iterable)) {
    return iterable;
  }

  if (Array.isArray(iterable)) {
    return array(iterable);
  }

  if (iterable instanceof Set) {
    return set<T>(iterable);
  }

  if (iterable instanceof Map) {
    return map(iterable) as unknown as Sequence<T>;
  }

  return sequence(iterable);
}

export function sequence<T = any>(iterable: Iterable<T>): Sequence<T> {
  return new WrappedIterable(iterable);
}

export function empty<T = any>(): Sequence<T> {
  return EMPTY;
}

export function single<T>(obj: T): Sequence<T> {
  return new WrappedObject(obj);
}

export function array<T = any>(array: ReadonlyArray<T>): Sequence<T> {
  return new WrappedArray(array);
}

export function arrayLike<T = any>(arrayLike: ArrayLike<T>): Sequence<T> {
  return new WrappedArrayLike(arrayLike);
}

export function set<T>(set: ReadonlySet<T>): Sequence<T> {
  return new WrappedSet(set);
}

export function map<K, V>(map: ReadonlyMap<K, V>): Sequence<[K, V]> {
  return new WrappedMap(map);
}

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

export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Sequence<T> {
  return of(...elements);
}

export function entries<T>(o: Record<string, T> | ArrayLike<T>): Sequence<[string, T]> {
  return array(Object.entries(o));
}

export function keys(o: object): Sequence<string> {
  return array(Object.keys(o));
}

export function func<T>(f: () => T): Sequence<T> {
  return new FunctionSequence(f);
}

export function generator<T>(generator: () => Iterable<T>): Sequence<T> {
  return new GeneratorSequence(generator);
}

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

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

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

export function bigintRange(max: bigint): Sequence<bigint>
export function bigintRange(min: bigint, max: bigint): Sequence<bigint>
export function bigintRange(min: bigint, max: bigint, step: bigint): Sequence<bigint>
export function bigintRange(a: bigint, b?: bigint, c?: bigint): Sequence<bigint> {
  if (b === undefined) {
    b = a;
    a = 0n;
  }

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

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

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

  if (count < 0) {
    throw new RangeError();
  }

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

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

  return new RepeatSequence(value, count);
}

export function randomSequence(random?: RandomGenerator): Sequence<number> {
  return new FunctionSequence(random ?? mathRandom);
}

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

export function zip<T>(first: Sequence<T>, second: Sequence<T>): Sequence<[T, T]> {
  return new ZippedSequence(first, second);
}

export function isSequence<T = any>(obj: any): obj is Sequence<T> {
  return obj instanceof SequenceMarker;
}