function MyPromise(executor) {
  let self = this;
  self.status = 'pending';       // 初始状态
  self.value = undefined;        // 成功时的值
  self.reason = undefined;       // 失败时的原因
  self.onResolvedCallbacks = []; // 存储成功的回调
  self.onRejectedCallbacks = []; // 存储失败的回调

  function resolve(value) {
    if (self.status === 'pending') {
      self.status = 'fulfilled';
      self.value = value;
      self.onResolvedCallbacks.forEach(fn => fn());
    }
  }

  function reject(reason) {
    if (self.status === 'pending') {
      self.status = 'rejected';
      self.reason = reason;
      self.onRejectedCallbacks.forEach(fn => fn());
    }
  }

  // 立即执行 executor 函数
  try {
    executor(resolve, reject);
  } catch (err) {
    reject(err); // 如果执行出错，直接进入 reject
  }
}

MyPromise.prototype.then = function(onFulfilled, onRejected) {
  let self = this;
  // 解决 onFulfilled、onRejected 不传的情况
  onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : val => val;
  onRejected = typeof onRejected === 'function' ? onRejected : err => { throw err; };

  // 返回一个新的 Promise，实现链式调用
  let promise2 = new MyPromise((resolve, reject) => {
    if (self.status === 'fulfilled') {
      setTimeout(() => {
        try {
          let x = onFulfilled(self.value);
          resolvePromise(promise2, x, resolve, reject);
        } catch (e) {
          reject(e);
        }
      }, 0);
    }

    if (self.status === 'rejected') {
      setTimeout(() => {
        try {
          let x = onRejected(self.reason);
          resolvePromise(promise2, x, resolve, reject);
        } catch (e) {
          reject(e);
        }
      }, 0);
    }

    if (self.status === 'pending') {
      // 如果状态还未改变，说明异步操作未完成，先存储回调
      self.onResolvedCallbacks.push(() => {
        setTimeout(() => {
          try {
            let x = onFulfilled(self.value);
            resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        }, 0);
      });

      self.onRejectedCallbacks.push(() => {
        setTimeout(() => {
          try {
            let x = onRejected(self.reason);
            resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        }, 0);
      });
    }
  });

  return promise2;
};

function resolvePromise(promise2, x, resolve, reject) {
  // 防止循环引用
  if (x === promise2) {
    return reject(new TypeError('Chaining cycle detected for promise'));
  }

  let called = false; // 确保只调用一次 resolve 或 reject

  // 如果 x 是对象或函数，才可能是 Promise
  if (x != null && (typeof x === 'object' || typeof x === 'function')) {
    try {
      let then = x.then;

      // 如果 x 是 Promise，则采用它的状态
      if (typeof then === 'function') {
        then.call(x, y => {
          if (called) return;
          called = true;
          resolvePromise(promise2, y, resolve, reject); // 递归解析
        }, r => {
          if (called) return;
          called = true;
          reject(r);
        });
      } else {
        // x 是普通对象
        resolve(x);
      }
    } catch (e) {
      if (called) return;
      called = true;
      reject(e);
    }
  } else {
    // x 是基本类型值
    resolve(x);
  }
}

// MyPromise.resolve
MyPromise.resolve = function(value) {
  return new MyPromise(resolve => resolve(value));
};

// MyPromise.reject
MyPromise.reject = function(reason) {
  return new MyPromise((resolve, reject) => reject(reason));
};

// MyPromise.all
MyPromise.all = function(promises) {
  return new MyPromise((resolve, reject) => {
    let result = [];
    let count = 0;
    if (promises.length === 0) return resolve(result);

    for (let i = 0; i < promises.length; i++) {
      MyPromise.resolve(promises[i]).then(
        val => {
          result[i] = val;
          count++;
          if (count === promises.length) {
            resolve(result);
          }
        },
        err => reject(err)
      );
    }
  });
};