/**
 * Shelf handles persistent key/value pairs, or records, which are stored in the shelf collection on the
 * server, and can be accessed and manipulated in a concurrent fashion.
 *
 * @author Alain Pitiot
 * @version 2021.2.3
 * @copyright (c) 2022 Open Science Tools Ltd. (https://opensciencetools.org)
 * @license Distributed under the terms of the MIT License
 */

import {PsychObject} from "../util/PsychObject.js";
import {PsychoJS} from "../core/PsychoJS.js";
import {ExperimentHandler} from "./ExperimentHandler";
import {Scheduler} from "../util/Scheduler.js";


/**
 * <p>Shelf handles persistent key/value pairs, or records, which are stored in the shelf collection on the
 * server, and can be accessed and manipulated in a concurrent fashion.</p>
 *
 * @extends PsychObject
 */
export class Shelf extends PsychObject
{
	/**
	 * Maximum number of components in a key
	 * @type {number}
	 * @note this value should mirror that on the server, i.e. the server also checks that the key is valid
	 */
	static #MAX_KEY_LENGTH = 10;

	/**
	 * @memberOf module:data
	 * @param {Object} options
	 * @param {module:core.PsychoJS} options.psychoJS 	the PsychoJS instance
	 * @param {boolean} [options.autoLog= false] 				whether to log
	 */
	constructor({psychoJS, autoLog = false } = {})
	{
		super(psychoJS);

		this._addAttribute('autoLog', autoLog);
		this._addAttribute('status', Shelf.Status.READY);

		// minimum period of time, in ms, before two calls to Shelf methods, i.e. throttling:
		this._throttlingPeriod_ms = 500.0;

		// timestamp of the last actual call to a Shelf method:
		this._lastCallTimestamp = 0.0;
		// timestamp of the last scheduled call to a Shelf method:
		this._lastScheduledCallTimestamp = 0.0;
	}

	/**
	 * Get the value of a record of type BOOLEAN associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key					 	key as an array of key components
	 * @param {boolean} options.defaultValue		the default value returned if no record with the given key exists
	 * 	on the shelf
	 * @return {Promise<boolean>}								the value associated with the key
	 * @throws {Object.<string, *>} 						exception if there is a record associated with the given key
	 * 	but it is not of type BOOLEAN
	 */
	getBooleanValue({key, defaultValue} = {})
	{
		return this._getValue(key, Shelf.Type.BOOLEAN, {defaultValue});
	}

	/**
	 * Set the value of a record of type BOOLEAN associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		 	key as an array of key components
	 * @param {boolean} options.value 		the new value
	 * @return {Promise<boolean>}					the new value
	 * @throws {Object.<string, *>} 			exception if value is not a boolean, or if there is no record with the given
	 * 	key, or if there is a record but it is locked or it is not of type BOOLEAN
	 */
	setBooleanValue({key, value} = {})
	{
		// check the value:
		if (typeof value !== "boolean")
		{
			throw {
				origin: "Shelf.setIntegerValue",
				context: `when setting the value of the BOOLEAN record associated with the key: ${JSON.stringify(key)}`,
				error: "the value should be a boolean"
			};
		}

		// update the value:
		const update = {
			action: "SET",
			value
		};
		return this._updateValue(key, Shelf.Type.BOOLEAN, update);
	}

	/**
	 * Flip the value of a record of type BOOLEAN associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		key as an array of key components
	 * @return {Promise<boolean>}				the new, flipped, value
	 * @throws {Object.<string, *>} 		exception if there is no record with the given key, or
	 * 	if there is a record but it is not of type BOOLEAN
	 */
	flipBooleanValue({key} = {})
	{
		// update the value:
		const update = {
			action: "FLIP"
		};
		return this._updateValue(key, Shelf.Type.BOOLEAN, update);
	}

	/**
	 * Get the value of a record of type INTEGER associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		 			key as an array of key components
	 * @param {number} options.defaultValue		the default value returned if no record with the given key
	 * 	exists on the shelf
	 * @return {Promise<number>}							the value associated with the key
	 * @throws {Object.<string, *>} 					exception if there is no record with the given key,
	 * 	or if there is a record but it is locked or it is not of type BOOLEAN
	 */
	getIntegerValue({key, defaultValue} = {})
	{
		return this._getValue(key, Shelf.Type.INTEGER, {defaultValue});
	}

