// promise 的特點(diǎn)
    // 狀態(tài): pending => resolved / rejected, 單向單次轉(zhuǎn)換, 一旦改變就不會(huì)再改變
    // promise.prototype.then 返回的是一個(gè) promise 對(duì)象, 狀態(tài)由回調(diào)函數(shù)的返回值決定
    // 返回值: 由對(duì)應(yīng)狀態(tài)的處理函數(shù)(resolve, reject函數(shù))返回, 這個(gè)值會(huì)傳遞給 then

    // then 方法里面的兩個(gè)參數(shù)也是函數(shù), 兩個(gè)函數(shù)的返回值都有如下兩種情況:
    // 1. 處理函數(shù)的返回值是非 promise 對(duì)象(普通數(shù)據(jù)), then 方法返回一個(gè)狀態(tài)為 resolved 的 promise 對(duì)象
    // 2. 處理函數(shù)返回值是 promise 對(duì)象, then 方法返回的 promise 對(duì)象的狀態(tài)由處理函數(shù)的狀態(tài)決定
class myPromise {
    constructor(fn){
        // new Promise 對(duì)象的參數(shù)一定是一個(gè)函數(shù), 這個(gè)函數(shù)的兩個(gè)參數(shù)也是兩個(gè)函數(shù).
        if (typeof fn !== 'function'){
            throw TypeError(`Promise resolver ${fn} is not a function`);
        } else {    // 如果是函數(shù), 則進(jìn)入正常的 Promise 代碼執(zhí)行.
            //  若傳遞參數(shù)是函數(shù), 那么它會(huì)執(zhí)行, 但是兩個(gè)參數(shù)函數(shù)是 promise 的狀態(tài)處理函數(shù)
            //  在原生的 Promise 對(duì)象中, resolve reject, 是內(nèi)部定義好的. 我們也需要在內(nèi)部定義

            let resolve = data => {

                setTimeout( () => {
                    if (this.status === 'pending'){  // 如果狀態(tài)是 pending, 才允許改變
                        this.status = 'resolved';
                        this.data = data;
                        if(this.resolveCB.length > 0){
                            this.resolveCB.forEach( fn => fn() );
                        }
                    }
                }, 0);
            };
            let reject = error => {
                // 狀態(tài)改變, 若是執(zhí)行 reject 函數(shù), 狀態(tài)改變?yōu)?rejected, 數(shù)據(jù)存儲(chǔ)
                setTimeout( () => {
                    if (this.status === 'pending'){  // 如果狀態(tài)是 pending, 才允許改變
                        this.status = 'rejected';
                        this.data = error;
                        if(this.rejectCB.length > 0){
                            this.rejectCB.forEach( fn => fn() );
                        }
                    }
                }, 0);
            };
            // 狀態(tài)改變, 若是執(zhí)行 resolve 函數(shù), 狀態(tài)改變?yōu)?resolved, 數(shù)據(jù)存儲(chǔ)
            this.status = 'pending';    //  promise 一開始的默認(rèn)狀態(tài)是 pending
            this.data = undefined;      //  數(shù)據(jù)是undefined

            // 這兩個(gè)屬性是兩個(gè)函數(shù), 用來(lái)存儲(chǔ) then 方法中第三種情況, 來(lái)不及做的要做的事情
            this.resolveCB = [];
            this.rejectCB = [];
            fn(resolve, reject);
        }
    }
    // myPromise 原型上的方法 then
    // 參數(shù)是兩個(gè)函數(shù), 第一個(gè)用來(lái)處理 resolved 狀態(tài), 第二個(gè)處理 reject 狀態(tài)
    then(onResolve, onReject){
        // 無(wú)論怎樣, then 的返回值都是一個(gè) promise 對(duì)象
        // 所以, 無(wú)論那種情況, 都需要 return 一個(gè) promise 對(duì)象
        if (this.status === 'resolved'){
            return new myPromise((resolve, reject) => {
                // 根據(jù) onResolved 函數(shù)的執(zhí)行結(jié)果, 決定 promise 對(duì)象的狀態(tài), 需要判斷結(jié)果的類型
                // 我們使用 res 保存一下
                let res = onResolve(this.data); // this.data 就是 promise 中 resolve 或者 reject 保存的數(shù)據(jù)

                //  如果 res 是 promise 對(duì)象
                if(res instanceof myPromise){
                    // 如果 res 是一個(gè) promise 對(duì)象, 那么一定要去觸發(fā) then 方法.
                    res.then(resolve, reject);
                } else {    // 如果不是 promise 對(duì)象, 讓 promise 的狀態(tài)變成 resolved 即可
                    resolve(res);
                }
            })
        } else if ( this.status === 'rejected'){
            return new myPromise((resolve, reject) => {
                let res = onReject(this.data);

                //  如果 res 是 promise 對(duì)象
                if(res instanceof myPromise){
                    res.then(resolve, reject);
                } else {    // 如果不是 promise 對(duì)象
                    resolve(res); // 返回狀態(tài)為 resolved 的 promise 對(duì)象
                }
            })
        } else if ( this.status === 'pending'){
            // 上面兩個(gè) if 分別處理了 resolved 和 rejected 狀態(tài)
            // 但是當(dāng) promise 內(nèi)部是一個(gè)延時(shí)定時(shí)器的時(shí)候, 代碼執(zhí)行到這里, 定時(shí)器的時(shí)間還沒(méi)有到達(dá), 代碼沒(méi)有執(zhí)行
            // 狀態(tài)就一直是 pending, 因?yàn)?js 引擎不會(huì)等. 但是最終那個(gè)數(shù)據(jù)還是接收到了
            // 錯(cuò)過(guò)了就是錯(cuò)過(guò)了

            // 定時(shí)器不知道什么時(shí)候結(jié)束, 狀態(tài)改變之后, 又不會(huì)觸發(fā)這件事了
            // 我們需要把這個(gè)要做的事情存儲(chǔ)起來(lái), 等狀態(tài)改變之后, 再去判斷要走 resolved 還是 rejected
            return new myPromise((resolve, reject) => {
                // 因?yàn)樘幚頎顟B(tài)需要用到數(shù)據(jù), 就需要傳遞參數(shù)
                // 所以不可能寫成 this.resolveCB = 函數(shù)名 的形式, 需要用到閉包
                /*--------------------------閉包---------------------------*/
                this.resolveCB.push((resolveFn => {
                    return () => {
                        let res = resolveFn && resolveFn(this.data);
                        if( res instanceof myPromise){
                            res.then(resolve, reject);
                        } else {
                            resolve(res);
                        }
                    };
                })(onResolve));
                /*--------------------------閉包---------------------------*/
                this.rejectCB.push((rejectFn =>{
                    return () => {
                        let res = rejectFn && rejectFn(this.data);
                        if( res instanceof myPromise){
                            res.then(resolve, reject);
                        } else {
                            resolve(res);
                        }
                    };
                })(onReject));
                /*---------------------------------------------------------*/
            });
        }
    }
}