const PENDING = 'pending' //等待
const FULFILLED = 'fulfilled' //成功
const REJECTED = 'rejected' //失敗

const fulfilledCallback = [] //成功回調(diào)函數(shù)
const rejectedCallback = []  //失敗回調(diào)函數(shù)

class MyPromise {
   
    constructor (executor) {
        
        try{
            executor(this.resolve, this.reject)
        } catch (e){
            this.reject(e)
        }
    }

    status = PENDING//promise的狀態(tài)
    value = undefined//成功之后的值
    reason = undefined//失敗之后的值
    fulfilledCallback = [] //成功回調(diào)函數(shù)
    rejectedCallback = []  //失敗回調(diào)函數(shù)
    resolve = value => {
        //如果狀態(tài)不是等待, 阻止程序繼續(xù)往下執(zhí)行
        if(this.status !== PENDING){
            return
        }
        this.status = FULFILLED
        this.value = value
        //判斷成功回調(diào)是否存在,如果存在, 調(diào)用
        // this.fulfilledCallback && this.fulfilledCallback(this.value)
        while(this.fulfilledCallback.length) this.fulfilledCallback.shift()()

    }
    reject = reason => {
        //如果狀態(tài)不是等待, 阻止程序繼續(xù)往下執(zhí)行
        if(this.status !== PENDING){
            return
        }
        this.status = REJECTED
        this.reason = reason
        //判斷失敗回調(diào)是否存在,如果存在, 調(diào)用
        // this.rejectedCallback && this.rejectedCallback(this.reason)
        while(this.rejectedCallback.length) this.rejectedCallback.shift()()
    }
    then = (fulfilledCallback, rejectedCallback) => {
        fulfilledCallback = fulfilledCallback ? fulfilledCallback : value => value
        rejectedCallback = rejectedCallback ? rejectedCallback : reason => {throw reason}
        let promise2 = new MyPromise((resolve, reject) => {
            
            //判斷狀態(tài)
            if(this.status === FULFILLED){
                setTimeout(() => {
                    try {
                        //判斷x 傳過來的可能是promise,先查看promise返回的結(jié)果,在決定是用resolve還是reject,
                        //如果是普通值,直接調(diào)用resolve
                        let x = fulfilledCallback(this.value)
                        //外面加載完,才能獲取到promise2,用異步解決
                        resolvePromise(promise2,x,resolve, reject)
                    } catch (error) {
                        reject(error)
                    }
                    
                },0)
               
            }else if(this.status === REJECTED){
                
                setTimeout(() => {
                    try {
                        //判斷x 傳過來的可能是promise,先查看promise返回的結(jié)果,在決定是用resolve還是reject,
                        //如果是普通值,直接調(diào)用resolve
                        let x = rejectedCallback(this.reason)
                        //外面加載完,才能獲取到promise2,用異步解決
                        resolvePromise(promise2,x,resolve, reject)
                    } catch (error) {
                        reject(error)
                    }
                    
                },0)
            }else{
                //等待狀態(tài)
                this.fulfilledCallback.push(() => {
                    setTimeout(() => {
                        try {
                            //判斷x 傳過來的可能是promise,先查看promise返回的結(jié)果,在決定是用resolve還是reject,
                            //如果是普通值,直接調(diào)用resolve
                            let x = fulfilledCallback(this.value)
                            //外面加載完,才能獲取到promise2,用異步解決
                            resolvePromise(promise2,x,resolve, reject)
                        } catch (error) {
                            reject(error)
                        }
                        
                    },0)
                });
                this.rejectedCallback.push(() => {
                    setTimeout(() => {
                        try {
                            //判斷x 傳過來的可能是promise,先查看promise返回的結(jié)果,在決定是用resolve還是reject,
                            //如果是普通值,直接調(diào)用resolve
                            let x = rejectedCallback(this.reason)
                            //外面加載完,才能獲取到promise2,用異步解決
                            resolvePromise(promise2,x,resolve, reject)
                        } catch (error) {
                            reject(error)
                        }
                        
                    },0)
                });
            }
        })
        return promise2
    }

    static all (array) {
        let result= []
        let index = 0;

        return new MyPromise((resolve, reject) => {

            function addData (key, value) {
                result[key] = value
                index++
                if (index === array.length) {
                    resolve(result)
                }
            }

            for (let i = 0; i < array.length; i++) {
                
                if (array[i] instanceof MyPromise) {
                    //promise對象
                    array[i].then(value => addData(i, value), reason => reject(reason))
                } else {
                    //普通值, 放到數(shù)組里
                    addData(i, array[i])
                }
            }
        })

    }

    static resolve (value) {
        if(value instanceof MyPromise) return value
        return new MyPromise(resolve => resolve(value))

    }

    finally (callback) {
        return this.then(value => {
            return MyPromise.resolve(callback()).then(() => value)
        }, reason => {
            return MyPromise.resolve(callback()).then(() => {throw reason})
        })

    }

    catch (rejectedCallback) {
        return this.then(undefined, rejectedCallback)
    }

}

function resolvePromise(promise2,x,resolve, reject){

    if(x === promise2){
        return reject(new TypeError('啦啦啦啦'))
    }
    if(x instanceof MyPromise){
        //是promise
        //往下直接傳
        x.then(resolve,reject)
    }else{
        //普通值
        resolve(x)
    }
}

module.exports = MyPromise;