import {
    MapIterator,
    AsyncErrorCallback,
    Dictionary,
    NumericDictionary,
    MapResultCallback,
    PromiseResolver,
    PromiseRejector
} from "../interfaces";

import {
    once
} from "../common";

function seriesArray<T, E>(
    data: T[],
    next: MapIterator<T, E>,
    final?: MapResultCallback<T, E>
): void {

    let results: T[] = [];

    let loop = function(i: number): void {

        if (i < data.length) {

            next(data[i], i, once(function(err: E, val: T): void {

                if (err !== null && err !== undefined) {

                    final && final(err);
                }
                else {

                    results.push(val);

                    loop(i + 1);
                }
            }));
        }
        else {

            final && final(null, results);
        }
    };

    loop(0);
}

function seriesDict<T, E>(
    data: Dictionary<T>,
    next: MapIterator<T, E>,
    final: MapResultCallback<T, E>
): void {

    let keys: string[] = [];

    let dataObject: Dictionary<T> = {}, results: Dictionary<T> = {};

    for (let key in data) {

        keys.push(key);
        dataObject[key] = data[key];
    }

    let loop = function(i: number): void {

        if (i < keys.length) {

            let key: string = keys[i];

            next(data[key], key, once(function(err: E, val: T): void {

                if (err !== null && err !== undefined) {

                    final(err);
                }
                else {

                    results[key] = val;

                    loop(i + 1);
                }
            }));
        }
        else {

            final(null, results);
        }
    };

    loop(0);
}

/**
 * This method enum all items in an array or an object one by one,
 * with index value.
 */
export function series<T, E>(
    data: Dictionary<T> | T[],
    next: MapIterator<T, E>,
    final: MapResultCallback<T, E>
): void {

    if (data instanceof Array) {

        data = data.slice();

        seriesArray<T, E>(data, next, final);
    }
    else {

        seriesDict<T, E>(data, next, final);
    }
};

export function series_Promise<T, E>(
    data: Dictionary<T> | T[],
    next: MapIterator<T, E>
): Promise<T> {

    return new Promise<T>(function(
        resolve: PromiseResolver<T>,
        reject: PromiseRejector<E>
    ): void {

        series(data, next, function(err?: E): void {

            err ? reject(err) : resolve();
        });

    });
}