var queryize = function (original) {
  var query = {};

  // bind all mutators directly to query
  for (const [ key, fn ] of Object.entries(mutators)) {
    query[key] = (typeof fn === 'function' ? fn.bind(query) : fn);
  }

  query._constructor = queryize;
  query._isQueryizeObject = true;
  query._evalFunction = queryize.evalFunction;
  query._attributes = {
    debugEnabled: false,
    database: false,
    tableName: false,
    fromSubquery: false,
    alias: false,
    dataBindings: {},
    useBoundParameters: queryize.useBoundParameters,
    where: [],
    whereBoolean: null,
    set: [],
    setKeys: {},
    columns: [ '*' ],
    joins: [],
    orderBy: false,
    groupBy: false,
    distinct: false,
    limit: false,
    asName: false,
    builder: false,
  };

  if (original) {
    if (original._isQueryizeObject) {
      Object.assign(query._attributes, original.export());
    } else if (typeof original === 'object') {
      Object.assign(query._attributes, original);
    }
  }

  return query;
};

queryize.select = function (...args) {
  var q = queryize();
  q.select(...args);
  return q;
};

queryize.update = function (...args) {
  var q = queryize();
  q.update(...args);
  return q;
};

queryize.insert = function (...args) {
  var q = queryize();
  q.insert(...args);
  return q;
};

queryize.replace = function (...args) {
  var q = queryize();
  q.replace(...args);
  return q;
};

queryize.delete = function (...args) {
  var q = queryize();
  q.deleteFrom(...args);
  return q;
};

queryize.deleteFrom = queryize.delete;

query.debug = function debug (enable) {
  this._attributes.debugEnabled = isDefined(enable) ? enable : true;

  return this;
};

query.insertBinding = function insertBinding (key, value) {
  if (typeof value === 'object') {
    // if we've got a date, convert it into a mysql ready datestamp
    if (value instanceof Date) {
      value = mysqlDate(value);
    } else {
      throw new TypeError('Received unparsable object as field value.');
    }
  }

  if (key.substr(0, 2) !== '{{') key = '{{' + key + '}}';

  this._attributes.dataBindings[key] = value;

  return this;
};

query.createBinding = function createBinding (value, modifier) {
  if (value === true) return 'TRUE';
  if (value === false) return 'FALSE';
  if (value === null) return 'NULL';

  var key = '{{' + _uniqueId('binding') + '}}';

  this.insertBinding(key, value);

  return modifier ? [ modifier, '(', key, ')' ].join('') : key;
};

query.select = function select (...args) {
  this._attributes.builder = 'select';
  if (arguments.length) {
    this.columns(args);
  }
  return this;
};

exports.delete = query.deleteFrom = function deleteFrom (tablename, alias) {
  this._attributes.builder = 'delete';

  if (isArray(tablename)) {
    if (alias) {
      this.from(tablename.shift(), alias);
      tablename.unshift(alias);
    }
    this.columns(tablename);
  } else if (tablename) {
    this.from(tablename, alias);
  }

  return this;
};

query.insert = function insert (...args) {
  this._attributes.builder = 'insert';
  this._attributes.insertMode = 'INSERT';
  if (arguments.length) {
    this.set(...args);
  }
  return this;
};

query.insertIgnore = function replace (...args) {
  this._attributes.builder = 'insert';
  this._attributes.insertMode = 'INSERT IGNORE';
  if (arguments.length) {
    this.set(...args);
  }
  return this;
};

query.replace = function replace (...args) {
  this._attributes.builder = 'insert';
  this._attributes.insertMode = 'REPLACE';
  if (arguments.length) {
    this.set(...args);
  }
  return this;
};

query.update = function update (tablename, alias) {
  this._attributes.builder = 'update';
  if (tablename) {
    this.table(tablename, alias);
  }
  return this;
};

query.table = exports.into = exports.from = function table (tablename, alias) {
  if (isQueryizeObject(tablename)) {
    if (isDefined(alias)) {
      tablename = tablename.clone().as(alias);
    }
    this._attributes.fromSubquery = this._mergeSubquery(tablename);
    return this;
  }

  this._attributes.tableName = tablename;
  if (isDefined(alias)) {
    this._attributes.alias = alias;
  }
  return this;
};