	/**
	 * Set the value of a record of type INTEGER associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		key as an array of key components
	 * @param {number} options.value 		the new value
	 * @return {Promise<number>} 				the new value
	 * @throws {Object.<string, *>} 		exception if value is not an integer, or or if there is no record
	 * 	with the given key, or if there is a record but it is locked or it is not of type INTEGER
	 */
	setIntegerValue({key, value} = {})
	{
		// check the value:
		if (!Number.isInteger(value))
		{
			throw {
				origin: "Shelf.setIntegerValue",
				context: `when setting the value of the INTEGER record associated with the key: ${JSON.stringify(key)}`,
				error: "the value should be an integer"
			};
		}

		// update the value:
		const update = {
			action: "SET",
			value
		};
		return this._updateValue(key, Shelf.Type.INTEGER, update);
	}

	/**
	 * Add a delta to  the value of a record of type INTEGER associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		 	key as an array of key components
	 * @param {number} options.delta 		the delta, positive or negative, to add to the value
	 * @return {Promise<number>} 					the new value
	 * @throws {Object.<string, *>} 			exception if delta is not an integer, or if there is no record with the given
	 * 	key, or if there is a record but it is locked or it is not of type INTEGER
	 */
	addIntegerValue({key, delta} = {})
	{
		// check the delta:
		if (!Number.isInteger(delta))
		{
			throw {
				origin: "Shelf.setIntegerValue",
				context: `when adding a value to the value of the INTEGER record associated with the key: ${JSON.stringify(key)}`,
				error: "the value should be an integer"
			};
		}

		// update the value:
		const update = {
			action: "ADD",
			delta
		};
		return this._updateValue(key, Shelf.Type.INTEGER, update);
	}

	/**
	 * Get the value of a record of type TEXT associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key					 	key as an array of key components
	 * @param {string} options.defaultValue		the default value returned if no record with the given key exists on
	 * 	the shelf
	 * @return {Promise<string>}									the value associated with the key
	 * @throws {Object.<string, *>} 						exception if there is a record associated with the given key but it is
	 * 	not of type TEXT
	 */
	getTextValue({key, defaultValue} = {})
	{
		return this._getValue(key, Shelf.Type.TEXT, {defaultValue});
	}

	/**
	 * Set the value of a record of type TEXT associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		 	key as an array of key components
	 * @param {string} options.value 			the new value
	 * @return {Promise<string>} 					the new value
	 * @throws {Object.<string, *>} 			exception if value is not a string, or if there is a record associated
	 * 	with the given key but it is not of type TEXT
	 */
	setTextValue({key, value} = {})
	{
		// check the value:
		if (typeof value !== "string")
		{
			throw {
				origin: "Shelf.setTextValue",
				context: `when setting the value of the TEXT record associated with the key: ${JSON.stringify(key)}`,
				error: "the value should be a string"
			};
		}

		// update the value:
		const update = {
			action: "SET",
			value
		};
		return this._updateValue(key, Shelf.Type.TEXT, update);
	}

	/**
	 * Get the value of a record of type LIST associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key					 			key as an array of key components
	 * @param {Array.<*>} options.defaultValue		the default value returned if no record with the given key exists on
	 * 	the shelf
	 * @return {Promise<Array.<*>>}								the value associated with the key
	 * @throws {Object.<string, *>} 								exception if there is no record with the given key, or if there is a record
	 * 	but it is locked or it is not of type LIST
	 */
	getListValue({key, defaultValue} = {})
	{
		return this._getValue(key, Shelf.Type.LIST, {defaultValue});
	}

