'use strict'

var bind = require('./helpers/bind')

// utils is a library of generic helper functions non-specific to ipoa

var toString = Object.prototype.toString

/**
 * Determine if a value is an Array
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an Array, otherwise false
 */
function isArray(val) {
 return toString.call(val) === '[object Array]'
}

/**
 * Determine if a value is undefined
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if the value is undefined, otherwise false
 */
function isUndefined(val) {
 return typeof val === 'undefined'
}

/**
 * Determine if a value is a Buffer
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Buffer, otherwise false
 */
function isBuffer(val) {
 return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
 && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val)
}

/**
 * Determine if a value is an ArrayBuffer
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
 */
function isArrayBuffer(val) {
 return toString.call(val) === '[object ArrayBuffer]'
}

/**
 * Determine if a value is a FormData
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an FormData, otherwise false
 */
function isFormData(val) {
 return (typeof FormData !== 'undefined') && (val instanceof FormData)
}

/**
 * Determine if a value is a view on an ArrayBuffer
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
 */
function isArrayBufferView(val) {
 var result
 if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
 result = ArrayBuffer.isView(val)
 } else {
 result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer)
 }
 return result
}

/**
 * Determine if a value is a String
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a String, otherwise false
 */
function isString(val) {
 return typeof val === 'string'
}

/**
 * Determine if a value is a Number
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Number, otherwise false
 */
function isNumber(val) {
 return typeof val === 'number'
}

/**
 * Determine if a value is an Object
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is an Object, otherwise false
 */
function isObject(val) {
 return val !== null && typeof val === 'object'
}

/**
 * Determine if a value is a plain Object
 *
 * @param {Object} val The value to test
 * @return {boolean} True if value is a plain Object, otherwise false
 */
function isPlainObject(val) {
 if (toString.call(val) !== '[object Object]') {
 return false
 }

 var prototype = Object.getPrototypeOf(val)
 return prototype === null || prototype === Object.prototype
}

/**
 * Determine if a value is an JSON
 *
 * @param str
 * @param passObject
 * @returns {boolean} True if value is an JSON, otherwise false
 */
function isJSON(str, passObject = false) {
 if (isObject(str) && passObject) return true

 if (!isString(str)) return false

 str = str.replace(/\s/g, '').replace(/\n|\r/, '')

 if (/^\{(.*?)\}$/.test(str))
 return /"(.*?)":(.*?)/g.test(str)

 if (/^\[(.*?)\]$/.test(str)) {
 return str.replace(/^\[/, '')
 .replace(/\]$/, '')
 .replace(/},{/g, '}\n{')
 .split(/\n/)
 .map(function (s) { return isJSON(s) })
 .reduce(function (prev, curr) { return !!curr })
 }

 return false
}

/**
 *
 * Determine if a value is a Date
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Date, otherwise false
 */
function isDate(val) {
 return toString.call(val) === '[object Date]'
}

/**
 * Determine if a value is a File
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a File, otherwise false
 */
function isFile(val) {
 return toString.call(val) === '[object File]'
}

/**
 * Determine if a value is a Blob
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Blob, otherwise false
 */
function isBlob(val) {
 return toString.call(val) === '[object Blob]'
}

/**
 * Determine if a value is a Function
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Function, otherwise false
 */
function isFunction(val) {
 return toString.call(val) === '[object Function]'
}

/**
 * Determine if a value is a Stream
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a Stream, otherwise false
 */
function isStream(val) {
 return isObject(val) && isFunction(val.pipe)
}

/**
 * Determine if a value is a URLSearchParams object
 *
 * @param {Object} val The value to test
 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
 */
function isURLSearchParams(val) {
 return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams
}

/**
 * Trim excess whitespace off the beginning and end of a string
 *
 * @param {String} str The String to trim
 * @returns {String} The String freed of excess whitespace
 */
function trim(str) {
 return str.replace(/^\s*/, '').replace(/\s*$/, '')
}

/**
 * Determine if we're running in a standard browser environment
 *
 * This allows axios to run in a web worker, and react-native.
 * Both environments support XMLHttpRequest, but not fully standard globals.
 *
 * web workers:
 * typeof window -> undefined
 * typeof document -> undefined
 *
 * react-native:
 * navigator.product -> 'ReactNative'
 * nativescript
 * navigator.product -> 'NativeScript' or 'NS'
 */
function isStandardBrowserEnv() {
 if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
 navigator.product === 'NativeScript' ||
 navigator.product === 'NS')) {
 return false
 }
 return (
 typeof window !== 'undefined' &&
 typeof document !== 'undefined'
 )
}

/**
 * Similar to `isStandardBrowserEnv`, just check it's running in a Node environment
 *
 * @return {boolean} Ture on Node, otherwise false
 */
