import { Dictionary, Producer, SequenceIterator, Transform } from "../../types/types"
import { Pipe } from "../../types/sequence/pipe"
import { OmniSequence } from "../../types/sequence/omni-sequence"
import { ErrorMessage } from "../../shared";

/**
 * Yields all own-property names in an object.
 */
export function keys<V>(object: Dictionary<V>): OmniSequence<string> {
    return new Pipe(generateKeys(object))
}

/**
 * Yields all key-value pairs in an object.
 */
export function pairs<V>(object: Dictionary<V>): OmniSequence<[string, V]> {
    return new Pipe(generatePairs(object))
}

/**
 * Yields all integers from zero to **end**. Does not include **end**.
 */
export function range(end: number): OmniSequence<number>

/**
 * Yields all numbers from **start** to **end** with a step size of one. Does not include **end**. Throws an error
 * if **start** is greater than **end**.
 */
export function range(start: number, end: number): OmniSequence<number>

/**
 * Yields all numbers from **start** to **end** with a provided **step** size. Does not include **end**. Throws an
 * error if **start** is greater than **end** or the **step** size is zero.
 */
export function range(start: number, end: number, step: number): OmniSequence<number>
export function range(first: number, second?: number, step: number = 1): OmniSequence<number> {
    let start, end
    if (second === undefined) {
        start = 0
        end = first
    } else {
        start = first
        end = second
    }

    if (step === 0) {
        throw Error(ErrorMessage.invalidRangeStep)
    }
    if (end < start) {
        throw Error(ErrorMessage.invalidRangeBounds)
    }

    return new Pipe(generateRange(start, end, step))
}

/**
 * Yields the values of all own-properties in an **object**.
 */
export function values<V>(object: Dictionary<V>): OmniSequence<V> {
    return new Pipe(generateValues(object))
}

/**
 * Yields an infinite sequence where each element is generated by a **producer** function.
 */
export function sequence<T>(producer: Producer<T>): OmniSequence<T>

/**
 * Yields an infinite sequence where each element is generated by passing the previous element into the **next**
 * transform function. The **initial** value will be the first value passed into **next**.
 */
export function sequence<T>(initial: T, next: Transform<T, T>): OmniSequence<T>
export function sequence<T>(first: T | Producer<T>, second?: Transform<T, T>): OmniSequence<T> {
    if (second === undefined) {
        return new Pipe(generateSequence(undefined, first as Producer<T>)) as OmniSequence<T>
    }
    return new Pipe(generateSequence(first as T, second as any)) as OmniSequence<T>
}

function* generateKeys<V>(object: Dictionary<V>): SequenceIterator<string> {
    for (let key in object) {
        if (object.hasOwnProperty(key)) {
            yield key
        }
    }
}

function* generatePairs<V>(object: Dictionary<V>): SequenceIterator<[string, V]> {
    for (let key in object) {
        if (object.hasOwnProperty(key)) {
            yield [key, object[key]]
        }
    }
}

function* generateRange(start: number, end: number, step: number): SequenceIterator<number> {
    if (step > 0) {
        for (let i = start; i < end; i += step) {
            yield i
        }
    } else {
        for (let i = end + step; i >= start; i += step) {
            yield i
        }
    }
}

function* generateValues<V>(object: Dictionary<V>): SequenceIterator<V> {
    for (let key in object) {
        if (object.hasOwnProperty(key)) {
            yield object[key]
        }
    }
}

function* generateSequence<T>(initial: T | undefined, next: (current?: T) => T): SequenceIterator<T> {
    if (initial === undefined) {
        while (true) {
            yield next()
        }
    }
    let current = initial
    while (true) {
        yield current
        current = next(current)
    }
}