query.database = exports.intoDatabase = exports.fromDatabase = function database (dbname, tablename, alias) {
  this._attributes.database = dbname;
  if (tablename) {
    this._attributes.tableName = tablename;
  }
  if (alias) {
    this._attributes.alias = alias;
  }
  return this;
};

query.columns = function columns (...args) {
  var self = this;

  this._attributes.columns = null;

  flatten(args).forEach((column) => {
    self.addColumn(column);
  });

  return this;
};

query.addColumn = function addColumn (column, avoidDuplicates) {
  // if the current columns list is only a '*' wildcard, reset the array.
  // The expected use case in this scenario is that a new queryize object was made and they want to define columns individually.
  if (this._attributes.columns && this._attributes.columns.length === 1 && this._attributes.columns[0] === '*') {
    this._attributes.columns = null;
  }

  if (typeof column === 'number' || column instanceof Date) {
    avoidDuplicates = false;
    column = this.createBinding(column);
  } else if (isQueryizeObject(column)) {
    avoidDuplicates = false;
    if (column._attributes.columns.length > 1 || column._attributes.columns[0] === '*') {
      throw new Error('Column level subqueries can only return a single column.');
    }
    column = this._mergeSubquery(column);
  } else if (typeof column === 'object' && isDefined(column.data)) {
    avoidDuplicates = false;
    column = this.createBinding(column.data, column.modifier);
  }

  if (typeof column !== 'string') {
    throw new TypeError('Unknown column type: ' + JSON.stringify(column));
  }

  if (Array.isArray(this._attributes.columns)) {
    if (!avoidDuplicates || this._attributes.columns.indexOf(column) === -1) {
      this._attributes.columns.push(column);
    }
  } else {
    this._attributes.columns = [ column ];
  }
};

query.comparisonMethod = function comparisonMethod (condition) {
  if (typeof condition === 'boolean') {
    condition = condition ? 'and' : 'or';
  }

  switch (String(condition).trim()) {
  case 'and':
  case 'AND':
  case 'yes':
    this._attributes.whereBoolean = 'AND'; break;

  case 'or':
  case 'OR':
  case 'no':
    this._attributes.whereBoolean = 'OR'; break;
  // no default
  }

  return this;
};

query.where = function where (clause, value, operator, modifier) {
  if (!isDefined(clause)) {
    this._attributes.where = [];
    return this;
  }

  var self = this;

  if (isQueryizeObject(clause)) {
    clause = this._mergeCompoundWhere(clause);
  }

  // if a value is defined, then we're performing a field > value comparison
  // and must parse that first.
  if (value !== undefined && (typeof clause === 'string' || isArray(clause))) {
    clause = this._processWhereCondition(clause, value, operator, modifier);

  // if there was no value, check to see if we got an object based where definition
  } else if (typeof clause === 'object' && !isArray(clause)) {
    modifier = operator;
    operator = value;
    clause = this._processWhereObject(clause, operator, modifier);
  }

  // if we've got an array at this point, then we should parse it as if it were
  // a collection of possible conditions in an OR
  if (isArray(clause)) {
    clause = flatten(clause).map((c) => {
      switch (typeof c) {
      case 'string': return c;
      case 'object': return self._processWhereObject(c, operator, modifier);
      default:
        throw new TypeError('Where clause could not be processed. Found ' + (typeof c) + ' instead.');
      }
    });

    var l = clause.length;
    var subBoolean = ' OR ';
    if (l === 1) {
      clause = clause[0];
    } else if (l > 1) {
      // if the first value in the array is "AND", reverse our typical boolean.
      if (clause[0] === 'AND') {
        subBoolean = ' AND ';
        clause.shift();
        l--;
      }
      if (l === 1) {
        clause = clause[0];
      } else {
        clause = '(' + clause.join(subBoolean) + ')';
      }
    } else {
      clause = null;
    }
  }

  // by now the clause should be a string. if it isn't, then someone gave us an unusable clause
  if (typeof clause === 'string') {
    this._attributes.where.push(clause);
  } else {
    throw new TypeError('Where clause could not be processed. Found ' + (typeof clause) + ' instead.');
  }

  return this;
};

