/**
 * 
 * @authors yutent (yutent@doui.cc)
 * @date    2016-11-26 16:35:45
 *
 */

'use strict';

define(function() {
    var _Promise = function(callback) {
        this.callback = [];
        var _this = this;

        if (typeof this !== 'object')
            throw new TypeError('Promises must be constructed via new');

        if (typeof callback !== 'function')
            throw new TypeError('Argument must be a function');

        callback(
            function(val) {
                _resolve(_this, val);
            },
            function(val) {
                _reject(_this, val);
            }
        );
    };
    var self = {
        _state: 1,
        _fired: 1,
        _val: 1,
        callback: 1
    };

    _Promise.prototype = {
        constructor: _Promise,
        _state: 'pending',
        _fired: false,
        _fire: function(yes, no) {
            if (this._state === 'rejected') {
                if (typeof no === 'function') no(this._val);
                else throw this._val;
            } else {
                if (typeof yes === 'function') yes(this._val);
            }
        },
        _then: function(yes, no) {
            if (this._fired) {
                var _this = this;
                fireCallback(_this, function() {
                    _this._fire(yes, no);
                });
            } else {
                this.callback.push({ yes: yes, no: no });
            }
        },
        then: function(yes, no) {
            yes = typeof yes === 'function' ? yes : _yes;
            no = typeof no === 'function' ? no : _no;
            var _this = this;
            var next = new _Promise(function(resolve, reject) {
                _this._then(
                    function(val) {
                        try {
                            val = yes(val);
                        } catch (err) {
                            return reject(err);
                        }
                    },
                    function(val) {
                        try {
                            val = no(val);
                        } catch (err) {
                            return reject(err);
                        }
                        resolve(val);
                    }
                );
            });
            for (var i in _this) {
                if (!self[i]) next[i] = _this[i];
            }
            return next;
        },
        done: done,
        catch: fail,
        fail: fail
    };

    _Promise.all = function(arr) {
        return _some(false, arr);
    };

    _Promise.race = function(arr) {
        return _some(true, arr);
    };

    _Promise.defer = defer;

    // -----------------------------------------------------------

    function _yes(val) {
        return val;
    }

    function _no(err) {
        throw err;
    }

    function done(callback) {
        return this.then(callback, _no);
    }

    function fail(callback) {
        return this.then(_yes, callback);
    }

    function defer() {
        var obj = {};
        obj.promise = new this(function(yes, no) {
            obj.resolve = yes;
            obj.reject = no;
        });
        return obj;
    }

    //成功的回调
    function _resolve(obj, val) {
        if (obj._state !== 'pending') return;

        if (val && typeof val.then === 'function') {
            var method = val instanceof _Promise ? '_then' : 'then';
            val[method](
                function(v) {
                    _transmit(obj, v, true);
                },
                function(v) {
                    _transmit(obj, v, false);
                }
            );
        } else {
            _transmit(obj, val, true);
        }
    }

    //失败的回调
    function _reject(obj, val) {
        if (obj._state !== 'pending') return;

        _transmit(obj, val, false);
    }

    // 改变Promise的_fired值，并保持用户传参，触发所有回调
    function _transmit(obj, val, isResolved) {
        obj._fired = true;
        obj._val = val;
        obj._state = isResolved ? 'fulfilled' : 'rejected';

        fireCallback(obj, function() {
            for (var i in obj.callback) {
                obj._fire(obj.callback[i].yes, obj.callback[i].no);
            }
        });
    }

    function fireCallback(obj, callback) {
        var isAsync = false;

        if (typeof obj.async === 'boolean') isAsync = obj.async;
        else isAsync = obj.async = true;

        if (isAsync) setTimeout(callback, 0);
        else callback();
    }

    function _some(bool, iterable) {
        iterable = Array.isArray(iterable) ? iterable : [];

        var n = 0;
        var res = [];
        var end = false;

        return new _Promise(function(yes, no) {
            if (!iterable.length) no(res);

            function loop(obj, idx) {
                obj.then(
                    function(val) {
                        if (!end) {
                            res[idx] = val;
                            n++;
                            if (bool || n >= iterable.length) {
                                yes(bool ? val : res);
                                end = true;
                            }
                        }
                    },
                    function(val) {
                        end = true;
                        no(val);
                    }
                );
            }

            for (var i = 0, len = iterable.length; i < len; i++) {
                loop(iterable[i], i);
            }
        });
    }

    // ---------------------------------------------------------------

    var nativePromise = window.Promise;
    if (/native code/.test(nativePromise)) {
        nativePromise.prototype.done = done;
        nativePromise.prototype.fail = fail;
        if (!nativePromise.defer) nativePromise.defer = defer;
    }

    return (window.Promise = nativePromise || _Promise);
});