class SqlTransactions{

	constructor(database){
		this.database = database;
		this.stack    = Array();
	}

	query(query, bindings = Array()){
		if(bindings){
			this.stack.push( {query: query, bindings: bindings} );
			return;
		}
		this.stack.push( query );
	}

	select(table, parameters = {}, bindings = Array()){
		const query = `SELECT ${parameters.fields ? parameters.fields : '*'} FROM ${table}${parameters.where ? ' WHERE ' + parameters.where : ''}${parameters.orderBy ? ' ORDER BY ' + parameters.orderBy : ''}`;
		this.query(query, bindings);
	}

	insert(table, data = Array()){
		if(!data.length) return;

		function divideArrays(arr){
			const divide = 499;
			const pieces = Array();
			const times  = Math.ceil(arr.length / divide);

			if(arr.length < divide){
				return [arr];
			}

			for(let counter = 0; counter < times; counter++){
				pieces.push(arr.splice(0, divide));
			}
			return pieces;
		}

		const keysLength = Object.keys(data[0]).length;
		const keys       = Object.keys(data[0]).join(', ');
		const values     = Array();
		const refused    = Array();

		data.forEach(insert => {
			const valuesArr    = Object.values(insert);
			const valuesLength = valuesArr.length;
			const block        = '(' + valuesArr.map(value => `"${value}"`).join(', ') + ')';
			keysLength === valuesLength ? values.push( block ) : refused.push( block );
		});

		if(refused.length) return;

		const pieces = divideArrays(values);
		pieces.forEach(piece => {
			const values = piece.join(', ');
			const query  = `INSERT OR REPLACE INTO ${table} (${keys}) VALUES ${values}`;
			this.stack.push( query );
		});
	}

	update(table, data = Array()){
		this.insert(table, data);
	}

	delete(table, condition, bindings = Array()){
		if(!condition) return;
		const query = `DELETE FROM ${table} ${condition}`;
		this.query( query, bindings );
	}

	getStack(){
		return this.stack;
	}

	clearStack(){
		this.stack = Array();
	}

	mountTransaction(transaction, parameters){
		return new Promise((resolve, reject) => {
			const query    = typeof parameters === 'string' ? parameters : parameters.query;
			const bindings = typeof parameters === 'string' ? [] : parameters.bindings;
			// t = transaction || s = success || e = error
			return transaction.executeSql( query, bindings, (t, s) => resolve(s), (t, e) => {
				reject(e);
				// must return a non-false value to automatically rollback querys
				return true;
			});
		});
	}

	executeStack(){
		return new Promise((resolve, reject) => {
			if(!this.stack.length){
				reject('EMPTY_STACK');
				return;
			}

			this.database.transaction(transaction => {
				const promises = this.stack.map( parameters => this.mountTransaction(transaction, parameters) );
				Promise.all(promises).then(res => {
					this.clearStack();
					resolve(res);
				}, err => {
					this.clearStack();
					reject(err);
				});
			});
		});
	}

	updateDatabase(oldVersion, newVersion){
		return new Promise((resolve, reject) => {
			if(!this.stack.length){
				reject('EMPTY_STACK');
				return;
			}

			this.database.changeVersion(String(oldVersion), String(newVersion), (transaction) => {
				const promises = this.stack.map( parameters => this.mountTransaction(transaction, parameters) );
				Promise.all(promises).then(res => {
					this.clearStack();
					resolve(res);
				}, err => {
					this.clearStack();
					reject(err);
				});
			});
		});
	}
}