/**
 * Will trim all falsy values from the end of an array
 *
 * @param {Array} a
 * @return {Array}
 */
export default function trim (a) {
	a = [...a].reverse();

	while (a.length) {
		if (a[0]) break;
		a.shift();
	}

	return a.reverse();
}

/**
 * Converts the given string to camelCase
 *
 * @param str
 * @returns {*}
 */
export default function camel (str) {
	return str.toLowerCase().replace(
		/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g,
		(m, chr) => chr.toUpperCase()
	);
}

/**
 * Capitalize the first letter of the given string
 *
 * @param {string} str
 * @param {boolean=} forceLower
 * @return {string}
 */
export default function capitalize (str, forceLower = false) {
	if (!str) return str;
	return str.charAt(0).toUpperCase() + (forceLower ? str.slice(1).toLowerCase() : str.slice(1));
}

/**
 * Cherry-picks from the given array of objects, comparing top-level keys
 * against the given compare object.
 *
 * ```js
 * const myCollection = [
 *   { id: 1, default: false },
 *   { id: 2, default: true },
 *   { id: 3, default: false },
 * ];
 *
 * const defaultValue = cherryPick(myCollection, { default: true });
 * ```
 *
 * @param {[...Object]} array - Collection to pick from
 * @param {Object} compare - An object of values to compare against
 * @param {Boolean=true} fallbackToFirst - Whether to fall back to the first value if no match is found
 * @returns {?Object} The picked object if available
 */
export default function cherryPick (array, compare, fallbackToFirst = true) {
	const entries = Object.entries(compare);

	outer:
	for (let i = 0, l = array.length; i < l; i++) {
		const item = array[i];

		for (let j = 0, k = entries.length; j < k; j++) {
			const [key, value] = entries[j];

			if (item[key] !== value)
				continue outer;
		}

		return item;
	}

	return fallbackToFirst ? array?.[0] : null;
}

/**
 * Clamp the given number between a min and max
 *
 * @param {number} number
 * @param {number} min
 * @param {number} max
 * @return {number}
 */
export default function clamp (number, min = 0, max = 1) {
	return Math.min(Math.max(number, min), max);
}

/**
 * Builds a class string from the given args
 *
 * cls('my-class', { [css.myClass]: a === b }, ['another', { 'hello': false }])
 *
 * @param args
 * @return {string}
 */
export default function cls (...args) {
	const c = [];

	args.forEach(arg => {
		if (typeof arg !== 'object') {
			c.push(arg);
			return;
		}

		if (Array.isArray(arg)) {
			c.concat(...cls(...arg));
			return;
		}

		for (const [key, value] of Object.entries(arg))
			if (!!value)
				c.push(key);
	});

	return c.join(' ');
}

/**
 * ## Create Element
 * Quick and easy DOM element creation
 *
 * @param {string=} tag - The element tag
 * @param {object=} attributes - The attributes to add, mapping the key as
 *     the attribute name, and the value as its value. If the value is a
 *     function, it will be added as an event.
 * @param {(Array|*)=} children - An array of children (can be a mixture of
 *     Nodes to append, or other values to be stringified and appended
 *     as text).
 * @return {Element} - The created element
 */
export default function createElement (
	tag = "div",
	attributes = {},
	children = []
) {
	const elem = document.createElement(tag);

	for (let [key, value] of Object.entries(attributes)) {
		if (!value) continue;

		if (typeof value === typeof (() => {})) {
			if (key === "ref") value(elem);
			else elem.addEventListener(key, value);
			continue;
		}

		if (key === "style")
			value = value.replace(/[\t\r\n]/g, " ").trim();

		elem.setAttribute(key, value);
	}

	if (!Array.isArray(children))
		children = [children];

	children.map(child => {
		if (!child) return;

		try {
			elem.appendChild(child);
		} catch (_) {
			elem.appendChild(document.createTextNode(child));
		}
	});

	return elem;
}

/**
 * Builds a class string from the given args but smaller
 *
 * cx('my-class', a === b && css.myClass, css.hi)
 *
 * @param args
 * @return {string}
 */
export default function cx (...args) {
	return args.filter(Boolean).join(' ');
}

/**
 * Converts two dates into a human readable duration string
 *
 * @param {Date|int|string} from
 * @param {Date|int|string} to
 * @param {Object=} opts
 * @return {string}
 */
