import 'typings-global'
import * as util from 'util'

export interface IResolve<T> {
  (value?: T | Promise<T>): void
}

export interface IReject {
  (reason?: any): void
}

export type TDeferredStatus = 'pending' | 'fulfilled' | 'rejected'

export class Deferred<T> {
  promise: Promise<T>
  resolve: IResolve<T>
  reject: IReject
  status: TDeferredStatus
  constructor () {
    this.promise = new Promise<T>((resolve, reject) => {
      this.resolve = resolve
      this.reject = reject
      this.status = 'pending'
    })
  }
}

export let defer = <T>() => {
  return new Deferred<T>()
}

/**
 * Creates a new resolved promise for the provided value.
 */
export let resolvedPromise = <T>(value?: T): Promise<T> => {
  return Promise.resolve(value)
}

/**
 * Creates a new rejected promise for the provided reason.
 */
export let rejectedPromise = (err) => {
  return Promise.reject(err)
}

export let promisify = util.promisify

// polyfill
if (!promisify) {
  promisify = require('util.promisify')
}
export let map = async <T> (inputArg: T[],functionArg) => {
  let promisifedFunction = promisify(functionArg)
  let promiseArray: Promise<any>[] = []
  let resultArray = []
  for (let item of inputArg) {
    let promise: Promise<any> = promisifedFunction(item)
    promiseArray.push(promise)
    promise.then(x => {
      resultArray.push(x)
    })

  }
  await Promise.all(promiseArray)
  return resultArray
}