	/**
	 * Set the value of a record of type LIST associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		 		key as an array of key components
	 * @param {Array.<*>} options.value 	the new value
	 * @return {Promise<Array.<*>>}				the new value
	 * @throws {Object.<string, *>} 				exception if value is not an array or if there is no record with the given key,
	 * 	or if there is a record but it is locked or it is not of type LIST
	 */
	setListValue({key, value} = {})
	{
		// check the value:
		if (!Array.isArray(value))
		{
			throw {
				origin: "Shelf.setListValue",
				context: `when setting the value of the LIST record associated with the key: ${JSON.stringify(key)}`,
				error: "the value should be an array"
			};
		}

		// update the value:
		const update = {
			action: "SET",
			value
		};
		return this._updateValue(key, Shelf.Type.LIST, update);
	}

	/**
	 * Append an element, or a list of elements, to the value of a record of type LIST associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		key as an array of key components
	 * @param {*} options.elements 		the element or list of elements to be appended
	 * @return {Promise<Array.<*>>}		the new value
	 * @throws {Object.<string, *>} 		exception if there is no record with the given key, or if there is a record
	 * 	but it is locked or it is not of type LIST
	 */
	appendListValue({key, elements} = {})
	{
		// update the value:
		const update = {
			action: "APPEND",
			elements
		};
		return this._updateValue(key, Shelf.Type.LIST, update);
	}

	/**
	 * Pop an element, at the given index, from the value of a record of type LIST associated
	 * with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key						key as an array of key components
	 * @param {number} [options.index = -1] 	the index of the element to be popped
	 * @return {Promise<*>}											the popped element
	 * @throws {Object.<string, *>} 						exception if there is no record with the given key, or if there is a record
	 * 	but it is locked or it is not of type LIST
	 */
	popListValue({key, index = -1} = {})
	{
		// update the value:
		const update = {
			action: "POP",
			index
		};
		return this._updateValue(key, Shelf.Type.LIST, update);
	}

	/**
	 * Empty the value of a record of type LIST associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		key as an array of key components
	 * @return {Promise<Array.<*>>}		the new, empty value, i.e. []
	 * @throws {Object.<string, *>} 		exception if there is no record with the given key, or if there is a record
	 * 	but it is locked or it is not of type LIST
	 */
	clearListValue({key} = {})
	{
		// update the value:
		const update = {
			action: "CLEAR"
		};
		return this._updateValue(key, Shelf.Type.LIST, update);
	}

	/**
	 * Shuffle the elements of the value of a record of type LIST associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		key as an array of key components
	 * @return {Promise<Array.<*>>}		the new, shuffled value
	 * @throws {Object.<string, *>} 		exception if there is no record with the given key, or if there is a record
	 * 	but it is locked or it is not of type LIST
	 */
	shuffleListValue({key} = {})
	{
		// update the value:
		const update = {
			action: "SHUFFLE"
		};
		return this._updateValue(key, Shelf.Type.LIST, update);
	}


	/**
	 * Get the names of the fields in the dictionary record associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		key as an array of key components
	 * @return {Promise<string[]>}			the list of field names
	 * @throws {Object.<string, *>} 		exception if there is no record with the given key, or if there is a record
	 * 	but it is locked or it is not of type DICTIONARY
	 */
	async getDictionaryFieldNames({key} = {})
	{
		return this._getValue(key, Shelf.Type.DICTIONARY, {fieldNames: true});
	}

	/**
	 * Get the value of a given field in the dictionary record associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key					 	key as an array of key components
	 * @param {string} options.fieldName				the name of the field
	 * @param {boolean} options.defaultValue		the default value returned if no record with the given key exists on
	 * 	the shelf, or if is a record of type DICTIONARY with the given key but it has no such field
	 * @return {Promise<*>}											the value of that field
	 * @throws {Object.<string, *>} 						exception if there is no record with the given key,
	 * 	or if there is a record but it is locked or it is not of type DICTIONARY
	 */
	async getDictionaryFieldValue({key, fieldName, defaultValue} = {})
	{
		return this._getValue(key, Shelf.Type.DICTIONARY, {fieldName, defaultValue});
	}