export default function datesToDuration (
	from,
	to,
	opts = {
		show: {
			years: true,
			days: true,
			hours: true,
			minutes: true,
			seconds: true,
			second: true,
		},
		labels: {
			years: 'y',
			days: 'd',
			hours: 'h',
			minutes: 'm',
			seconds: 's',
			second: 's',
		},
	},
) {
	if (typeof from === 'string') from = new Date(from);
	if (typeof to   === 'string') to   = new Date(to);

	let ms = Math.abs((to - from) / 1000);

	const y = Math.floor(ms / 31536000)
		, d = Math.floor((ms %= 31536000) / 86400)
		, h = Math.floor((ms %= 86400) / 3600)
		, m = Math.floor((ms %= 3600) / 60)
		, s = ms % 60 ? (ms % 60).toFixed(2) : 0;

	if (!(y || d || h || m || s) && opts.show.second)
		return `< 1${opts.labels.second}`;

	return (
		(opts.show.years   && y ? `${y}${opts.labels.years} `   : '') +
		(opts.show.days    && d ? `${d}${opts.labels.days} `    : '') +
		(opts.show.hours   && h ? `${h}${opts.labels.hours} `   : '') +
		(opts.show.minutes && m ? `${m}${opts.labels.minutes} ` : '') +
		(opts.show.seconds && s ? `${s}${opts.labels.seconds} ` : '')
	).trim();
}

/**
 * Calculates the number of days between two dates
 *
 * @param {Date} from
 * @param {Date} to
 * @returns {number}
 */
export default function daysInRange (from, to) {
	return Math.round(Math.abs(from - to) / 8.64e+7);
}

/**
 * ## Debounce
 *
 * A function, that, as long as it continues to be invoked, will not
 * be triggered. The function will be called after it stops being called for
 * N milliseconds.
 *
 * If `immediate` is passed, trigger the function on the leading edge,
 * instead of the trailing.
 *
 * ```jsx
 *
 * // ...
 *
 * <input onInput={this.handleInput}>
 *
 * // ...
 *
 * handleInput = debounce(e => { /* ... *\/ });
 *
 * ```
 *
 * @param {function} func - The function to debounce
 * @param {number=} wait - How long, in milliseconds, to delay between attempts
 * @param {boolean=} immediate - Fire on the leading edge
 * @returns {Function}
 */
export default function debounce (func, wait = 300, immediate = false) {
	let timeout;

	if (wait === 0) {
		return function () {
			func.apply(this, arguments);
		};
	}

	return function () {
		const context = this
			, args = arguments;

		if (args.length && args[0].constructor.name === "SyntheticEvent")
			args[0].persist();

		const later = function() {
			timeout = null;
			if (!immediate) func.apply(context, args);
		};
		const callNow = immediate && !timeout;
		clearTimeout(timeout);
		timeout = setTimeout(later, wait);
		if (callNow) func.apply(context, args);
	};
}

/**
 * Sets the number of decimal places, stripping trailing zeros to nearest 10
 *
 * dp(1.4, 2) -> 1.40
 * dp(1.303, 2) -> 1.30
 * dp(10, 2) -> 10
 *
 * @param {number} v - The value to modify
 * @param {number=} d - The number of decimal places
 * @returns {string}
 */
const dp = (v, d = 2) => isNaN(+v) ? v :
	(+v).toFixed(d).replace(
		/(\.0+$)|(?<k>\.\d\d[1-9]?)(0+)$/,
		(_, __, $2) => $2 ?? ''
	);

export default dp;

/**
 * Format the given bytes to the nearest appropriate size
 *
 * @param {Number|string} bytes
 * @param {Number} decimals
 * @returns {string}
 * @see https://stackoverflow.com/a/18650828/550109
 */
export default function formatBytes (bytes, decimals = 2) {
	if (bytes === 0)
		return '0 Bytes';

	const k = 1024;
	const dm = decimals < 0 ? 0 : decimals;
	const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];

	const i = Math.floor(Math.log(bytes) / Math.log(k));

	return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}

class FormatDate {

	// Properties
	// =========================================================================

	static _shortMonths = [
		'Jan',
		'Feb',
		'Mar',
		'Apr',
		'May',
		'Jun',
		'Jul',
		'Aug',
		'Sep',
		'Oct',
		'Nov',
		'Dec',
	];

