'use strict';

var trimStart = require('string.prototype.trimleft');
var trimEnd = require('string.prototype.trimright');
var inspect = require('object-inspect');

var ES2018 = require('./es2018');
var assign = require('./helpers/assign');
var MAX_SAFE_INTEGER = require('./helpers/maxSafeInteger');

var GetIntrinsic = require('./GetIntrinsic');

var $TypeError = GetIntrinsic('%TypeError%');

var ES2019 = assign(assign({}, ES2018), {
	// https://tc39.es/ecma262/#sec-add-entries-from-iterable
	AddEntriesFromIterable: function AddEntriesFromIterable(target, iterable, adder) {
		if (!this.IsCallable(adder)) {
			throw new $TypeError('Assertion failed: `adder` is not callable');
		}
		if (iterable == null) {
			throw new $TypeError('Assertion failed: `iterable` is present, and not nullish');
		}
		var iteratorRecord = this.GetIterator(iterable);
		while (true) { // eslint-disable-line no-constant-condition
			var next = this.IteratorStep(iteratorRecord);
			if (!next) {
				return target;
			}
			var nextItem = this.IteratorValue(next);
			if (this.Type(nextItem) !== 'Object') {
				var error = new $TypeError('iterator next must return an Object, got ' + inspect(nextItem));
				return this.IteratorClose(
					iteratorRecord,
					function () { throw error; } // eslint-disable-line no-loop-func
				);
			}
			try {
				var k = this.Get(nextItem, '0');
				var v = this.Get(nextItem, '1');
				this.Call(adder, target, [k, v]);
			} catch (e) {
				return this.IteratorClose(
					iteratorRecord,
					function () { throw e; } // eslint-disable-line no-loop-func
				);
			}
		}
	},

	// https://ecma-international.org/ecma-262/10.0/#sec-flattenintoarray
	// eslint-disable-next-line max-params, max-statements
	FlattenIntoArray: function FlattenIntoArray(target, source, sourceLen, start, depth) {
		var mapperFunction;
		if (arguments.length > 5) {
			mapperFunction = arguments[5];
		}

		var targetIndex = start;
		var sourceIndex = 0;
		while (sourceIndex < sourceLen) {
			var P = this.ToString(sourceIndex);
			var exists = this.HasProperty(source, P);
			if (exists === true) {
				var element = this.Get(source, P);
				if (typeof mapperFunction !== 'undefined') {
					if (arguments.length <= 6) {
						throw new $TypeError('Assertion failed: thisArg is required when mapperFunction is provided');
					}
					element = this.Call(mapperFunction, arguments[6], [element, sourceIndex, source]);
				}
				var shouldFlatten = false;
				if (depth > 0) {
					shouldFlatten = this.IsArray(element);
				}
				if (shouldFlatten) {
					var elementLen = this.ToLength(this.Get(element, 'length'));
					targetIndex = this.FlattenIntoArray(target, element, elementLen, targetIndex, depth - 1);
				} else {
					if (targetIndex >= MAX_SAFE_INTEGER) {
						throw new $TypeError('index too large');
					}
					this.CreateDataPropertyOrThrow(target, this.ToString(targetIndex), element);
					targetIndex += 1;
				}
			}
			sourceIndex += 1;
		}

		return targetIndex;
	},

	// https://ecma-international.org/ecma-262/10.0/#sec-trimstring
	TrimString: function TrimString(string, where) {
		var str = this.RequireObjectCoercible(string);
		var S = this.ToString(str);
		var T;
		if (where === 'start') {
			T = trimStart(S);
		} else if (where === 'end') {
			T = trimEnd(S);
		} else if (where === 'start+end') {
			T = trimStart(trimEnd(S));
		} else {
			throw new $TypeError('Assertion failed: invalid `where` value; must be "start", "end", or "start+end"');
		}
		return T;
	}
});

module.exports = ES2019;