	/**
	 * Set a field in the dictionary record associated to the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key					key as an array of key components
	 * @param {string} options.fieldName			the name of the field
	 * @param {*} options.fieldValue					the value of the field
	 * @return {Promise<Object.<string, *>>}	the updated dictionary
	 * @throws {Object.<string, *>} 					exception if there is no record with the given key,
	 * 	or if there is a record but it is locked or it is not of type DICTIONARY
	 */
	async setDictionaryFieldValue({key, fieldName, fieldValue} = {})
	{
		// update the value:
		const update = {
			action: "FIELD_SET",
			fieldName,
			fieldValue
		};
		return this._updateValue(key, Shelf.Type.DICTIONARY, update);
	}

	/**
	 * Get the value of a record of type DICTIONARY associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key		 									key as an array of key components
	 * @param {Object.<string, *>} options.defaultValue		the default value returned if no record with the given key
	 * 	exists on the shelf
	 * @return {Promise<Object.<string, *>>}							the value associated with the key
	 * @throws {Object.<string, *>} 											exception if there is no record with the given key,
	 * 	or if there is a record but it is locked or it is not of type DICTIONARY
	 */
	getDictionaryValue({key, defaultValue} = {})
	{
		return this._getValue(key, Shelf.Type.DICTIONARY, {defaultValue});
	}

	/**
	 * Set the value of a record of type DICTIONARY associated with the given key.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key							key as an array of key components
	 * @param {Object.<string, *>} options.value 	the new value
	 * @return {Promise<Object.<string, *>>} 			the new value
	 * @throws {Object.<string, *>} 							exception if value is not an object, or or if there is no record
	 * 	with the given key, or if there is a record but it is locked or it is not of type DICTIONARY
	 */
	setDictionaryValue({key, value} = {})
	{
		// check the value:
		if (typeof value !== "object")
		{
			throw {
				origin: "Shelf.setDictionaryValue",
				context: `when setting the value of the DICTIONARY record associated with the key: ${JSON.stringify(key)}`,
				error: "the value should be an object"
			};
		}

		// update the value:
		const update = {
			action: "SET",
			value
		};
		return this._updateValue(key, Shelf.Type.DICTIONARY, update);
	}

	/**
	 * Schedulable component that will block the experiment until the counter associated with the given key
	 * has been incremented by the given amount.
	 *
	 * @param key
	 * @param increment
	 * @param callback
	 * @returns {function(): module:util.Scheduler.Event|Symbol|*} a component that can be scheduled
	 *
	 * @example
	 * const flowScheduler = new Scheduler(psychoJS);
	 * var experimentCounter = '<>';
	 * flowScheduler.add(psychoJS.shelf.incrementComponent(['counter'], 1, (value) => experimentCounter = value));
	 */
	incrementComponent(key = [], increment = 1, callback)
	{
		const response = {
			origin: 'Shelf.incrementComponent',
			context: 'when making a component to increment a shelf counter'
		};

		try
		{
			// TODO replace this._incrementComponent by a component with a unique name
			let incrementComponent = {};
			incrementComponent.status = PsychoJS.Status.NOT_STARTED;
			return () =>
			{
				if (incrementComponent.status === PsychoJS.Status.NOT_STARTED)
				{
					incrementComponent.status = PsychoJS.Status.STARTED;
					this.increment(key, increment)
						.then( (newValue) =>
						{
							callback(newValue);
							incrementComponent.status = PsychoJS.Status.FINISHED;
						});
				}

				return (incrementComponent.status === PsychoJS.Status.FINISHED) ?
					Scheduler.Event.NEXT :
					Scheduler.Event.FLIP_REPEAT;
			};
		}
		catch (error)
		{
			this._status = Shelf.Status.ERROR;
			throw {...response, error};
		}
	}

