import { EventEmitter } from "../";

/**
 * promise
 */

export namespace promise {
    // region Functions

    /**
     * Determines whether a {@code value} should be treated as a promise.
     * Any object whose 'then' property is a function will be considered a
     * promise.
     */
    function isPromise(value: any): boolean;

    /**
     * Creates a promise that will be resolved at a set time in the future.
     */
    function delayed(ms: number): Promise<void>;

    /**
     * Calls a function for each element in an array, and if the function returns
     * true adds the element to a new array.
     *
     * If the return value of the filter function is a promise, this function
     * will wait for it to be fulfilled before determining whether to insert the
     * element into the new array.
     *
     * If the filter function throws or returns a rejected promise, the promise
     * returned by this function will be rejected with the same reason. Only the
     * first failure will be reported; all subsequent errors will be silently
     * ignored.
     */
    function filter<T, V>(
        arr: T[] | Promise<T[]>,
        fn: (element: T, index: number, array: T[]) => V,
        // value
        optSelf?: any,
    ): Promise<V[]>;

    /**
     * Calls a function for each element in an array and inserts the result into a
     * new array, which is used as the fulfillment value of the promise returned
     * by this function.
     *
     * If the return value of the mapping function is a promise, this function
     * will wait for it to be fulfilled before inserting it into the new array.
     *
     * If the mapping function throws or returns a rejected promise, the
     * promise returned by this function will be rejected with the same reason.
     * Only the first failure will be reported; all subsequent errors will be
     * silently ignored.
     */
    function map<T, V>(
        arr: T[] | Promise<T[]>,
        fn: (self: any, type: T, index: number, array: T[]) => V,
        optSelf?: any,
    ): Promise<V[]>;

    /**
     * Wraps a function that expects a node-style callback as its final
     * argument. This callback expects two arguments: an error value (which will
     * be null if the call succeeded), and the success value as the second
     * argument. The callback will the resolve or reject the returned promise,
     * based on its arguments.
     */
    function checkedNodeCall<T>(fn: Function, ...varArgs: any[]): Promise<T>;

    /**
     * Returns a promise that will be resolved with the input value in a
     * fully-resolved state. If the value is an array, each element will be fully
     * resolved. Likewise, if the value is an object, all keys will be fully
     * resolved. In both cases, all nested arrays and objects will also be
     * fully resolved.  All fields are resolved in place; the returned promise
     * will resolve on {@code value} and not a copy.
     *
     * Warning: This function makes no checks against objects that contain
     * cyclical references:
     *
     *     var value = {};
     *     value['self'] = value;
     *     promise.fullyResolved(value);  // Stack overflow.
     */
    function fullyResolved(value: any): Promise<any>;

    /**
     * Registers a listener to invoke when a promise is resolved, regardless
     * of whether the promise's value was successfully computed. This function
     * is synonymous with the {@code finally} clause in a synchronous API:
     *
     *     // Synchronous API:
     *     try {
     *       doSynchronousWork();
     *     } finally {
     *       cleanUp();
     *     }
     *
     *     // Asynchronous promise API:
     *     doAsynchronousWork().finally(cleanUp);
     *
     * __Note:__ similar to the {@code finally} clause, if the registered
     * callback returns a rejected promise or throws an error, it will silently
     * replace the rejection error (if any) from this promise:
     *
     *     try {
     *       throw Error('one');
     *     } finally {
     *       throw Error('two');  // Hides Error: one
     *     }
     *
     *     let p = Promise.reject(Error('one'));
     *     promise.finally(p, function() {
     *       throw Error('two');  // Hides Error: one
     *     });
     */
    function thenFinally<R>(promise: any, callback: () => R | Promise<R>): Promise<R>;

    // endregion
}