// promise可以链式操作，then返回的是一个值或者是一个promise对象
// promise2 = promise1.then(onFulfilled, onRejected);
/**
 * 
 * @param {promise} promise2        promise1.then返回的对象  
 * @param {[type]} x                promise1中onFulfilled的返回值
 * @param {[type]} resolve          promise2的resolve方法
 * @param {[type]} reject           promise2的reject方法
 */
function handlePromise(promise2,x,resolve,reject) {
  if (promise2 === x) {
    // 如果从onFulfilled中返回的x 就是promise2 就会导致循环引用报错
    return reject(new TypeError('循环引用'));
  }
  let called = false; // 避免多次调用
  if (x instanceof Promise) {
    // 如果 x 为 Promise ，则使 promise 接受 x 的状态
    if (x.status === 'pending') {
      x.then(y => {
        handlePromise(promise2,y,resolve,reject);
      }, r => {
        reject(r);
      })
    } else {
      x.then(resolve, reject);
    }
  } else if (x !== null && (typeof x === 'object' || typeof x === 'function')) {
    // 如果 x 为对象或者函数
    // 把 x.then 赋值给 then
    // 如果取 x.then 的值时抛出错误 e ，则以 e 为据因拒绝 promise
    try {
      // 如果 then 是函数，将 x 作为函数的作用域 this 调用之。传递两个回调函数作为参数，第一个参数叫做 resolvePromise ，第二个参数叫做 rejectPromise:
      let then = x.then;
      if (typeof then === 'function') {
        then.call(x, y => {
          // 如果 resolvePromise 或 rejectPromise 已经被调用，则忽略之
          if (called) return;
          called = true;
          handlePromise(promise2,y,resolve,reject);
        }, r => {
          if (called) return;
          called = true;
          reject(r)
        })
      } else {
        // 如果 x 不为对象或者函数，以 x 为参数执行 promise
        resolve(x);
      }
    } catch(e) {
      // 如果 resolvePromise 或 rejectPromise 已经被调用，则忽略之
      if(called) return;
      called = true;
      reject(e)
    }
  } else {
    // 如果 x 不为对象或者函数，以 x 为参数执行 promise
    resolve(x);
  }
}
class Promise1 { //创建一个Promise类
  constructor(executor) {
      this.status = 'pending'; //初始默认状态为pending
      this.value = undefined; //默认赋值为undefined
      this.reason = undefined; //默认赋值为undefined
      this.successStore = [];
      this.failStore = [];
      let resolve = (value) => {
          if (this.status === 'pending') { //只有状态为pending才能转换状态
              this.value = value; //将传递进来的的值赋给value保存
              this.status = 'resolved'; //将状态设置成resolved
              this.successStore.forEach(fn => fn());
          }
      }
      let reject = (reason) => {
          if (this.status === 'pending') { //只有状态为pending才能转换状态
              this.reason = reason; //将传递进来的失败原因赋给reason保存
              this.status = 'rejected'; //将状态设置成rejected
              this.failStore.forEach(fn => fn());
          }
      }
      try {
        executor(resolve, reject); 
    } catch (e) {
        reject(e); //如果发生错误，将错误放入reject中
    }
  }
  //等同于es5的Promise.prototype.then 当调用then的时候,根据状态，来执行不同的函数
  then(onFulfilled, onRejected) { 
    let promise2;
    // 处理参数默认值 保证参数后续能够继续执行
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };

    // 为了确保 onFulfilled 和 onRejected 方法异步执行(且应该在 then 方法被调用的那一轮事件循环之后的新执行栈中执行) 所以要在resolve里加上setTimeout
    // 对于一个promise，它的then方法可以调用多次.（当在其他程序中多次调用同一个promise的then时 由于之前状态已经为FULFILLED/REJECTED状态，则会走的下面逻辑),所以要确保为FULFILLED/REJECTED状态后 也要异步执行onFulfilled/onRejected

    if (this.status === 'resolved') { //如果状态是resolved
        promise2 = new Promise((resolve, reject) => {
          setTimeout(() => {
            try {
              let x = onFulfilled(this.value);
              handlePromise(promise2,x,resolve,reject);
            } catch (error) {
              reject(error);
            }
          })
        })
    }
    if (this.status === 'rejected') { //如果状态是rejected
        promise2 = new Promise((resolve, reject) => {
          setTimeout(() => {
            try {
              let x = onRejected(this.reason);
              handlePromise(promise2,x,resolve,reject);
            } catch (error) {
              reject(error);
            }
          })
        })
    }
    if (this.status === 'pending') {
      // 当异步调用resolve/rejected时 将onFulfilled/onRejected收集暂存到集合中
      // this.successStore.push(() => onFulfilled(this.value));
      // this.failStore.push(() => onRejected(this.reason));
      promise2 = new Promise((resolve, reject) => {
        this.successStore.push(() => {
          try {
            let x = onFulfilled(this.value);
            handlePromise(promise2,x,resolve,reject);
          } catch (error) {
            reject(error);
          }
        });

        this.failStore.push(() => {
          try {
            let x = onRejected(this.reason);
            handlePromise(promise2,x,resolve,reject);
          } catch (error) {
            reject(error);
          }
        })
      })
    }
    return promise2;
  }
}
// module.exports = Promise; //将Promise导出


const p = new Promise1((resolve, reject) => {
  setTimeout(() => {
            resolve('hi');
  }, 1000);
})
p.then((data) =>{
  console.log(data);
  return new Promise((resolve, reject) => {
    resolve('resolve')
  });
},(err) =>{
  console.log(err);
})
.then(data => {
  console.log(data)
}, err => {
  console.log(err)
})