	/**
	 * Get the name of a group, using a counterbalanced design.
	 *
	 * @param {Object} options
	 * @param {string[]} options.key					key as an array of key components
	 * @param {string[]} options.groups				the names of the groups
	 * @param {number[]} options.groupSizes		the size of the groups
	 * @return {Promise<{string, boolean}>}		an object with the name of the selected group and whether all groups
	 * 	have been depleted
	 */
	async counterBalanceSelect({key, groups, groupSizes} = {})
	{
		const response = {
			origin: 'Shelf.counterBalanceSelect',
			context: `when getting the name of a group, using a counterbalanced design, with key: ${JSON.stringify(key)}`
		};

		try
		{
			await this._checkAvailability("counterBalanceSelect");
			this._checkKey(key);

			// prepare the request:
			const url = `${this._psychoJS.config.pavlovia.URL}/api/v2/shelf/${this._psychoJS.config.session.token}/counterbalance`;
			const data = {
				key,
				groups,
				groupSizes
			};

			// query the server:
			const putResponse = await fetch(url, {
				method: 'PUT',
				mode: 'cors',
				cache: 'no-cache',
				credentials: 'same-origin',
				redirect: 'follow',
				referrerPolicy: 'no-referrer',
				headers: {
					'Content-Type': 'application/json'
				},
				body: JSON.stringify(data)
			});

			// convert the response to json:
			const document = await putResponse.json();

			if (putResponse.status !== 200)
			{
				throw ('error' in document) ? document.error : document;
			}

			// return the updated value:
			this._status = Shelf.Status.READY;
			return {
				group: document.group,
				finished: document.finished
			};
		}
		catch (error)
		{
			this._status = Shelf.Status.ERROR;
			throw {...response, error};
		}
	}


	/**
	 * Update the value associated with the given key.
	 *
	 * <p>This is a generic method, typically called from the Shelf helper methods, e.g. setBinaryValue.</p>
	 *
	 * @param {string[]} key					 	key as an array of key components
	 * @param {Shelf.Type} type 				the type of the record associated with the given key
	 * @param {*} update 							the desired update
	 * @return {Promise<any>}					the updated value
	 * @throws {Object.<string, *>} 	exception if there is no record associated with the given key or if there is one
	 * 	but it is not of the given type
	 */
	async _updateValue(key, type, update)
	{
		const response = {
			origin: 'Shelf._updateValue',
			context: `when updating the value of the ${Symbol.keyFor(type)} record associated with key: ${JSON.stringify(key)}`
		};

		try
		{
			await this._checkAvailability("_updateValue");
			this._checkKey(key);

			// prepare the request:
			const url = `${this._psychoJS.config.pavlovia.URL}/api/v2/shelf/${this._psychoJS.config.session.token}/value`;
			const data = {
				key,
				type: Symbol.keyFor(type),
				update
			};

			// query the server:
			const postResponse = await fetch(url, {
				method: 'POST',
				mode: 'cors',
				cache: 'no-cache',
				credentials: 'same-origin',
				redirect: 'follow',
				referrerPolicy: 'no-referrer',
				headers: {
					'Content-Type': 'application/json'
				},
				body: JSON.stringify(data)
			});

			// convert the response to json:
			const document = await postResponse.json();

			if (postResponse.status !== 200)
			{
				throw ('error' in document) ? document.error : document;
			}

			// return the updated value:
			this._status = Shelf.Status.READY;
			return document.value;
		}
		catch (error)
		{
			this._status = Shelf.Status.ERROR;
			throw {...response, error};
		}
	}

	/**
	 * Get the value associated with the given key.
	 *
	 * <p>This is a generic method, typically called from the Shelf helper methods, e.g. getBinaryValue.</p>
	 *
	 * @param {string[]} key					 	key as an array of key components
	 * @param {Shelf.Type} type 				the type of the record associated with the given key
	 * @param {Object} [options] 			the options, e.g. the default value returned if no record with the
	 * given key exists on the shelf
	 * @return {Promise<any>}					the value
	 * @throws {Object.<string, *>} 	exception if there is a record associated with the given key but it is not of
	 * 	the given type
	 */
	async _getValue(key, type, options)
	{
		const response = {
			origin: 'Shelf._getValue',
			context: `when getting the value of the ${Symbol.keyFor(type)} record associated with key: ${JSON.stringify(key)}`
		};

		try
		{
			await this._checkAvailability("_getValue");
			this._checkKey(key);

			// prepare the request:
			const url = `${this._psychoJS.config.pavlovia.URL}/api/v2/shelf/${this._psychoJS.config.session.token}/value`;
			const data = {
				key,
				type: Symbol.keyFor(type)
			};

			if (typeof options !== 'undefined')
			{
				for (const attribute in options)
				{
					if (typeof options[attribute] !== "undefined")
					{
						data[attribute] = options[attribute];
					}
				}
			}

			// query the server:
			const putResponse = await fetch(url, {
				method: 'PUT',
				mode: 'cors',
				cache: 'no-cache',
				credentials: 'same-origin',
				redirect: 'follow',
				referrerPolicy: 'no-referrer',
				headers: {
					'Content-Type': 'application/json'
				},
				body: JSON.stringify(data)
			});

			const document = await putResponse.json();

			if (putResponse.status !== 200)
			{
				throw ('error' in document) ? document.error : document;
			}

			// return the value:
			this._status = Shelf.Status.READY;
			return document.value;
		}
		catch (error)
		{
			this._status = Shelf.Status.ERROR;
			throw {...response, error};
		}
	}