	static _longMonths = [
		'January',
		'February',
		'March',
		'April',
		'May',
		'June',
		'July',
		'August',
		'September',
		'October',
		'November',
		'December',
	];

	static _shortDays = [
		'Sun',
		'Mon',
		'Tue',
		'Wed',
		'Thu',
		'Fri',
		'Sat',
	];

	static _longDays = [
		'Sunday',
		'Monday',
		'Tuesday',
		'Wednesday',
		'Thursday',
		'Friday',
		'Saturday',
	];

	static _replaceChars = {

		// Day
		// ---------------------------------------------------------------------

		/**
		 * @returns {string}
		 */
		d: function () {
			const d = this.getDate();
			return (d < 10 ? '0' : '') + d;
		},

		/**
		 * @returns {string}
		 */
		D: function () {
			return FormatDate._shortDays[this.getDay()];
		},

		/**
		 * @returns {number}
		 */
		j: function () {
			return this.getDate();
		},

		/**
		 * @returns {string}
		 */
		l: function () {
			return FormatDate._longDays[this.getDay()];
		},

		/**
		 * @returns {number}
		 */
		N: function () {
			const N = this.getDay();
			return N === 0 ? 7 : N;
		},

		/**
		 * @returns {string}
		 */
		S: function () {
			const S = this.getDate();
			return (
				S % 10 === 1 && S !== 11 ? 'st' : (
					S % 10 === 2 && S !== 12 ? 'nd' : (
						S % 10 === 3 && S !== 13 ? 'rd' : 'th'
					)
				)
			);
		},

		/**
		 * @returns {number}
		 */
		w: function () {
			return this.getDay();
		},

		/**
		 * @returns {number}
		 */
		z: function () {
			const d = new Date(this.getFullYear(), 0, 1);
			return Math.ceil((this - d) / 86400000);
		},

		// Week
		// ---------------------------------------------------------------------

		/**
		 * @returns {string}
		 */
		W: function () {
			const target = new Date(this.valueOf())
				, dayNr = (this.getDay() + 6) % 7;

			target.setDate(target.getDate() - dayNr + 3);

			const firstThursday = target.valueOf();

			target.setMonth(0, 1);

			if (target.getDay() !== 4)
				target.setMonth(0, 1 + ((4 - target.getDay()) + 7) % 7);

			const retVal = 1 + Math.ceil((firstThursday - target) / 604800000);

			return (retVal < 10 ? '0' + retVal : retVal);
		},

		// Month
		// ---------------------------------------------------------------------

		/**
		 * @returns {string}
		 */
		F: function () {
			return FormatDate._longMonths[this.getMonth()];
		},

		/**
		 * @returns {string}
		 */
		m: function () {
			const m = this.getMonth();
			return (m < 9 ? '0' : '') + (m + 1);
		},

		/**
		 * @returns {string}
		 */
		M: function () {
			return FormatDate._shortMonths[this.getMonth()];
		},

		/**
		 * @returns {number}
		 */
		n: function () {
			return this.getMonth() + 1;
		},

		/**
		 * @returns {number}
		 */
		t: function () {
			let year = this.getFullYear(), nextMonth = this.getMonth() + 1;

			if (nextMonth === 12) {
				year++;
				nextMonth = 0;
			}

			return new Date(year, nextMonth, 0).getDate();
		},

		// Year
		// ---------------------------------------------------------------------

		/**
		 * @returns {boolean}
		 */
		L: function () {
			const L = this.getFullYear();
			return (
				L % 400 === 0 || (
					L % 100 !== 0 && L % 4 === 0
				)
			);
		},

		/**
		 * @returns {number}
		 */
		o: function () {
			const d = new Date(this.valueOf());
			d.setDate(d.getDate() - ((this.getDay() + 6) % 7) + 3);
			return d.getFullYear();
		},

		/**
		 * @returns {number}
		 */
		Y: function () {
			return this.getFullYear();
		},

		/**
		 * @returns {string}
		 */
		y: function () {
			return (
				'' + this.getFullYear()
			).substr(2);
		},

		// Time
		// ---------------------------------------------------------------------

		/**
		 * @returns {string}
		 */
		a: function () {
			return this.getHours() < 12 ? 'am' : 'pm';
		},

		/**
		 * @returns {string}
		 */
		A: function () {
			return this.getHours() < 12 ? 'AM' : 'PM';
		},

		/**
		 * @returns {number}
		 */
		B: function () {
			return Math.floor(
				(
					(
						(
							this.getUTCHours() + 1
						) % 24
					) + this.getUTCMinutes() / 60
					+ this.getUTCSeconds() / 3600
				) * 1000 / 24);
		},

		/**
		 * @returns {number}
		 */
		g: function () {
			return this.getHours() % 12 || 12;
		},

		/**
		 * @returns {number}
		 */
		G: function () {
			return this.getHours();
		},

		/**
		 * @returns {string}
		 */
		h: function () {
			const h = this.getHours();
			return (
				(
					h % 12 || 12
				) < 10 ? '0' : ''
			) + (
				h % 12 || 12
			);
		},

		/**
		 * @returns {string}
		 */
		H: function () {
			const H = this.getHours();
			return (H < 10 ? '0' : '') + H;
		},

		/**
		 * @returns {string}
		 */
		i: function () {
			const i = this.getMinutes();
			return (
				i < 10 ? '0' : ''
			) + i;
		},

		/**
		 * @returns {string}
		 */
		s: function () {
			const s = this.getSeconds();
			return (
				s < 10 ? '0' : ''
			) + s;
		},

		/**
		 * @returns {string}
		 */
		v: function () {
			const v = this.getMilliseconds();
			return (
				v < 10 ? '00' : (
					v < 100 ? '0' : ''
				)
			) + v;
		},

		// Timezone
		// ---------------------------------------------------------------------

		/**
		 * @returns {string}
		 */
		e: function () {
			return Intl.DateTimeFormat().resolvedOptions().timeZone;
		},

		/**
		 * @returns {number}
		 */
		I: function () {
			let DST = null;
			for (let i = 0; i < 12; ++i) {
				const d = new Date(this.getFullYear(), i, 1);
				const offset = d.getTimezoneOffset();

				if (DST === null) DST = offset;
				else if (offset < DST) {
					DST = offset;
					break;
				} else if (offset > DST) break;
			}
			return (this.getTimezoneOffset() === DST)|0;
		},

		/**
		 * @returns {string}
		 */
		O: function () {
			const O = this.getTimezoneOffset();
			return (
				-O < 0 ? '-' : '+'
			) + (
				Math.abs(O / 60) < 10 ? '0' : ''
			) + Math.floor(Math.abs(O / 60)) + (
				Math.abs(O % 60) === 0 ? '00' : (
					(
						Math.abs(O % 60) < 10 ? '0' : ''
					)
				) + (
					Math.abs(O % 60)
				)
			);
		},

		/**
		 * @returns {string}
		 */
		P: function () {
			const P = this.getTimezoneOffset();
			return (
				-P < 0 ? '-' : '+'
			) + (
				Math.abs(P / 60) < 10 ? '0' : ''
			) + Math.floor(Math.abs(P / 60)) + ':' + (
				Math.abs(P % 60) === 0 ? '00' : (
					(
						Math.abs(P % 60) < 10 ? '0' : ''
					)
				) + (
					Math.abs(P % 60)
				)
			);
		},

		/**
		 * @returns {string}
		 */
		T: function () {
			const tz = this.toLocaleTimeString(
				navigator.language,
				{ timeZoneName: 'short' }
			).split(' ');
			return tz[tz.length - 1];
		},

		/**
		 * @returns {number}
		 */
		Z: function () {
			return -this.getTimezoneOffset() * 60;
		},

		// Full Date / Time
		// ---------------------------------------------------------------------

		/**
		 * @returns {*|string}
		 */
		c: function () {
			return FormatDate.format(this, "Y-m-d\\TH:i:sP");
		},

		/**
		 * @returns {string}
		 */
		r: function () {
			return this.toString();
		},

		/**
		 * @returns {number}
		 */
		U: function () {
			return this.getTime() / 1000;
		},

	};