query.whereBetween = function whereBetween (field, from, to, modifier) {
  this.where([ field, 'BETWEEN', this.createBinding(from, modifier), 'AND', this.createBinding(to, modifier) ].join(' '));

  return this;
};

query.whereLike = function whereLike (field, value, modifier) {
  if (typeof field === 'object') {
    this.where(field, 'LIKE', modifier);
  } else {
    this.where(field, value, 'LIKE', modifier);
  }
  return this;
};

query.whereNot = function whereNot (field, value, modifier) {
  if (typeof field === 'object') {
    this.where(field, '!=', modifier);
  } else {
    this.where(field, value, '!=', modifier);
  }
  return this;
};

query.whereNotLike = function whereNotLike (field, value, modifier) {
  if (typeof field === 'object') {
    this.where(field, 'NOT LIKE', modifier);
  } else {
    this.where(field, value, 'NOT LIKE', modifier);
  }
  return this;
};

query.whereInRange = function whereInRange (field, from, to, modifier) {
  if (isDefined(from) && isDefined(to)) {
    this.whereBetween(field, from, to, modifier);
  } else if (isDefined(from)) {
    this.where(field, from, '>=', modifier);
  } else if (isDefined(to)) {
    this.where(field, to, '<=', modifier);
  }
  return this;
};

query.orderBy = function orderBy (...args) {
  this._attributes.orderBy = flatten(args);

  return this;
};

query.groupBy = function groupBy (...args) {
  this._attributes.groupBy = flatten(args);

  return this;
};

query.distinct = function distinct (enable) {
  this._attributes.distinct = isDefined(enable) ? enable : true;
  return this;
};

query.limit = function limit (max, offset) {
  if (!isDefined(max)) max = 0;
  if (!isDefined(offset)) offset = 0;

  if (max) {
    if (offset) {
      this._attributes.limit = 'LIMIT ' + Number(offset) + ', ' + Number(max);
    } else {
      this._attributes.limit = 'LIMIT ' + Number(max);
    }
  } else {
    this._attributes.limit = false;
  }

  return this;
};

query.set = function set (clause, value, modifier) {
  var self = this;

  if (!isDefined(clause)) throw new Error('You must define a field to set.');

  if (typeof clause === 'object') {
    Object.keys(clause).forEach((field) => {
      self.set(field, clause[field], value);
    });
    return this;
  }

  // if we received a value, create a set clause
  if (typeof value === 'undefined') {
    this._attributes.set.push(clause);
  } else {
    var column = clause;
    if (value && typeof value === 'object' && typeof value.raw === 'string') {
      clause = clause + ' = ' + value.raw;
    } else {
      if (!isValidPrimative(value)) {
        throw new TypeError('Unknown data type in set clause');
      }

      clause = clause + ' = ' + this.createBinding(value, modifier);
    }

    // if we've previously created a clause for this column, overwrite it.
    var key = this._attributes.setKeys[column];
    if (isDefined(key)) {
      this._attributes.set[key] = clause;
    } else {
      this._attributes.setKeys[column] = this._attributes.set.length;
      this._attributes.set.push(clause);
    }
  }

  return this;
};

query.addRow = function addRow (data) {
  var row, columns;
  var self = this;

  // make sure the rows property exists
  if (!this._attributes.rows) {
    this._attributes.rows = [];
  }

  if (Array.isArray(data)) {
    columns = this._attributes.columns || [];

    // if the current columns list is only a '*' wildcard, then the developer has not defined any columns yet and we can't take array data.
    if (!this._attributes.columns || this._attributes.columns.length === 1 && this._attributes.columns[0] === '*') {
      throw new Error('You must define the insert columns first in order to pass rows as array.');
    }

    if (columns.length !== data.length) {
      throw new Error('Row does not contain the same number of entries (' + data.length + ') as the number of defined columns (' + columns.length + ').');
    }

    row = {};
    columns.forEach((column, i) => {
      row[column] = data[i];
    });

    this._attributes.rows.push(row);
  } else if (typeof data === 'object') {
    columns = Object.keys(data);

    columns.forEach((column) => {
      self.addColumn(column, true);
    });

    this._attributes.rows.push(data);
  } else {
    throw new TypeError('Row is not of the expected data type.');
  }

  return this;
};