	/**
	 * Check whether it is possible to run a given shelf command.
	 *
	 * <p>Since all Shelf methods call _checkAvailability, we also use it as a means to throttle those calls.</p>
	 *
	 * @param {string} [methodName=""] - name of the method requiring a check
	 * @throws {Object.<string, *>} exception if it is not possible to run the given shelf command
	 */
	_checkAvailability(methodName = "")
	{
		// Shelf requires access to the server, where the key/value pairs are stored:
		if (this._psychoJS.config.environment !== ExperimentHandler.Environment.SERVER)
		{
			throw {
				origin: 'Shelf._checkAvailability',
				context: 'when checking whether Shelf is available',
				error: 'the experiment has to be run on the server: shelf commands are not available locally'
			};
		}

		// throttle calls to Shelf methods:
		const self = this;
		return new Promise((resolve, reject) =>
		{
			const now = performance.now();

			// if the last scheduled call already occurred, schedule this one as soon as possible,
			// taking into account the throttling period:
			let timeoutDuration;
			if (now > self._lastScheduledCallTimestamp)
			{
				timeoutDuration = Math.max(0.0, self._throttlingPeriod_ms - (now - self._lastCallTimestamp));
				self._lastScheduledCallTimestamp = now + timeoutDuration;
			}
			// otherwise, schedule it after the next call:
			else
			{
				self._lastScheduledCallTimestamp += self._throttlingPeriod_ms;
				timeoutDuration = self._lastScheduledCallTimestamp;
			}

			setTimeout(
				() => {
					self._lastCallTimestamp = performance.now();
					self._status = Shelf.Status.BUSY;
					resolve();
					},
				timeoutDuration
			);
		});
	}

	/**
	 * Check the validity of the key.
	 *
	 * @param {object} key 							key whose validity is to be checked
	 * @throws {Object.<string, *>} 	exception if the key is invalid
	 */
	_checkKey(key)
	{
		// the key must be a non empty array:
		if (!Array.isArray(key) || key.length === 0)
		{
			throw 'the key must be a non empty array';
		}

		if (key.length > Shelf.#MAX_KEY_LENGTH)
		{
			throw 'the key consists of too many components';
		}

		// the only @<component> in the key should be @designer and @experiment
		// TODO
	}
}

/**
 * Shelf status
 *
 * @enum {Symbol}
 * @readonly
 */
Shelf.Status = {
	/**
	 * The shelf is ready.
	 */
	READY: Symbol.for('READY'),

	/**
	 * The shelf is busy, e.g. storing or retrieving values.
	 */
	BUSY: Symbol.for('BUSY'),

	/**
	 * The shelf has encountered an error.
	 */
	ERROR: Symbol.for('ERROR')
};

/**
 * Shelf record types.
 *
 * @enum {Symbol}
 * @readonly
 */
Shelf.Type = {
	INTEGER: Symbol.for('INTEGER'),
	TEXT: Symbol.for('TEXT'),
	DICTIONARY: Symbol.for('DICTIONARY'),
	BOOLEAN: Symbol.for('BOOLEAN'),
	LIST: Symbol.for('LIST')
};