	// Methods
	// =========================================================================

	/**
	 * Formats the given date
	 *
	 * @param {Date|string|number} date - The date to format
	 * @param {string} format - The format string (see http://php.net/manual/en/function.date.php)
	 * @return {string}
	 */
	static format (date, format) {
		if (!(date instanceof Date))
			date = new Date(date);

		return format.replace(/(\\?)(.)/g, function(_, esc, chr) {
			return (esc === '' && FormatDate._replaceChars[chr])
				? FormatDate._replaceChars[chr].call(date)
				: chr;
		});
	}

}

export default FormatDate.format;

/**
 * Converts the given FormData to a JSON String
 *
 * @param {FormData} formData
 * @returns {string}
 */
export default function formDataToJson (formData) {
	const object = {};

	formData.forEach((value, key) => {
		if(!Reflect.has(object, key)){
			object[key] = value;
			return;
		}

		if(!Array.isArray(object[key]))
			object[key] = [object[key]];

		object[key].push(value);
	});

	return JSON.stringify(object);
}

/**
 * Checks if the given element has a valid name and value, and isn't disabled
 *
 * @param {Element|HTMLInputElement|HTMLSelectElement|HTMLTextAreaElement} element
 * @return {Boolean}
 */
function isValidElement (element) {
	let parent = element.parentNode;

	while (parent && parent.nodeName.toLowerCase() !== 'form') {
		if (parent.nodeName.toLowerCase() === 'fieldset' && parent.disabled)
			return false;

		parent = parent.parentNode;
	}

	return element.name && element.value && !element.disabled;
}

