//申明常量  promise的3個(gè)基本狀態(tài)
const SUCCESS = 'fulfilled';
const FAIL = 'rejected';
const PENDING = 'pending';
//返回的那個(gè)新的promise  x是then方法中的返回值
function resolvePromise(promise2,x,resolve,reject){
    if(promise2 === x){
        reject(new TypeError('TypeError: Chaining cycle detected for promise #<Promise>'));
    }
    let called;   
    //判斷x的類型
    //promise 有n種實(shí)現(xiàn)方式  都符合這個(gè)規(guī)范  兼容別人的 promise
    //怎么判斷 x是不是一個(gè) promise  看他有沒(méi)有then方法
    if(typeof x === 'function' || (typeof x === 'object' && x != null)){
        try{
            let then = x.then;   //取then可能會(huì)報(bào)錯(cuò)
            if(typeof then === 'function'){
                then.call(x,y=>{   //如果promise是成功的就把結(jié)果往下傳，如果失敗的就讓下一個(gè)人也失敗
                    if(called) return;  //1）//為了辨別這個(gè)promise不能多次調(diào)用
                    called = true;
                    resolvePromise(promise2,y,resolve,reject)
                },r=>{
                    if(called) return;  //2）//為了辨別這個(gè)promise不能多次調(diào)用
                    called = true;
                    reject(r)
                })   //避免取多次   不要使用x.then()  否則會(huì)再次取值
            }else{
                resolve(x)
            }
        }catch(e){
            if(called) return;  //3）//為了辨別這個(gè)promise不能多次調(diào)用
            called = true;
            reject(e)
        }
    }else{
        resolve(x)   // 只要是一個(gè)普通值就需要接著往下面拋
    }
}
class Promise{
    constructor(executor){   //executor 執(zhí)行器   只要new Promise()的時(shí)候就會(huì)執(zhí)行
      
        this.status = PENDING;   //默認(rèn)狀態(tài)為等待態(tài)
        this.value = undefined;   //then  回調(diào)成功的返回值
        this.reason = undefined;   //then   回調(diào)失敗的返回值
        this.onResolveCallbacks = [];   //成功所有的回調(diào)   只有pending的時(shí)候才存儲(chǔ)
        this.onRejectedCallbacks = []; //失敗所有的回調(diào)   只有pending的時(shí)候才存儲(chǔ)
        
        let resolve = (value)=>{     //成功回調(diào)函數(shù)   改變狀態(tài)并保存返回值
            if(value instanceof Promise){   //如果resolve的結(jié)果是一個(gè)promise
                return value.then(resolve,reject)   //那么會(huì)讓這個(gè)promise執(zhí)行，將執(zhí)行后的結(jié)果再傳遞給 resolve或者reject中
            }
            if(this.status === PENDING){   //只有在等待態(tài)的時(shí)候才能改變狀態(tài)
                this.value = value;
                this.status = SUCCESS;
                this.onResolveCallbacks.forEach(fn => fn())
            }
        }
        let reject = (reason)=>{   //失敗回調(diào)函數(shù)   改變狀態(tài)并保存返回值
            if(this.status === PENDING){   //只有在等待態(tài)的時(shí)候才能改變狀態(tài)
                this.reason = reason;
                this.status = FAIL;
                this.onRejectedCallbacks.forEach(fn => fn())
            }
        }
        try{   //在new Promise的時(shí)候可能內(nèi)部會(huì)拋錯(cuò)誤啄骇，所以需要try catch
            executor(resolve,reject);   //只要new Promise()的時(shí)候就會(huì)執(zhí)行  并且可傳遞兩個(gè)回調(diào)函數(shù)  成功冠场、失敗
        }catch(e){
            reject(e);
        }
    }
    then(onFulfilled,onRejected){   //根據(jù)狀態(tài)執(zhí)行不同的函數(shù)
        onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : val => val;
        onRejected = typeof onRejected === 'function' ? onRejected : err => {throw err};
        let promise2;
        //可以不停的調(diào)用then方法,返回了一個(gè)新的promise
        promise2 = new Promise((resolve,reject)=>{
            if(this.status === SUCCESS){
                setTimeout(()=>{   //定時(shí)器解決調(diào)用resolvePromise的時(shí)候promise2為undefined
                    try{   //執(zhí)行的時(shí)候拋出錯(cuò)誤灾搏，需要try catch 捕獲
                        //調(diào)用當(dāng)前then方法的結(jié)果漂羊，來(lái)判斷當(dāng)前這個(gè)promise2是成功還是失敗
                        let x = onFulfilled(this.value)
                        //這里的x是普通值還是promise
                        //如果這個(gè)是promise呢稽寒？
                        resolvePromise(promise2,x,resolve,reject)
                    }catch(err){
                        reject(err)
                    }
                })
                
            }
    
            if(this.status === FAIL){
                setTimeout(()=>{
                    try{
                        let x = onRejected(this.reason);
                        resolvePromise(promise2,x,resolve,reject)
                   }catch(err){
                        reject(err)
                   }
                })
            }
    
            if(this.status === PENDING){   //多次調(diào)用并且pending的時(shí)候存儲(chǔ)函數(shù)  
                this.onResolveCallbacks.push(()=>{
                    setTimeout(()=>{
                        try{
                            let x = onFulfilled(this.value)
                            resolvePromise(promise2,x,resolve,reject)
                        }catch(err){
                            reject(err)
                        }
                    })
                })
    
                this.onRejectedCallbacks.push(()=>{
                    setTimeout(()=>{
                        try{
                            let x = onRejected(this.reason);
                            resolvePromise(promise2,x,resolve,reject)
                        }catch(err){
                            reject(err)
                        }
                    })
                })
            }
        })
        return promise2;
        
    }
    catch(errCallback){   //用來(lái)捕獲錯(cuò)誤
        return this.then(null,errCallback)
    }
    
}
//希望測(cè)試一下這個(gè)庫(kù)是否符合promise A+規(guī)范
//promises-aplus-tests
Promise.defer = Promise.deferred = function(){
    let dfd = {};
    dfd.promise = new Promise((resolve,reject)=>{
        dfd.resolve = resolve;
        dfd.reject = reject;
    });
    return dfd;
}
module.exports = Promise;