"use strict";

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

const isEven = require("../math/even");

const isOdd = require("../math/odd");

const zip = require("../util/zip"); // @TODO cannot import toFlatPairs here because circular :-/
// @TODO move to deps
// @TODO can use .findIndex too


const findIndexPlusOne = (needle, haystack) => haystack.indexOf(needle) + 1;

const atIndexPlusOne = (needle, haystack) => haystack[findIndexPlusOne(needle, haystack)];

const findIndexMinusOne = (needle, haystack) => haystack.indexOf(needle) - 1;

const atIndexMinusOne = (needle, haystack) => haystack[findIndexMinusOne(needle, haystack)];
/**
 * @desc allows any key val
 * @type {Array}
 * @HACK @FIXME @TODO
 * - BABEL HATES EXTENDING NATIVES
 * - Compiled with ts | buble to enable it
 * - you've been able to do this for years
 *
 * @TODO Set
 * https://stackoverflow.com/questions/7069052/how-to-obtain-index-of-a-given-set-element-without-iteration
 */
// class FlatPairArray extends Array {
//   typed(type) {
//     this.type = type
//     return this
//   }
//   has(key) {
//     return this.indexOf(key) !== -1
//   }
//   // push(key, value) {
//   //   return this.set(key, value)
//   // }
//   set(key, value) {
//     if (this.has(key)) return this
//     super.push(key)
//     super.push(value)
//     return this
//   }
//   get(key) {
//     return atIndexPlusOne(key, this)
//   }
//   getKey(value) {
//     return atIndexMinusOne(value, this)
//   }
// }

/* eslint no-proto: "OFF" */

/* eslint no-shadow: "OFF" */

/* eslint prefer-includes/prefer-includes: "OFF" */


var FlatPairArray = function (Array) {
  function FlatPairArray() {
    Array.apply(this, arguments);
  }

  if (Array) FlatPairArray.__proto__ = Array;
  FlatPairArray.prototype = Object.create(Array && Array.prototype);
  FlatPairArray.prototype.constructor = FlatPairArray; // @TODO not implemented

  FlatPairArray.prototype.typed = function typed(type) {
    this.type = type;
    return this;
  }; // boolean


  FlatPairArray.prototype.has = function has(key) {
    return this.indexOf(key) !== -1;
  }; // @chainable


  FlatPairArray.prototype.set = function set(key, value) {
    if (this.has(key)) {
      return this;
    }

    Array.prototype.push.call(this, key);
    Array.prototype.push.call(this, value);
    return this;
  }; // @alias getValue


  FlatPairArray.prototype.get = function get(key) {
    return atIndexPlusOne(key, this);
  };

  FlatPairArray.prototype.getKey = function getKey(value) {
    return atIndexMinusOne(value, this);
  }; // @alias add, set


  FlatPairArray.prototype.add = FlatPairArray.prototype.set;
  /**
   * @NOTE can make `final` if we want for better perf but better api allows writable
   * @type {Function}
   * @return {Array} pre-allocated for the length
   */

  Object.defineProperty(FlatPairArray.prototype, 'allocate', {
    configurable: true,
    enumerable: false,

    get() {
      return new Array(this.length);
    }

  });
  /**
   * @since 5.0.0-beta.9
   * @memberOf structured
   * @memberOf FlatPairArray
   * @NOTE 1/2 are keys, so cannot use array/preAllocate
   * @TODO if doing anything but isEven/isOdd, should not preAllocate
   *
   * @param {Function} indexPredicate match current index (isEven, isOdd, etc)
   * @return {Array<*>} keys
   *
   * @example
   *    const pairs = new FlatPairArray([ [1, '2'], [3, '4'] ])
   *    //=> [1, '2', 3, '4']
   *
   *    pairs.half(isEven)
   *    //=> []
   */

  FlatPairArray.prototype.half = function (indexPredicate) {
    const preAllocated = new Array(this.length / 2);
    let index = 0;
    this.forEach(value => {
      if (indexPredicate(index)) preAllocated[index] = value;
      index += 1;
    });
    return preAllocated;
  };
  /**
   * @since 5.0.0-beta.9
   * @memberOf structured
   * @memberOf FlatPairArray
   *
   * @TODO wonder if there is a `.grow`
   *       to pre-allocate growth
   *       on an instantiated array
   *       before adding?
   *
   * @param {Pairs} pairs isPairs
   * @return {FlatPairArray} @chainable
   *
   * @example
   *
   *    new FlatPairArray().addPairs([ [1, '2'], [3, '4'] ])
   *    //=> [1, '2', 3, '4']
   *
   */


  FlatPairArray.prototype.addPairs = function (pairs) {
    for (let index = 0; index < pairs.length; index++) {
      const _pairs$index = _slicedToArray(pairs[index], 2),
            key = _pairs$index[0],
            value = _pairs$index[1];

      this.push(key);
      this.push(value);
    }

    return this;
  }; // return Array<Pair>


  FlatPairArray.prototype.toPairs = function () {
    const keys = this.keys();
    const values = this.values();
    return zip(keys, values); // const preAllocated = new Array(this.length / 2)
    // let current = []
    // let index = 0
    // this.forEach(value => {
    //   if (isEven(index)) {
    //     current.push(value)
    //   }
    //   else {
    //     current.push(value)
    //     preAllocated[index / 2] = current.slice()
    //     current = []
    //   }
    //   index += 1
    // })
    // return preAllocated
  }; // @return {Array}


  FlatPairArray.prototype.keys = function () {
    return this.half(isOdd);
  }; // @override
  // @return {Array}


  FlatPairArray.prototype.values = function () {
    return this.half(isEven);
  };

  return FlatPairArray;
}(Array);

Object.assign(FlatPairArray, {
  FlatPairArray,
  FlatArrayPairs: FlatPairArray,
  findIndexPlusOne,
  atIndexPlusOne,
  findIndexMinusOne,
  atIndexMinusOne
});
module.exports = FlatPairArray;