/**
 * Checks if the given elements value can be saved
 * (i.e. not an unchecked checkbox)
 *
 * @param {Element|HTMLInputElement} element
 * @return {Boolean}
 */
function isValidValue (element) {
	return (!['checkbox', 'radio'].includes(element.type) || element.checked);
}

/**
 * Checks if the given element is a checkbox
 *
 * @param {Element|HTMLInputElement} element
 * @return {Boolean}
 */
function isCheckbox (element) {
	return element.type === 'checkbox';
}

/**
 * Checks if the given element is a select w/ the multiple attribute
 *
 * @param {Element|HTMLSelectElement} element
 * @return {Boolean}
 */
function isMultiSelect (element) {
	return element.options && element.multiple;
}

/**
 * Gets the selected values from the given multi-select element
 *
 * @param {HTMLOptionsCollection} element
 * @return {Array}
 */
function getSelectValues (element) {
	return [].reduce.call(element, (values, option) => {
		return option.selected ? values.concat(option.value) : values;
	}, []);
}

/**
 * Converts the given form elements to an object
 *
 * @param {HTMLFormControlsCollection} elements
 *
 * @return {Object}
 */
export default function formToObj (elements) {
	return [].reduce.call(elements, (data, element) => {
		if (!isValidElement(element) || !isValidValue(element))
			return data;

		if (isCheckbox(element))
			data[element.name] = (data[element.name] || []).concat(element.value);
		else if (isMultiSelect(element))
			data[element.name] = getSelectValues(element);
		else
			data[element.name] = element.value;

		return data;
	}, {});
}

/**
 * ## Fuzzy
 * A tiny and blazing-fast fuzzy search in JavaScript
 *
 * Shamelessly stolen from https://github.com/bevacqua/fuzzysearch
 * (but modified slightly, so it's okay)
 *
 * @param {string} needle - The thing to search for
 * @param {string|string[]} haystack - The thing to search in
 * @param {boolean} caseSensitive - Should the search be case sensitive?
 * @return {boolean} - Whether or not we have a match
 */
export default function fuzzy (needle, haystack, caseSensitive = false) {
	if (Array.isArray(haystack)) {
		for (const straw of haystack)
			if (fuzzy(needle, straw, caseSensitive))
				return true;
		
		return false;
	}
	
	if (typeof haystack === typeof {})
		haystack = JSON.stringify(Object.values(haystack));

	if (!caseSensitive) {
		needle = needle.toLowerCase();
		haystack = haystack.toLowerCase();
	}

	const hlen = haystack.length
		, nlen = needle.length;

	if (nlen > hlen)
		return false;

	if (nlen === hlen)
		return needle === haystack;

	outer: for (let i = 0, j = 0; i < nlen; i++) {
		const nch = needle.charCodeAt(i);

		while (j < hlen)
			if (haystack.charCodeAt(j++) === nch)
				continue outer;

		return false;
	}

	return true;
}

/**
 * Will get the nearest scrollable parent
 *
 * @param {HTMLElement} element
 * @param {Boolean?} includeHidden
 * @returns {HTMLElement}
 */
export default function getScrollParent (element, includeHidden = false) {
	let style = getComputedStyle(element);
	const excludeStaticParent = style.position === 'absolute';
	const overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/;

	if (style.position === 'fixed')
		return document.documentElement;

	for (let parent = element; (parent = parent.parentElement);) {
		style = getComputedStyle(parent);

		if (excludeStaticParent && style.position === 'static')
			continue;

		if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX))
			return parent;
	}

	return document.documentElement;
}

