/**
 * promise的一些操作
 */


/**
 * promise是一種異步編程解決方案阻逮，通俗說(shuō)就是一個(gè)存放未來(lái)才會(huì)結(jié)束的事件的容器
 * promise有三種狀態(tài)
 * 1.fulfilled:執(zhí)行成功返回狀態(tài)
 * 2.pending:正在執(zhí)行中的狀態(tài),也有說(shuō)是初始狀態(tài)掐隐，既不是成功,也不是失敗
 * 3.rejected:執(zhí)行失敗返回的狀態(tài)
 * 狀態(tài)一旦發(fā)生改變就不會(huì)再變,比如由pending->rejected或者由pending->到fulfilled,就會(huì)一直保持失敗或者成功的狀態(tài),無(wú)法改變
 * Promise實(shí)例有兩個(gè)方法坦敌，catch和then
 * then可以鏈?zhǔn)秸{(diào)用，catch可以捕捉多個(gè)promise中拋出的錯(cuò)誤荆虱，但是拋出錯(cuò)誤的后續(xù)的promise不再執(zhí)行了
 * node中有專門捕捉未監(jiān)聽(tīng)的reject錯(cuò)誤事件:unhandledRejection
 * process.on('unhandledRejection',function(err,p){
 *     console.error(err.stack)
 * })
 */


/**
 * promise.then屬于微任務(wù)荐虐，在宏任務(wù)執(zhí)行完成后才會(huì)執(zhí)行
 * 執(zhí)行過(guò)程:
 *  1.console.log('start')被執(zhí)行,輸出'start'
 *  2.async1執(zhí)行,加入microtask隊(duì)列
 *  3.setTimeout執(zhí)行,加入macrotask隊(duì)列
 *  4.promise1執(zhí)行藕夫，他的兩個(gè)then加入microtask隊(duì)列
 *  5.console.log('end')被執(zhí)行,輸出'end'
 *  6.按照事件循環(huán)的定義,接下來(lái)會(huì)執(zhí)行新增的microtask任務(wù),再執(zhí)行加macrotask任務(wù),所以第一次事件循環(huán)
 *  的輸出結(jié)果為:start,async2,promise,end,這時(shí)候microtask隊(duì)列為空,執(zhí)行下一輪循環(huán),從macrotask
 *  隊(duì)列里取位于隊(duì)首的任務(wù)(async1)并執(zhí)行,輸出async1,以此類推
 */
console.log('start')

async function async1() {
  await async2()
  console.log('async1')
}

async function async2() {
  console.log('async2')
}

async1()

setTimeout(function () {
  console.log('setTimeout')
}, 0)

new Promise(resolve => {
  console.log('promise1')
  resolve()
}).then(() => {
  console.log('promise2')
}).then(() => {
  console.log('promise3')
})

console.log('end')


/**
 * new Promise((reslove,reject)=>{}):返回一個(gè)Promise對(duì)象
 * Promise.all():將多個(gè)Promise實(shí)例包裝成一個(gè)新的Promise實(shí)例,參數(shù)不一定是數(shù)組，但一定具有iterable接口,
 * 所有的Promise都成功才觸發(fā)成功,若一個(gè)失敗則失敗
 * Promise.race():跟參數(shù)和all()方法一樣,iterable參數(shù)中的一個(gè)成功或者失敗都會(huì)立即觸發(fā)返回對(duì)象的成功和失敗
 * 比如:實(shí)現(xiàn)如下調(diào)用渴语，lazyMan('xxx').sleep(1000).eat('333').sleepFirst(2000) sleepFirst最先執(zhí)行苹威。
 */
function lazyMan(name) {
  this.task = []
  this.task.push(() => {
    return new Promise(resolve => {
      console.log('name:', name);
      resolve()
    })
  })
  //將事件形成鏈?zhǔn)秸{(diào)用
  let run = () => {
    let sequence = Promise.resolve()
    for (let func of this.task) {
      sequence = sequence.then(() => func())
    }
  }
  //根據(jù)事件循環(huán),通過(guò)定時(shí)器將事件鏈?zhǔn)秸{(diào)用
  setTimeout(() => {
    run()
  }, 0)

  this.sleep = (time) => {
    this.task.push(() => {
      return new Promise(resolve => {
        setTimeout(() => {
          console.log('sleep:', time);
          resolve()
        }, time)

      })
    })
    return this
  }
  this.eat = (str) => {
    this.task.push(() => {
      return new Promise(resolve => {
        console.log('eat:', str);
        resolve()
      })
    })
    return this
  }
  //將sleepFirst推到任務(wù)隊(duì)列的第一個(gè)
  this.sleepFirst = (time) => {
    this.task.unshift(() => {
      return new Promise((resolve) => {
        setTimeout(() => {
          console.log('sleepFirst:', time);
          resolve()
        }, time)

      })
    })
    return this
  }
  return this
}
lazyMan('xxx').sleep(300).eat('333').sleepFirst(200)


