class MyPromise {
  constructor(executor) {
    // 初始化Promise的狀態為pending
    this.state = 'pending';
    // 存儲Promise的成功值
    this.value = undefined;
    // 存儲Promise的失敗原因
    this.reason = undefined;
    // 存儲成功狀態下的回調函數數組
    this.onResolvedCallbacks = [];
    // 存儲失敗狀態下的回調函數數組
    this.onRejectedCallbacks = [];


    // 定義resolve函數，用于將Promise狀態從pending改變為fulfilled
    const resolve = value => {
      if (this.state === 'pending') {
        this.state = 'fulfilled';
        this.value = value;
        // 執行成功狀態下的回調函數數組中的每個回調函數
        this.onResolvedCallbacks.forEach(callback => callback());
      }
    };


    // 定義reject函數，用于將Promise狀態從pending改變為rejected
    const reject = reason => {
      if (this.state === 'pending') {
        this.state = 'rejected';
        this.reason = reason;
        // 執行失敗狀態下的回調函數數組中的每個回調函數
        this.onRejectedCallbacks.forEach(callback => callback());
      }
    };


    try {
      // 執行executor函數，并將resolve和reject函數作為參數傳遞給executor
      executor(resolve, reject);
    } catch (error) {
      // 如果executor執行過程中發生了錯誤，則將Promise狀態改變為rejected
      reject(error);
    }
  }


  // then方法用于注冊Promise的成功和失敗回調，并返回一個新的Promise
  then(onFulfilled, onRejected) {
    // 創建一個新的Promise實例
    const newPromise = new MyPromise((resolve, reject) => {
      // 當前Promise的狀態為fulfilled時
      if (this.state === 'fulfilled') {
        // 異步執行onFulfilled回調函數，并處理返回值result
        setTimeout(() => {
          try {
            const result = onFulfilled(this.value);
            // 將返回值result傳遞給resolvePromise函數，處理新Promise的狀態
            resolvePromise(newPromise, result, resolve, reject);
          } catch (error) {
            // 如果執行onFulfilled回調函數過程中發生了錯誤，則將新Promise的狀態改為rejected
            reject(error);
          }
        }, 0);
      }


      // 當前Promise的狀態為rejected時
      if (this.state === 'rejected') {
        // 異步執行onRejected回調函數，并處理返回值result
        setTimeout(() => {
          try {
            const result = onRejected(this.reason);
            // 將返回值result傳遞給resolvePromise函數，處理新Promise的狀態
            resolvePromise(newPromise, result, resolve, reject);
          } catch (error) {
            // 如果執行onRejected回調函數過程中發生了錯誤，則將新Promise的狀態改為rejected
            reject(error);
          }
        }, 0);
      }


      // 當前Promise的狀態為pending時
      if (this.state === 'pending') {
        // 將成功和失敗回調函數分別添加到對應的回調函數數組中
        this.onResolvedCallbacks.push(() => {
          // 異步執行成功回調函數，并處理返回值result
          setTimeout(() => {
            try {
              const result = onFulfilled(this.value);
              // 將返回值result傳遞給resolvePromise函數，處理新Promise的狀態
              resolvePromise(newPromise, result, resolve, reject);
            } catch (error) {
              // 如果執行成功回調函數過程中發生了錯誤，則將新Promise的狀態改為rejected
              reject(error);
            }
          }, 0);
        });


        this.onRejectedCallbacks.push(() => {
          // 異步執行失敗回調函數，并處理返回值result
          setTimeout(() => {
            try {
              const result = onRejected(this.reason);
              // 將返回值result傳遞給resolvePromise函數，處理新Promise的狀態
              resolvePromise(newPromise, result, resolve, reject);
            } catch (error) {
              // 如果執行失敗回調函數過程中發生了錯誤，則將新Promise的狀態改為rejected
              reject(error);
            }
          }, 0);
        });
      }
    });


    // 返回新的Promise實例
    return newPromise;
  }
}


// resolvePromise函數用于處理then方法中回調函數返回的結果
function resolvePromise(newPromise, result, resolve, reject) {
  // 如果新的Promise和返回值是同一個對象，則拋出錯誤
  if (newPromise === result) {
    return reject(new TypeError('Chaining cycle detected for promise'));
  }


  // 如果返回值是Promise實例，則等待該Promise的狀態改變，并根據其狀態決定新Promise的狀態
  if (result instanceof MyPromise) {
    result.then(resolve, reject);
  } else {
    // 如果返回值不是Promise實例，則將返回值傳遞給resolve函數，將新Promise的狀態改變為fulfilled
    resolve(result);
  }
}