/**
 * Calculate the distance between point A and point B
 *
 * @param {[Number, Number]} pointA - The [Lat, Lon] of point A
 * @param {[Number, Number]} pointB - The [Lat, Lon] of point B
 * @param useMiles - Return the result in miles (defaults to kilometres)
 * @returns {number}
 * @see https://stackoverflow.com/a/48805273/550109
 */
export default function haversine (pointA, pointB, useMiles = false) {
	let [lat1, lon1] = pointA,
		[lat2, lon2] = pointB;

	const toRadian = angle => (Math.PI / 180) * angle;
	const distance = (a, b) => (Math.PI / 180) * (a - b);
	const RADIUS_OF_EARTH_IN_KM = 6371;

	const dLat = distance(lat2, lat1);
	const dLon = distance(lon2, lon1);

	lat1 = toRadian(lat1);
	lat2 = toRadian(lat2);

	// Haversine Formula
	const a =
		Math.pow(Math.sin(dLat / 2), 2) +
		Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
	const c = 2 * Math.asin(Math.sqrt(a));

	let finalDistance = RADIUS_OF_EARTH_IN_KM * c;

	if (useMiles)
		finalDistance /= 1.60934;

	return finalDistance;
}

/**
 * A pause-able interval timer
 * via: https://stackoverflow.com/a/24725066/550109
 *
 * ```js
 * const timer = new IntervalTimer(function () {
 *     alert("Done!");
 * }, 5000);
 *
 * timer.pause();
 * timer.resume();
 * timer.restart();
 * ```
 *
 * @param {Function} callback
 * @param {number} interval
 * @constructor
 */
export default function IntervalTimer (callback, interval) {
	let timerId, startTime, remaining = 0;
	let state = 0; //  0 = idle, 1 = running, 2 = paused, 3 = resumed

	this.pause = function () {
		if (state !== 1) return;

		remaining = interval - (new Date() - startTime);
		window.clearInterval(timerId);
		state = 2;
	};

	this.resume = function () {
		if (state !== 2) return;

		state = 3;
		window.setTimeout(this.timeoutCallback, remaining);
	};

	this.restart = function () {
		startTime = new Date();
		timerId = window.setInterval(callback, interval);
		state = 1;
	};

	this.timeoutCallback = function () {
		if (state !== 3) return;

		callback();

		startTime = new Date();
		timerId = window.setInterval(callback, interval);
		state = 1;
	};

	this.restart();
}

/**
 * Detects if the given hex is dark
 *
 * isDark('#262629') -> true
 * isDark(0xfff) -> false
 * isDark('000', 20) -> false
 *
 * @param {string|number} color - The colour to test (Supports 3 & 6 length hexes, with or without a hash)
 * @param {number} threshold - The luma value, below which is considered dark (0-255)
 * @returns {boolean}
 * @see {@link https://stackoverflow.com/a/12043228/550109} for original source
 */
export default function isDark (color, threshold = 40) {
	const c = typeof color === 'string' ? color.replace('#', '') : color;
	const rgb = parseInt(c, 16); // convert rrggbb to decimal
	const r = (rgb >> 16) & 0xff       // extract red
		, g = (rgb >>  8) & 0xff       // extract green
		, b = (rgb >>  0) & 0xff;      // extract blue

	const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b; // per ITU-R BT.709

	return luma < threshold;
}

/**
 * Converts the given string to kebab-case
 */
export default function kebab (str) {
	if (str === str.toUpperCase()) str = str.toLowerCase();
	
	return str
		.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
		.map(x => x.toLowerCase())
		.join('-');
}

/**
 * Clamps the number within the given range
 *
 * @param {Number} num - The number to clamp
 * @param {Number} min - The minimum limited value
 * @param {Number} max - The maximum limited value
 * @returns {number} - The clamped number
 */
export default function minmax (num, min, max) {
	return Math.min(Math.max(+num, min), max);
}

/**
 * Will take a given number and append the appropriate ordinal
 *
 * ordinal(20) => 20th
 * ordinal(21) => 21st
 * ordinal(22) => 22nd
 * ordinal(23) => 23rd
 * ordinal('March 15 2020') => March 15th 2020
 *
 * @param {number|string} n
 * @return {string}
 */
