// cache the original Array.prototype
const originalPrototype = Array.prototype

// create an object from original Array.prototype
const arrayMethods = Object.create(originalPrototype)

const methodsToPatch = [
  "push",
  "pop",
  "shift",
  "unshift",
  "splice",
  "sort",
  "reverse",
]

methodsToPatch.forEach((method) => {
  arrayMethods[method] = function (...args) {
    // use original Array methods to get the result
    const result = originalPrototype[method].apply(this, args)

    // proxy here
    console.log(`catch ${method}`)

    return result
  }
})

const a = [1, 2, 3]
a.__proto__ = arrayMethods

a.push(1)
a.reverse()
a.pop()

console.log(a)

promsie.then(onFulfilled, onRejected)

promise2 = promise1.then(onFulfilled, onRejected)

var PENDING = "pending"
var FULFILLED = "fulfilled"
var REJECTED = "rejected"

function Promise(fn) {
  this.status = PENDING // initial status
  this.value = null // initial value
  this.reason = null // initial reason
  this.onFulfilledCallbacks = []
  this.onRejectedCallbacks = []

  var _this = this

  function resolve(value) {
    if (_this.status === PENDING) {
      _this.status = FULFILLED
      _this.value = value

      _this.onFulfilledCallbacks.forEach((i) => i(_this.value))
    }
  }

  function reject(reason) {
    if (_this.status === PENDING) {
      _this.status = REJECTED
      _this.reason = reason

      _this.onRejectedCallbacks.forEach((i) => i(_this.reason))
    }
  }

  try {
    fn(resolve, reject)
  } catch (e) {
    reject(e)
  }
}

function resolvePromise(promise, x, resolve, reject) {
  if (promise === x) {
    reject(new TypeError("The promise and the return value are the same"))
  }

  if (x instanceof Promise) {
    x.then(function (y) {
      resolvePromise(promise, y, resolve, reject)
    }, reject)
  } else if (typeof x === "object" || typeof x === "function") {
    if (x === null) {
      return resolve(x)
    }

    try {
      var then = x.then
    } catch (e) {
      return reject(e)
    }

    if (typeof then === "function") {
      var called = false

      try {
        then.call(
          x,
          function (y) {
            if (called) return
            called = true
            resolvePromise(promise, y, resolve, reject)
          },
          function (r) {
            if (called) return
            called = true
            reject(r)
          }
        )
      } catch (e) {
        if (called) return

        reject(e)
      }
    } else {
      resolve(x)
    }
  } else {
    resolve(x)
  }
}

Promise.prototype.then = function (onFulfilled, onRejected) {
  var checkOnFulfilled = onFulfilled
  if (typeof onFulfilled !== "function") {
    checkOnFulfilled = function (value) {
      return value
    }
  }

  var checkOnRejected = onRejected
  if (typeof onRejected !== "function") {
    checkOnRejected = function (reason) {
      throw reason
    }
  }

  var _this = this

  if (this.status === FULFILLED) {
    // 如果前面的 promise 抛出异常，后面的必须拒绝执行
    var promise2 = new Promise(function (resolve, reject) {
      setTimeout(function () {
        try {
          if (typeof onFulfilled !== "function") {
            resolve(_this.value)
          } else {
            var x = checkOnFulfilled(_this.value)
            resolvePromise(promise2, x, resolve, reject)
          }
        } catch (e) {
          reject(e)
        }
      }, 0)
    })

    return promise2
  }

  if (this.status === REJECTED) {
    var promise2 = new Promise(function (resolve, reject) {
      setTimeout(function () {
        try {
          if (typeof onRejected !== "function") {
            reject(_this.reason)
          } else {
            var x = checkOnRejected(_this.reason)
            resolvePromise(promise2, x, resolve, reject)
          }
        } catch (e) {
          reject(e)
        }
      }, 0)
    })

    return promise2
  }

  if (this.status === PENDING) {
    var promise2 = new Promise(function (resolve, reject) {
      _this.onFulfilledCallbacks.push(function () {
        setTimeout(function () {
          try {
            if (typeof onFulfilled !== "function") {
              resolve(_this.value)
            } else {
              var x = checkOnFulfilled(_this.value)
              resolvePromise(promise2, x, resolve, reject)
            }
          } catch (e) {
            reject(e)
          }
        }, 0)
      })

      _this.onRejectedCallbacks.push(function () {
        setTimeout(function () {
          try {
            if (typeof onRejected !== "function") {
              reject(_this.reason)
            } else {
              var x = checkOnRejected(_this.reason)
              resolvePromise(promise2, x, resolve, reject)
            }
          } catch (e) {
            reject(e)
          }
        }, 0)
      })
    })

    return promise2
  }
}

Promise.resolve = function (parameter) {
  if (parameter instanceof Promise) {
    return parameter
  }

  return new Promise(function (resolve) {
    resolve(parameter)
  })
}

Promise.reject = function (reason) {
  return new Promise(function (resolve, reject) {
    reject(reason)
  })
}

Promise.all = function (promises) {
  return new Promise(function (resolve, reject) {
    var count = 0
    var result = []
    var len = promises.length

    if (length === 0) {
      return resolve(result)
    }

    promises.forEach(function (promise, index) {
      Promise.resolve(promise).then(
        function (value) {
          count++
          result[index] = value

          if (count === len) {
            resolve(result)
          }
        },
        function (reason) {
          reject(reason)
        }
      )
    })
  })
}

Promise.race = function (promises) {
  return new Promise(function (resolve, reject) {
    var len = promises.length

    if (length === 0) {
      return resolve()
    } else {
      for (var i = 0; i < len; i++) {
        Promise.resolve(promises[i]).then(
          function (value) {
            return resolve(value)
          },
          function (reason) {
            return reject(reason)
          }
        )
      }
    }
  })
}

Promise.catch = function (onRejected) {
  this.then(null, onRejected)
}

Promise.finally = function (fn) {
  return this.then(
    function (value) {
      return Promise.resolve(fn()).then(function () {
        return value
      })
    },
    function (error) {
      return Promise.resolve(fn()).then(function () {
        throw error
      })
    }
  )
}

Promise.allSettled = function (promises) {
  return new Promise(function (resolve) {
    var len = promises.length
    var result = []
    var count = 0

    if (len === 0) {
      resolve(result)
    } else {
      for (let i = 0; i < len; i++) {
        ;(function (i) {
          var current = Promise.resolve(promises[i])

          current.then(
            function (value) {
              count++
              result[i] = {
                status: "fulfilled",
                value,
              }

              if (count === len) {
                return resolve(result)
              }
            },
            function (reason) {
              count++
              result[i] = {
                status: "rejected",
                reason,
              }

              if (count === len) {
                return resolve(result)
              }
            }
          )
        })(i)
      }
    }
  })
}

// for promises-aplus-tests test
Promise.deferred = function () {
  var result = {}
  result.promise = new Promise(function (resolve, reject) {
    result.resolve = resolve
    result.reject = reject
  })

  return result
}

module.exports = Promise