“use strict”; module.exports = function(Promise,

PromiseArray,
apiRejection,
tryConvertToPromise,
INTERNAL,
debug) {

var util = require(“./util”); var tryCatch = util.tryCatch;

function ReductionPromiseArray(promises, fn, initialValue, _each) {

this.constructor$(promises);
var context = Promise._getContext();
this._fn = util.contextBind(context, fn);
if (initialValue !== undefined) {
    initialValue = Promise.resolve(initialValue);
    initialValue._attachCancellationCallback(this);
}
this._initialValue = initialValue;
this._currentCancellable = null;
if(_each === INTERNAL) {
    this._eachValues = Array(this._length);
} else if (_each === 0) {
    this._eachValues = null;
} else {
    this._eachValues = undefined;
}
this._promise._captureStackTrace();
this._init$(undefined, -5);

} util.inherits(ReductionPromiseArray, PromiseArray);

ReductionPromiseArray.prototype._gotAccum = function(accum) {

if (this._eachValues !== undefined &&
    this._eachValues !== null &&
    accum !== INTERNAL) {
    this._eachValues.push(accum);
}

};

ReductionPromiseArray.prototype._eachComplete = function(value) {

if (this._eachValues !== null) {
    this._eachValues.push(value);
}
return this._eachValues;

};

ReductionPromiseArray.prototype._init = function() {};

ReductionPromiseArray.prototype._resolveEmptyArray = function() {

this._resolve(this._eachValues !== undefined ? this._eachValues
                                             : this._initialValue);

};

ReductionPromiseArray.prototype.shouldCopyValues = function () {

return false;

};

ReductionPromiseArray.prototype._resolve = function(value) {

this._promise._resolveCallback(value);
this._values = null;

};

ReductionPromiseArray.prototype._resultCancelled = function(sender) {

if (sender === this._initialValue) return this._cancel();
if (this._isResolved()) return;
this._resultCancelled$();
if (this._currentCancellable instanceof Promise) {
    this._currentCancellable.cancel();
}
if (this._initialValue instanceof Promise) {
    this._initialValue.cancel();
}

};

ReductionPromiseArray.prototype._iterate = function (values) {

this._values = values;
var value;
var i;
var length = values.length;
if (this._initialValue !== undefined) {
    value = this._initialValue;
    i = 0;
} else {
    value = Promise.resolve(values[0]);
    i = 1;
}

this._currentCancellable = value;

for (var j = i; j < length; ++j) {
    var maybePromise = values[j];
    if (maybePromise instanceof Promise) {
        maybePromise.suppressUnhandledRejections();
    }
}

if (!value.isRejected()) {
    for (; i < length; ++i) {
        var ctx = {
            accum: null,
            value: values[i],
            index: i,
            length: length,
            array: this
        };

        value = value._then(gotAccum, undefined, undefined, ctx, undefined);

        if ((i & 127) === 0) {
            value._setNoAsyncGuarantee();
        }
    }
}

if (this._eachValues !== undefined) {
    value = value
        ._then(this._eachComplete, undefined, undefined, this, undefined);
}
value._then(completed, completed, undefined, value, this);

};

Promise.prototype.reduce = function (fn, initialValue) {

return reduce(this, fn, initialValue, null);

};

Promise.reduce = function (promises, fn, initialValue, _each) {

return reduce(promises, fn, initialValue, _each);

};

function completed(valueOrReason, array) {

if (this.isFulfilled()) {
    array._resolve(valueOrReason);
} else {
    array._reject(valueOrReason);
}

}

function reduce(promises, fn, initialValue, _each) {

if (typeof fn !== "function") {
    return apiRejection("expecting a function but got " + util.classString(fn));
}
var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
return array.promise();

}

function gotAccum(accum) {

this.accum = accum;
this.array._gotAccum(accum);
var value = tryConvertToPromise(this.value, this.array._promise);
if (value instanceof Promise) {
    this.array._currentCancellable = value;
    return value._then(gotValue, undefined, undefined, this, undefined);
} else {
    return gotValue.call(this, value);
}

}

function gotValue(value) {

var array = this.array;
var promise = array._promise;
var fn = tryCatch(array._fn);
promise._pushContext();
var ret;
if (array._eachValues !== undefined) {
    ret = fn.call(promise._boundValue(), value, this.index, this.length);
} else {
    ret = fn.call(promise._boundValue(),
                          this.accum, value, this.index, this.length);
}
if (ret instanceof Promise) {
    array._currentCancellable = ret;
}
var promiseCreated = promise._popContext();
debug.checkForgottenReturns(
    ret,
    promiseCreated,
    array._eachValues !== undefined ? "Promise.each" : "Promise.reduce",
    promise
);
return ret;

} };