export default function ordinal (n) {
	if (typeof n === 'string')
		return n.replaceAll(/\b(\d{1,2})\b/gm, (_, b) => ordinal(+b));

	return n + (n > 0 ? ['th', 'st', 'nd', 'rd'][(n > 3 && n < 21) || n % 10 > 3 ? 0 : n % 10] : '');
}

// Stolen from https://gist.github.com/kerimdzhanov/7529623

/**
 * Get a random floating point number between `min` and `max`.
 *
 * @param {number} min - min number
 * @param {number} max - max number
 * @return {number} a random floating point number
 */
export function getRandomFloat(min, max) {
	return Math.random() * (max - min) + min;
}

/**
 * Get a random integer between `min` and `max`.
 *
 * @param {number} min - min number
 * @param {number} max - max number
 * @return {number} a random integer
 */
export function getRandomInt(min, max) {
	return Math.floor(Math.random() * (max - min + 1) + min);
}

/**
 * Get a random boolean value.
 *
 * @return {boolean} a random true/false
 */
export function getRandomBool() {
	return Math.random() >= 0.5;
}

/**
 * Returns a random value from the given array
 *
 * @param {Array} array
 * @returns {*}
 */
export default function randomFromArray (array) {
	return array[Math.floor(Math.random() * array.length)];
}

/**
 * weightedRandom({
 *     'a': 0.1, // 10%
 *     'b': 0.5, // 50%
 *     'c': 0.4, // 40%
 * })
 *
 * @param {Object} spec
 * @return {function(): *}
 */
export function weightedRandom (spec) {
	const totalWeights = Object.values(spec).reduce((a, b) => a + b, 0) * 10;
	let i, j, table = [];

	for (i in spec)
		for (j = 0; j < spec[i] * totalWeights; j++)
			table.push(i);

	return () => randomFromArray(table);
}

export default function Textarea () {
	const onInput = e => {
		let { borderTopWidth, borderBottomWidth } = window.getComputedStyle(e.target);
		borderTopWidth = +borderTopWidth.replace(/[^\d.]/g, '');
		borderBottomWidth = +borderBottomWidth.replace(/[^\d.]/g, '');
		e.target.style.height = '';
		e.target.style.height = (e.target.scrollHeight + borderTopWidth + borderBottomWidth) + 'px';
	};
	
	return (
		<textarea onInput={onInput} />
	);
}

/**
 * Will shift the specified number of items to the end of the array
 *
 * @param {Array} array - The array to modify
 * @param {Number} count - The number of items to shift
 * @returns {Array} - The modified array
 */
export default function shiftToEnd (array, count) {
	array = [...array];
	count = count % array.length;

	for (let i = 0; i < count; i++)
		array.push(array[i]);

	array.splice(0, count);

	return array;
}

/**
 * Randomly shuffles the given array using Durstenfeld
 *
 * @param {array} array
 * @returns {array}
 */
export default function shuffle (array) {
	for (let i = array.length - 1; i > 0; i--) {
		const j = Math.floor(Math.random() * (i + 1));
		[array[i], array[j]] = [array[j], array[i]];
	}
	
	return array;
}

/**
 * Decode / Unescape HTML entities
 *
 * @param str
 * @returns {*}
 */