function isProcessEnv() {
 return typeof process !== 'undefined' && toString.call(process) === '[object process]'
}

/**
 * Determine if a value is a `form-data` node module
 *
 *
 * @param {Object} val - To test value
 *
 * @returns {boolean} True if value is a `form-data` module, otherwise false
 */
function isProcessFormData(val) {
 // toString.call(val) returns `[object Object]`, let's checking the instance `toString`
 return this.isProcessEnv() && this.isObject(val) && val.toString() === '[object FormData]'
}

/**
 * Iterate over an Array or an Object invoking a function for each item.
 *
 * If `obj` is an Array callback will be called passing
 * the value, index, and complete array for each item.
 *
 * If 'obj' is an Object callback will be called passing
 * the value, key, and complete object for each property.
 *
 * @param {Object|Array} obj The object to iterate
 * @param {Function} fn The callback to invoke for each item
 */
function forEach(obj, fn) {
 // Don't bother if no value provided
 if (obj === null || typeof obj === 'undefined') {
 return
 }

 // Force an array if not already something iterable
 if (typeof obj !== 'object') {
 /*eslint no-param-reassign:0*/
 obj = [obj]
 }

 if (isArray(obj)) {
 // Iterate over array values
 for (var i = 0, l = obj.length; i < l; i++) {
 fn.call(null, obj[i], i, obj)
 }
 } else {
 // Iterate over object keys
 for (var key in obj) {
 if (Object.prototype.hasOwnProperty.call(obj, key)) {
 fn.call(null, obj[key], key, obj)
 }
 }
 }
}

/**
 * Accepts varargs expecting each argument to be an object, then
 * immutably merges the properties of each object and returns result.
 *
 * When multiple objects contain the same key the later object in
 * the arguments list will take precedence.
 *
 * Example:
 *
 * ```js
 * var result = merge({foo: 123}, {foo: 456});
 * console.log(result.foo); // outputs 456
 * ```
 *
 * @param {Object} obj1 Object to merge
 * @returns {Object} Result of all merge properties
 */
function merge(/* obj1, obj2, obj3, ... */) {
 var result = {}

 function assignValue(val, key) {
 if (isPlainObject(result[key]) && isPlainObject(val)) {
 result[key] = merge(result[key], val)
 } else if (isPlainObject(val)) {
 result[key] = merge({}, val)
 } else if (isArray(val)) {
 result[key] = val.slice()
 } else {
 result[key] = val
 }
 }

 for (var i = 0, l = arguments.length; i < l; i++) {
 forEach(arguments[i], assignValue)
 }
 return result
}

/**
 * Extends object a by mutably adding to it the properties of object b.
 *
 * @param {Object} a The object to be extended
 * @param {Object} b The object to copy properties from
 * @param {Object} thisArg The object to bind function to
 * @return {Object} The resulting value of object a
 */
function extend(a, b, thisArg) {
 forEach(b, function assignValue(val, key) {
 if (thisArg && typeof val === 'function') {
 a[key] = bind(val, thisArg)
 } else {
 a[key] = val
 }
 })
 return a
}

/**
 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
 *
 * @param {string} content with BOM
 * @return {string} content value without BOM
 */
function stripBOM(content) {
 if (content.charCodeAt(0) === 0xFEFF) {
 content = content.slice(1)
 }
 return content
}

/**
 * @param {String} url
 * @description Parse parameters from URL
 *
 * Example:
 * ```js
 * var url = 'http://xxx.xxx.com/?id=1&start=0&count=10'
 * var result = getUrlParams(url);
 * console.log(result); // outputs { id: '1', start: '0', count: '10' }
 * ```
 * @return {Object} parameters as Object
 *
 */

function getUrlParams(url = '') {
 var keyValueArr = url && url.split('?')[1].split('&')
 var paramObj = {}
 forEach(keyValueArr, function (item) {
 var keyValue = item.split('=')
 paramObj[keyValue[0]] = keyValue[1]
 })
 return paramObj
}

module.exports = {
 isArray: isArray,
 isArrayBuffer: isArrayBuffer,
 isBuffer: isBuffer,
 isFormData: isFormData,
 isArrayBufferView: isArrayBufferView,
 isString: isString,
 isNumber: isNumber,
 isObject: isObject,
 isPlainObject: isPlainObject,
 isJSON: isJSON,
 isUndefined: isUndefined,
 isDate: isDate,
 isFile: isFile,
 isBlob: isBlob,
 isFunction: isFunction,
 isStream: isStream,
 isURLSearchParams: isURLSearchParams,
 isStandardBrowserEnv: isStandardBrowserEnv,
 isProcessEnv: isProcessEnv,
 isProcessFormData: isProcessFormData,
 forEach: forEach,
 merge: merge,
 extend: extend,
 trim: trim,
 stripBOM: stripBOM,
 getUrlParams: getUrlParams
}