"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.containsCollections = containsCollections;
exports.deepForEach = deepForEach;
exports.deepMap = deepMap;
exports.reduce = reduce;
exports.scatter = scatter;
var _is = require("./is.js");
var _IndexError = require("../error/IndexError.js");
var _array = require("./array.js");
var _switch2 = require("./switch.js");
/**
 * Test whether an array contains collections
 * @param {Array} array
 * @returns {boolean} Returns true when the array contains one or multiple
 *                    collections (Arrays or Matrices). Returns false otherwise.
 */
function containsCollections(array) {
  for (let i = 0; i < array.length; i++) {
    if ((0, _is.isCollection)(array[i])) {
      return true;
    }
  }
  return false;
}

/**
 * Recursively loop over all elements in a given multi dimensional array
 * and invoke the callback on each of the elements.
 * @param {Array | Matrix} array
 * @param {Function} callback     The callback method is invoked with one
 *                                parameter: the current element in the array
 */
function deepForEach(array, callback) {
  if ((0, _is.isMatrix)(array)) {
    array.forEach(x => callback(x), false, true);
  } else {
    (0, _array.deepForEach)(array, callback, true);
  }
}

/**
 * Execute the callback function element wise for each element in array and any
 * nested array
 * Returns an array with the results
 * @param {Array | Matrix} array
 * @param {Function} callback   The callback is called with two parameters:
 *                              value1 and value2, which contain the current
 *                              element of both arrays.
 * @param {boolean} [skipZeros] Invoke callback function for non-zero values only.
 *
 * @return {Array | Matrix} res
 */
function deepMap(array, callback, skipZeros) {
  if (!skipZeros) {
    if ((0, _is.isMatrix)(array)) {
      return array.map(x => callback(x), false, true);
    } else {
      return (0, _array.deepMap)(array, callback, true);
    }
  }
  const skipZerosCallback = x => x === 0 ? x : callback(x);
  if ((0, _is.isMatrix)(array)) {
    return array.map(x => skipZerosCallback(x), false, true);
  } else {
    return (0, _array.deepMap)(array, skipZerosCallback, true);
  }
}

/**
 * Reduce a given matrix or array to a new matrix or
 * array with one less dimension, applying the given
 * callback in the selected dimension.
 * @param {Array | Matrix} mat
 * @param {number} dim
 * @param {Function} callback
 * @return {Array | Matrix} res
 */
function reduce(mat, dim, callback) {
  const size = Array.isArray(mat) ? (0, _array.arraySize)(mat) : mat.size();
  if (dim < 0 || dim >= size.length) {
    // TODO: would be more clear when throwing a DimensionError here
    throw new _IndexError.IndexError(dim, size.length);
  }
  if ((0, _is.isMatrix)(mat)) {
    return mat.create(_reduce(mat.valueOf(), dim, callback), mat.datatype());
  } else {
    return _reduce(mat, dim, callback);
  }
}

/**
 * Recursively reduce a matrix
 * @param {Array} mat
 * @param {number} dim
 * @param {Function} callback
 * @returns {Array} ret
 * @private
 */
function _reduce(mat, dim, callback) {
  let i, ret, val, tran;
  if (dim <= 0) {
    if (!Array.isArray(mat[0])) {
      val = mat[0];
      for (i = 1; i < mat.length; i++) {
        val = callback(val, mat[i]);
      }
      return val;
    } else {
      tran = (0, _switch2._switch)(mat);
      ret = [];
      for (i = 0; i < tran.length; i++) {
        ret[i] = _reduce(tran[i], dim - 1, callback);
      }
      return ret;
    }
  } else {
    ret = [];
    for (i = 0; i < mat.length; i++) {
      ret[i] = _reduce(mat[i], dim - 1, callback);
    }
    return ret;
  }
}

// TODO: document function scatter
function scatter(a, j, w, x, u, mark, cindex, f, inverse, update, value) {
  // a arrays
  const avalues = a._values;
  const aindex = a._index;
  const aptr = a._ptr;

  // vars
  let k, k0, k1, i;

  // check we need to process values (pattern matrix)
  if (x) {
    // values in j
    for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
      // row
      i = aindex[k];
      // check value exists in current j
      if (w[i] !== mark) {
        // i is new entry in j
        w[i] = mark;
        // add i to pattern of C
        cindex.push(i);
        // x(i) = A, check we need to call function this time
        if (update) {
          // copy value to workspace calling callback function
          x[i] = inverse ? f(avalues[k], value) : f(value, avalues[k]);
          // function was called on current row
          u[i] = mark;
        } else {
          // copy value to workspace
          x[i] = avalues[k];
        }
      } else {
        // i exists in C already
        x[i] = inverse ? f(avalues[k], x[i]) : f(x[i], avalues[k]);
        // function was called on current row
        u[i] = mark;
      }
    }
  } else {
    // values in j
    for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
      // row
      i = aindex[k];
      // check value exists in current j
      if (w[i] !== mark) {
        // i is new entry in j
        w[i] = mark;
        // add i to pattern of C
        cindex.push(i);
      } else {
        // indicate function was called on current row
        u[i] = mark;
      }
    }
  }
}