query.join = function join (clause, options) {
  if (!isDefined(clause)) throw new Error('You must define a table to join against.');

  if (isQueryizeObject(clause)) {
    if (typeof options !== 'object') throw new Error('You must define join options when joining against a queryize subquery.');

    options = Object.create(options);
    options.table = clause;
    clause = options;
  } else if (typeof clause === 'object') {
    if (isArray(clause)) throw new TypeError('Join clauses can only be strings or object definitions');
    if (!clause.table) throw new Error('You must define a table to join against');
  } else if (typeof options === 'object') {
    options = Object.create(options);
    options.table = clause;
    clause = options;
  } else if (typeof clause === 'string' && clause.search(joinTest) < 0) {
    clause = 'JOIN ' + clause;
  }

  if (typeof clause === 'object') {
    var stack = [];

    if (clause.type) stack.push(clause.type);
    stack.push('JOIN');
    if (isQueryizeObject(clause.table)) {
      if (clause.alias) {
        clause.table = clause.table.clone().as(clause.alias);
      }
      stack.push(this._mergeSubquery(clause.table));
    } else if (typeof clause.table === 'string') {
      stack.push(clause.table);
      if (clause.alias) stack.push(clause.alias);
    } else {
      throw new TypeError('The join table name is not a string.');
    }

    if (clause.using) {
      stack.push('USING (' + (isArray(clause.using) ? clause.using.join(', ') : clause.using) + ')');
    } else if (clause.on) {
      stack.push('ON (' + this._processJoinOns(clause.on, clause.onBoolean || 'AND') + ')');
    }

    clause = stack.join(' ');
  }

  this._attributes.joins.push(clause);

  return this;
};

query.innerJoin = _makeJoiner('INNER');

query.leftJoin = _makeJoiner('LEFT');

query.rightJoin = _makeJoiner('RIGHT');

query.as = function asNamed (name) {
  this._attributes.asName = name;
  return this;
};

query.disableBoundParameters = function disableBoundParameters (bool) {
  this._attributes.useBoundParameters = isDefined(bool) ? !bool : false;
  return this;
};

query.useBoundParameters = function (bool) {
  this.disableBoundParameters(isDefined(bool) ? !bool : true);
  return this;
};

query.compile = function compile (useBoundParameters) {
  if (!this._attributes.builder || !builders[this._attributes.builder]) throw new Error('Query operation undefined, must identify if performing a select/update/insert/delete query.');
  if (!this._attributes.tableName && !this._attributes.fromSubquery) throw new Error('No table name has been defined');

  if (this._attributes.builder === 'insert' && this._attributes.rows) {
    this._attributes.builder = 'insertMultiple';
  }

  if (typeof useBoundParameters === 'undefined') useBoundParameters = this._attributes.useBoundParameters;

  var q = builders[this._attributes.builder].call(this);

  if (typeof q === 'string') {
    return this._convertNamedParameters(q, useBoundParameters);
  }
  if (typeof q !== 'object' || !q.query) throw new Error('INTERNAL ERROR: Query builder returned unrecognized output.');
  return q;

};

query.eval = async function evaluate (...args) {
  const { query: q, data } = this.compile();
  if (this._attributes.debugEnabled) console.log({ query: q, data }); // eslint-disable-line no-console

  if (typeof this._evalFunction !== 'function') return [ q, data ];
  return await this._evalFunction(q, data, ...args);
};

query.then = function then (...args) {
  const p = this.eval();
  if (args.length) return p.then(...args);
  return p;
};

query.clone = function clone () {
  return this._constructor(this);
};

query.toString = function toString () {
  return this.compile(false).query;
};