class Promise {
    // 构造方法
    constructor(executor) {
        // 添加属性
        this.PromiseState = 'pending'
        this.PromiseResult = null
        this.callbacks = []

        // 保存实例对象的this的值
        const self = this

        // resolve 函数
        function resolve(data) {
            // 判断状态
            if (self.PromiseState !== 'pending') return

            // 此时this为window
            // 改变对象状态(PromiseState)
            self.PromiseState = 'fulfilled'
            // 设置对象结果值(PromiseResult)
            self.PromiseResult = data

            // 调用成功的回调函数
            /*if (self.callback.onResolved) {
                self.callback.onResolved(data);
            }*/
            setTimeout(() => {
                self.callbacks.forEach(item => {
                    item.onResolved(data)
                })
            })
        }

        // reject 函数
        function reject(data) {
            // 判断状态
            if (self.PromiseState !== 'pending') return

            // 改变对象状态(PromiseState)
            self.PromiseState = 'rejected'
            // 设置对象结果值(PromiseResult)
            self.PromiseResult = data

            // 调用失败的回调函数
            /*if (self.callback.onRejected) {
                self.callback.onRejected(data);
            }*/

            setTimeout(() => {
                self.callbacks.forEach(item => {
                    item.onRejected(data)
                })
            })
        }

        try {
            // 同步调用执行器函数
            executor(resolve, reject)
        } catch (e) {
            // 修改对象状态为失败
            reject(e)
        }
    }

    then(onResolved, onRejected) {

        const self = this
        // 判断回调函数参数
        if (typeof onRejected !== 'function') {
            onRejected = reason => {
                throw reason;
            }
        }
        if (typeof onResolved !== 'function') {
            onResolved = value => value;
        }
        return new Promise((resolve, reject) => {
            // 封装函数
            function callback(type) {
                try {
                    // 获取回调函数的执行结果
                    let result = type(self.PromiseResult);
                    // 判断
                    if (result instanceof Promise) {
                        // 如果是 promise 类型的对象
                        result.then(v => {
                            resolve(v)
                        }, r => {
                            reject(r)
                        })
                    } else {
                        // 结果的对象状态为「成功」
                        resolve(result)
                    }
                } catch (e) {
                    reject(e)
                }
            }

            // 调用回调函数
            if (this.PromiseState === 'fulfilled') {
                setTimeout(() => {
                    callback(onResolved)
                })
            }

            if (this.PromiseState === 'rejected') {
                setTimeout(() => {
                    callback(onRejected)
                })
            }

            // pending的状态
            if (this.PromiseState === 'pending') {
                this.callbacks.push({
                    onResolved: function () {
                        callback(onResolved)
                    },
                    onRejected: function () {
                        callback(onRejected)
                    }
                })
            }


        })
    }

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

    static resolve(value) {
        return new Promise((resolve, reject) => {
            if (value instanceof Promise) {
                value.then(v => {
                    resolve(v)
                }, r => {
                    reject(r)
                })
            } else {
                resolve(value)
            }
        })
    }

    static reject(reason) {
        return new Promise((resolve, reject) => {
            reject(reason)
        })
    }

    static all(promises) {
        return new Promise((resolve, reject) => {
            // 声明变量
            let count = 0 // 计数
            let arr = [] // 接收成功结果
            // 遍历
            for (let i = 0; i < promises.length; i++) {
                promises[i].then(v => {
                    // 当n个promise对象都成功才 resolve
                    count++;
                    // 将当前promise对象成功的结果存入数组中
                    arr[i] = v
                    // 判断
                    if (count === promises.length) {
                        // 在count等于数组个数才改变状态
                        resolve(arr) // 修改状态
                    }
                }, r => {
                    reject(r) // 只要有一个失败就改为失败
                })
            }
        })
    }

    static race(promises) {
        return new Promise((resolve, reject) => {
            for (let i = 0; i < promises.length; i++) {
                promises[i].then(v => {
                    // 修改返回对象的状态为「成功」 谁先运行谁决定状态
                    resolve(v)
                }, r => {
                    reject(r)
                })
            }
        })
    }
}