export default function unescape (str) {
	return str.replace(/&[^;]+;/gm, m => ({
		'&quot;': '"',
		'&#34;': '"',

		'&apos;': '\'',
		'&#39;': '\'',

		'&amp;': '&',
		'&#38;': '&',

		'&gt;': '>',
		'&#62;': '>',

		'&lt;': '<',
		'&#60;': '<',

		'&cent;': '¢',
		'&#162;': '¢',

		'&copy;': '©',
		'&#169;': '©',

		'&euro;': '€',
		'&#8364;': '€',

		'&pound;': '£',
		'&#163;': '£',

		'&reg;': '®',
		'&#174;': '®',

		'&yen;': '¥',
		'&#165;': '¥',
	}[m.replace(/#(0+)/gm, '#')]));
}

/**
 * Get the time from now until the given date in the format of
 * X years, X months, X weeks, X days, X hours, X minutes, and X seconds
 * hiding and pluralising values accordingly.
 *
 * @param {Date|number|string} date
 * @param {Date|number|string|null} now - Defaults to current time if null
 * @param {number} bitmask - The values to show in the string output (or as an object)
 * @return {string|null|{s: number, d: number, w: number, h: number, y: number, i: number, m: number}}
 */
export default function until (
	date,
	now = null,
	bitmask = until.DATE
) {
	date = new Date(date);
	now = now ? new Date(now) : new Date();

	if (date < now)
		return null;

	let y = date.getFullYear() - now.getFullYear(),
		m = date.getMonth() - now.getMonth(),
		d = date.getDate() - now.getDate(),
		h = date.getUTCHours() - now.getUTCHours(),
		i = date.getUTCMinutes() - now.getUTCMinutes(),
		s = date.getUTCSeconds() - now.getUTCSeconds();

	const ny = now.getFullYear();

	if (m < 0) {
		y--;
		m += 12;
	}

	if (d < 0) {
		if (m > 0) m--;
		else {
			y--;
			m = 11;
		}

		d += [
			31,
			(ny % 4 === 0 && ny % 100 !== 0) || ny % 400 === 0 ? 29 : 28,
			31,
			30,
			31,
			30,
			31,
			31,
			30,
			31,
			30,
			31,
		][now.getMonth()];
	}

	let w = Math.floor(d / 7);
	if (w > 0) d %= 7;

	if (h < 0) {
		if (d > 0) d--;
		h += 24;
	}

	if (i < 0) {
		if (h > 0) h--;
		i += 60;
	}

	if (s < 0) {
		if (i > 0) i--;
		s += 60;
	}

	const p = v => v === 1 ? '' : 's';

	if (bitmask & until.OBJECT)
		return { y, m, w, d, h, i, s };

	!(bitmask & until.YEAR)   && (y = 0);
	!(bitmask & until.MONTH)  && (m = 0);
	!(bitmask & until.WEEK)   && (w = 0);
	!(bitmask & until.DAY)    && (d = 0);
	!(bitmask & until.HOUR)   && (h = 0);
	!(bitmask & until.MINUTE) && (i = 0);
	!(bitmask & until.SECOND) && (s = 0);

	return [
		y > 0 ? `${y} year${p(y)}` : null,
		m > 0 ? `${m} month${p(m)}` : null,
		w > 0 ? `${w} week${p(w)}` : null,
		d > 0 ? `${d} day${p(d)}` : null,
		h > 0 ? `${h} hour${p(h)}` : null,
		i > 0 ? `${i} minute${p(i)}` : null,
		s > 0 ? `${s} second${p(s)}` : null,
	].filter(Boolean).join(', ').replace(/,([^,]*)$/, ', and $1');
}

until.OBJECT   = 1<<0;
until.YEAR     = 1<<1;
until.MONTH    = 1<<2;
until.WEEK     = 1<<3;
until.DAY      = 1<<4;
until.HOUR     = 1<<5;
until.MINUTE   = 1<<6;
until.SECOND   = 1<<7;
until.DATE     = until.YEAR | until.MONTH | until.WEEK | until.DAY;
until.TIME     = until.HOUR | until.MINUTE | until.SECOND;
until.DATETIME = until.DATE | until.TIME;

import { useEffect, useRef, MutableRefObject } from 'react';

/**
 * Tiny X-axis swipe handler
 *
 * dir < 0 === right to left
 * dir > 0 === left to right
 *
 * ```js
 * const swipeRef = useSwipe(distanceTravelledInDirection => ...);
 *
 * // ...
 *
 * <div ref={swipeRef} />
 * ```
 *
 * @param {(dir: number) => void} callback
 * @return {MutableRefObject<T>}
 */
export default function useSwipe (callback) {
	const ref = useRef();

	useEffect(() => {
		if (!ref.current) return;
		const el = ref.current;

		let touchStart = 0,
			touchEnd   = 0;

		const onTouchStart = e => touchStart = e.changedTouches[0].screenX;
		const onTouchEnd = e => {
			touchEnd = e.changedTouches[0].screenX;
			callback(touchEnd - touchStart);
		};

		el.addEventListener('touchstart', onTouchStart);
		el.addEventListener('touchend', onTouchEnd);

		return () => {
			el.removeEventListener('touchstart', onTouchStart);
			el.removeEventListener('touchend', onTouchEnd);
		};
	}, [ref, callback]);

	return ref;
}

/**
 * Will generate a random UUID v4
 *
 * @see https://stackoverflow.com/a/2117523/550109
 * @return {string}
 */
export default function uuid () {
	return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
		(c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
	);
}