/**
 * 任務(wù)隊(duì)列可不斷的添加異步任務(wù)（異步任務(wù)都是Promise），但只能同時(shí)處理5個(gè)任務(wù)驾凶，
 * 5個(gè)一組執(zhí)行完成后才能執(zhí)行下一組牙甫，任務(wù)隊(duì)列為空時(shí)暫停執(zhí)行，當(dāng)有新任務(wù)加入則自動(dòng)執(zhí)行调违。
 */
class RunQune {
  constructor() {
    this.list = [] //任務(wù)隊(duì)列數(shù)組
    this.targe = 5 //并發(fā)數(shù)量
    this.flag = false //任務(wù)執(zhí)行狀態(tài)
    this.date = Date.now()
  }
  //模擬任務(wù)執(zhí)行等待時(shí)間
  static async sleep(time) {
    return new Promise(resolve => {
      setTimeout(resolve, time)
    })
  }
  static async run() {
    while (this.list.length > 0) {
      this.flag = true
      let runList = list.slice(0, this.targe)
      this.date = Date.now()
      await this.runItem(runList)
      await this.sleep(1000)
    }
    this.flag = false
  }
  static async runItem(list) {
    return new Promise(resolve => {
      while (list.length > 0) {
        const fn = list.shift()
        fn().then().finally(() => {
          if (list.length === 0) {
            resolve()
          }
        })
      }
    })
  }

  //加入任務(wù)
  static push(task) {
    this.list.push(...task);
    !this.flag && this.run()
  }
}


/**
 * 手動(dòng)實(shí)現(xiàn)一個(gè)promise
 */
function MyPromise(executor) {
  this.status = 'pending' // pending 窟哺， fulfilled ， rejected
  this.data = '' // 當(dāng)前promise的值技肩，主要用于 then 方法中的 fulfilled 且轨， rejected 兩種狀態(tài)的處理
  this.resolveFuncList = [] //  使用數(shù)組的原因是，一個(gè)promise可以同時(shí)執(zhí)行多個(gè) then 方法虚婿， 也就會(huì)同時(shí)存在多個(gè)then回調(diào)
  this.rejectFunc;
  let self = this

  function resolve(value) {
    setTimeout(() => {
      if (self.status === 'pending') {
        self.status = 'fulfilled'
        self.data = value
        self.resolveFuncList.forEach(func => {
          func(value)
        })
      }
    })
  }

  function reject(reason) {
    setTimeout(() => {
      if (self.status === 'pending') {
        self.status = 'rejected'
        self.data = value
        self.rejectFunc && self.rejectFunc(reason)
      }
    })
  }
  try {
    executor(resolve, reject)
  } catch (e) {
    reject(e)
  }
}

function resolvePromise(promise2, val, resolve, reject) {
  if (val instanceof MyPromise) {
    if (val.status === 'pending') {
      val.then(value => {
        resolvePromise(promise2, value, resolve, reject)
      }, reason => {
        reject(reason)
      })
    } else {
      val.then(resolve, reject)
    }
  } else {
    resolve(val)
  }
}

MyPromise.prototype.then = function (onFulfilled, onRejected) {
  let promise2
  if (this.status === 'pending') {
    return promise2 = new MyPromise((res, rej) => {
      this.resolveFuncList.push(function (value) {
        let val = onFulfilled(value) //輸出將上一次執(zhí)行結(jié)果
        resolvePromise(promise2, val, res, rej)
      })
      this.rejectFunc = function (reason) {
        let val = onRejected(reason)
        resolvePromise(promise2, val, res, rej)
      }
    })
  }
  if (this.status === 'fulfilled') {
    return promise2 = new MyPromise((res, rej) => {
      setTimeout(() => {
        let val = onFulfilled(this.data)
        resolvePromise(promise2, val, res, rej)
      })
    })
  }
  if (this.status === 'rejected') {
    return promise2 = new Promise((res, rej) => {
      setTimeout(() => {
        let val = onRejected(this.data)
        resolvePromise(promise2, val, res, rej)
      })
    })
  }
}

async function test() {
  return new MyPromise((resolve, reject) => {
    resolve('ceshi')
  })
}
async function test1() {
  await test().then(r => {
    console.log(r)
  })
}
test1()


/**
 * 實(shí)現(xiàn)promise.all()
 */
Promise.all = function (promises) {
  return new Promise((resolve, reject) => {
    let values = []
    let count = 0
    promises.forEach((promise, index) => {
      promise.then(value => {
        values[index] = value
        count++
        if (count === promises.length) {
          resolve(values)
        }
      }, reject)
    })
  })
}

/**
 * 實(shí)現(xiàn)promsie.race()
 */

Promise.race = function (promises) {
  return new Promise((resolve, reject) => {
    promises.forEach((promise, index) => {
      promise.then(resolve, reject)
    })
  })
}