var safeRequire = require('../utils').safeRequire;
/**
 * Module dependencies
 */
var pg = safeRequire('pg');1
var BaseSQL = require('../sql');1
var util = require('util');1
exports.initialize = function initializeSchema(schema, callback) {
    if (!pg) return;1
    var Client = pg.Client;1
    var s = schema.settings;1
    schema.client = new Client(s.url ? s.url : {
        host: s.host || 'localhost',
        port: s.port || 5432,
        user: s.username,
        password: s.password,
        database: s.database,
        debug: s.debug
    });1
    schema.adapter = new PG(schema.client);1
    schema.adapter.connect(callback);1
};1
function PG(client) {
    this._models = {};1
    this.client = client;1
}
require('util').inherits(PG, BaseSQL);1
PG.prototype.connect = function (callback) {
    this.client.connect(function (err) {
        if (!err){
            callback();1
        }else{
            console.error(err);
            throw err;
        }
    });1
};1
PG.prototype.query = function (sql, callback) {
    var time = Date.now();8
    var log = this.log;8
    this.client.query(sql, function (err, data) {
        if (log) log(sql, time);8
        callback(err, data ? data.rows : null);8
    });8
};1
/**
 * Must invoke callback(err, id)
 */
PG.prototype.create = function (model, data, callback) {
    var fields = this.toFields(model, data, true);4
    var sql = 'INSERT INTO ' + this.tableEscaped(model) + '';4
    if (fields) {
        sql += ' ' + fields;4
    } else {
        sql += ' VALUES ()';
    }
    sql += ' RETURNING id';4
    this.query(sql, function (err, info) {
        if (err) return callback(err);4
        callback(err, info && info[0] && info[0].id);4
    });4
};1
PG.prototype.updateOrCreate = function (model, data, callback) {
    var pg = this;
    var fieldsNames = [];
    var fieldValues = [];
    var combined = [];
    var props = this._models[model].properties;
    Object.keys(data).forEach(function (key) {
        if (props[key] || key === 'id') {
            var k = '"' + key + '"';
            var v;
            if (key !== 'id') {
                v = pg.toDatabase(props[key], data[key]);
            } else {
                v = data[key];
            }
            fieldsNames.push(k);
            fieldValues.push(v);
            if (key !== 'id') combined.push(k + ' = ' + v);
        }
    });
    var sql = 'UPDATE ' + this.tableEscaped(model);
    sql += ' SET ' + combined + ' WHERE id = ' + data.id + ';';
    sql += ' INSERT INTO ' + this.tableEscaped(model);
    sql += ' (' + fieldsNames.join(', ') + ')';
    sql += ' SELECT ' + fieldValues.join(', ')
    sql += ' WHERE NOT EXISTS (SELECT 1 FROM ' + this.tableEscaped(model);
    sql += ' WHERE id = ' + data.id + ') RETURNING id';
    this.query(sql, function (err, info) {
        if (!err && info && info[0] && info[0].id) {
            data.id = info[0].id;
        }
        callback(err, data);
    });
};1
PG.prototype.toFields = function (model, data, forCreate) {
    var fields = [];4
    var props = this._models[model].properties;4
    
    if(forCreate){
      var columns = [];4
      Object.keys(data).forEach(function (key) {
          if (props[key]) {
              columns.push('"' + key + '"');8
              fields.push(this.toDatabase(props[key], data[key]));8
          }
      }.bind(this));4
      return '(' + columns.join(',') + ') VALUES ('+fields.join(',')+')';4
    }else{
      Object.keys(data).forEach(function (key) {
          if (props[key]) {
              fields.push('"' + key + '" = ' + this.toDatabase(props[key], data[key]));
          }
      }.bind(this));
      return fields.join(',');
    }
};1
function dateToPostgres(val) {
    return [
        val.getUTCFullYear(),
        fz(val.getUTCMonth() + 1),
        fz(val.getUTCDate())
    ].join('-') + ' ' + [
        fz(val.getUTCHours()),
        fz(val.getUTCMinutes()),
        fz(val.getUTCSeconds())
    ].join(':');
    function fz(v) {
        return v < 10 ? '0' + v : v;
    }
}
PG.prototype.toDatabase = function (prop, val) {
    if (val === null) {
		// Postgres complains with NULLs in not null columns
		// If we have an autoincrement value, return DEFAULT instead
        if( prop.autoIncrement ) {
            return 'DEFAULT';
        }
        else {
            return 'NULL';
	    }
    }
    if (val.constructor.name === 'Object') {
        var operator = Object.keys(val)[0]
        val = val[operator];
        if (operator === 'between') {
            return this.toDatabase(prop, val[0]) + ' AND ' + this.toDatabase(prop, val[1]);
        }
    }
    if (prop.type.name === 'Number') return val;4
    if (prop.type.name === 'Date') {
        if (!val) {
            if( prop.autoIncrement ) {
                return 'DEFAULT';
            }
            else {
                return 'NULL';
            }
        }
        if (!val.toUTCString) {
            val = new Date(val);
        }
        return escape(dateToPostgres(val));
    }
    return escape(val.toString());4
};1
PG.prototype.fromDatabase = function (model, data) {
    if (!data) return null;
    var props = this._models[model].properties;
    Object.keys(data).forEach(function (key) {
        var val = data[key];
        data[key] = val;
    });
    return data;
};1
PG.prototype.escapeName = function (name) {
    return '"' + name.replace(/\./g, '"."') + '"';6
};1
PG.prototype.all = function all(model, filter, callback) {
    this.query('SELECT * FROM ' + this.tableEscaped(model) + ' ' + this.toFilter(model, filter), function (err, data) {
        if (err) {
            return callback(err, []);
        }
        callback(err, data);
    }.bind(this));
};1
PG.prototype.toFilter = function (model, filter) {
    if (filter && typeof filter.where === 'function') {
      return filter();
    }
    if (!filter) return '';
    var props = this._models[model].properties;
    var out = '';
    if (filter.where) {
        var fields = [];
        var conds = filter.where;
        Object.keys(conds).forEach(function (key) {
            if (filter.where[key] && filter.where[key].constructor.name === 'RegExp') {
                return;
            }
            if (props[key]) {
                var filterValue = this.toDatabase(props[key], filter.where[key]);
                if (filterValue === 'NULL') {
                    fields.push('"' + key + '" IS ' + filterValue);
                } else if (conds[key].constructor.name === 'Object') {
                    var condType = Object.keys(conds[key])[0];
                    var sqlCond = key;
                    switch (condType) {
                        case 'gt':
                        sqlCond += ' > ';
                        break;
                        case 'gte':
                        sqlCond += ' >= ';
                        break;
                        case 'lt':
                        sqlCond += ' < ';
                        break;
                        case 'lte':
                        sqlCond += ' <= ';
                        break;
                        case 'between':
                        sqlCond += ' BETWEEN ';
                        break;
                    }
                    sqlCond += filterValue;
                    fields.push(sqlCond);
                } else {
                    fields.push('"' + key + '" = ' + filterValue);
                }
            }
        }.bind(this));
        if (fields.length) {
            out += ' WHERE ' + fields.join(' AND ');
        }
    }
    if (filter.order) {
        out += ' ORDER BY ' + filter.order;
    }
    if (filter.limit) {
        out += ' LIMIT ' + filter.limit + ' ' + (filter.offset || '');
    }
    return out;
};1
function getTableStatus(model, cb){
    function decoratedCallback(err, data){
        data.forEach(function(field){
            field.Type = mapPostgresDatatypes(field.Type);
        });
        cb(err, data);
    };
    this.query('SELECT column_name as "Field", udt_name as "Type", is_nullable as "Null", column_default as "Default" FROM information_schema.COLUMNS WHERE table_name = \'' + this.table(model) + '\'', decoratedCallback);
};1
PG.prototype.autoupdate = function (cb) {
    var self = this;
    var wait = 0;
    Object.keys(this._models).forEach(function (model) {
        wait += 1;
        var fields;
        getTableStatus.call(self, model, function(err, fields){
            if(err) console.log(err);
            self.alterTable(model, fields, done);
        });
    });
    function done(err) {
        if (err) {
            console.log(err);
        }
        if (--wait === 0 && cb) {
            cb();
        }
    };
};1
PG.prototype.isActual = function(cb) {
    var self = this;
    var wait = 0;
    changes = [];
    Object.keys(this._models).forEach(function (model) {
        wait += 1;
        getTableStatus.call(self, model, function(err, fields){
            changes = changes.concat(getPendingChanges.call(self, model, fields));
            done(err, changes);
        });
    });
    function done(err, fields) {
        if (err) {
            console.log(err);
        }
        if (--wait === 0 && cb) {
            var actual = (changes.length === 0);
            cb(null, actual);
        }
    };
};1
PG.prototype.alterTable = function (model, actualFields, done) {
  var self = this;
  var pendingChanges = getPendingChanges.call(self, model, actualFields);
  applySqlChanges.call(self, model, pendingChanges, done);
};1
function getPendingChanges(model, actualFields){
    var sql = [];
    var self = this;
    sql = sql.concat(getColumnsToAdd.call(self, model, actualFields));
    sql = sql.concat(getPropertiesToModify.call(self, model, actualFields));
    sql = sql.concat(getColumnsToDrop.call(self, model, actualFields));
    return sql;
};1
function getColumnsToAdd(model, actualFields){
    var self = this;
    var m = self._models[model];
    var propNames = Object.keys(m.properties);
    var sql = [];
    propNames.forEach(function (propName) {
        var found = searchForPropertyInActual.call(self, propName, actualFields);
        if(!found && propertyHasNotBeenDeleted.call(self, model, propName)){
            sql.push(addPropertyToActual.call(self, model, propName));
        }
    });
    return sql;
};1
function addPropertyToActual(model, propName){
    var self = this;
    var p = self._models[model].properties[propName];
    sqlCommand = 'ADD COLUMN "' + propName + '" ' + datatype(p) + " " + (propertyCanBeNull.call(self, model, propName) ? "" : " NOT NULL");
    return sqlCommand;
};1
function searchForPropertyInActual(propName, actualFields){
    var found = false;
    actualFields.forEach(function (f) {
        if (f.Field === propName) {
            found = f;
            return;
        }
    });
    return found;
};1
function getPropertiesToModify(model, actualFields){
    var self = this;
    var sql = [];
    var m = self._models[model];
    var propNames = Object.keys(m.properties);
    var found;
    propNames.forEach(function (propName) {
        found = searchForPropertyInActual.call(self, propName, actualFields);
        if(found && propertyHasNotBeenDeleted.call(self, model, propName)){
            if (datatypeChanged(propName, found)) {
                sql.push(modifyDatatypeInActual.call(self, model, propName));
            } 
            if (nullabilityChanged(propName, found)){
                sql.push(modifyNullabilityInActual.call(self, model, propName));
            }
        }
    });
    return sql;
    function datatypeChanged(propName, oldSettings){
        var newSettings = m.properties[propName];
        if(!newSettings) return false;
        return oldSettings.Type.toLowerCase() !== datatype(newSettings);
    };
    function nullabilityChanged(propName, oldSettings){
        var newSettings = m.properties[propName];
        if(!newSettings) return false;
        var changed = false;
        if (oldSettings.Null === 'YES' && (newSettings.allowNull === false || newSettings.null === false)) changed = true;
        if (oldSettings.Null === 'NO' && !(newSettings.allowNull === false || newSettings.null === false)) changed = true;
        return changed;
    };
};1
function modifyDatatypeInActual(model, propName) {
    var self = this;
    var sqlCommand = 'ALTER COLUMN "' + propName + '"  TYPE ' + datatype(self._models[model].properties[propName]);
    return sqlCommand;
};1
function modifyNullabilityInActual(model, propName) {
    var self = this;
    var sqlCommand = 'ALTER COLUMN "' + propName + '" ';
    if(propertyCanBeNull.call(self, model, propName)){
      sqlCommand = sqlCommand + "DROP ";
    } else {
      sqlCommand = sqlCommand + "SET ";
    }
    sqlCommand = sqlCommand + "NOT NULL";
    return sqlCommand;
};1
function getColumnsToDrop(model, actualFields){
    var self = this;
    var sql = [];
    actualFields.forEach(function (actualField) {
        if (actualField.Field === 'id') return;
        if (actualFieldNotPresentInModel(actualField, model)) {
            sql.push('DROP COLUMN "' + actualField.Field + '"');
        }
    });
    return sql;
    function actualFieldNotPresentInModel(actualField, model){
        return !(self._models[model].properties[actualField.Field]);
    };
};1
function applySqlChanges(model, pendingChanges, done){
    var self = this;
    if (pendingChanges.length) {
       var thisQuery = 'ALTER TABLE ' + self.tableEscaped(model);
       var ranOnce = false;
       pendingChanges.forEach(function(change){
         if(ranOnce) thisQuery = thisQuery + ',';
         thisQuery = thisQuery + ' ' + change;
         ranOnce = true;
       });
       thisQuery = thisQuery + ';';
       self.query(thisQuery, callback);
    }
    function callback(err, data){
      if(err) console.log(err);
    }
    done();
};1
PG.prototype.propertiesSQL = function (model) {
    var self = this;1
    var sql = ['"id" SERIAL PRIMARY KEY'];1
    Object.keys(this._models[model].properties).forEach(function (prop) {
        sql.push('"' + prop + '" ' + self.propertySettingsSQL(model, prop));2
    });1
    return sql.join(',\n  ');1
};1
PG.prototype.propertySettingsSQL = function (model, propName) {
    var self = this;2
    var p = self._models[model].properties[propName];2
    var result = datatype(p) + ' '; 
    if(!propertyCanBeNull.call(self, model, propName)) result = result + 'NOT NULL ';2
    return result;2
};1
function propertyCanBeNull(model, propName){
    var p = this._models[model].properties[propName];2
    return !(p.allowNull === false || p['null'] === false);2
};1
function escape(val) {
  if (val === undefined || val === null) {
    return 'NULL';
  }
  switch (typeof val) {
    case 'boolean': return (val) ? 'true' : 'false';
    case 'number': return val+'';
  }
  if (typeof val === 'object') {
    val = (typeof val.toISOString === 'function')
      ? val.toISOString()
      : val.toString();
  }
  val = val.replace(/[\0\n\r\b\t\\\'\"\x1a]/g, function(s) {
    switch(s) {
      case "\0": return "\\0";
      case "\n": return "\\n";
      case "\r": return "\\r";
      case "\b": return "\\b";
      case "\t": return "\\t";
      case "\x1a": return "\\Z";
      default: return "\\"+s;
    }
  });4
  return "'"+val+"'";4
};1
function datatype(p) {
    switch (p.type.name) {
        case 'String':
        return 'varchar';1
        case 'Text':
        return 'text';
        case 'Number':
        return 'integer';1
        case 'Date':
        return 'timestamp';
        case 'Boolean':
        return 'boolean';
        default:
        console.log("Warning: postgres adapter does not explicitly handle type '" + p.type.name +"'");
        return p.type.toLowerCase();
        //TODO a default case might not be the safest thing here... postgres has a fair number of extra types though
    }
};1
function mapPostgresDatatypes(typeName) {
    //TODO there are a lot of synonymous type names that should go here-- this is just what i've run into so far
    switch (typeName){
        case 'int4':
          return 'integer';
        default:
          return typeName;
    }
};1
function propertyHasNotBeenDeleted(model, propName){
    return !!this._models[model].properties[propName];
};1

module.exports = BaseSQL;
/**
 * Base SQL class
 */
function BaseSQL() {
}
BaseSQL.prototype.query = function () {
    throw new Error('query method should be declared in adapter');
};1
BaseSQL.prototype.command = function (sql, callback) {
    return this.query(sql, callback);2
};1
BaseSQL.prototype.queryOne = function (sql, callback) {
    return this.query(sql, function (err, data) {
        if (err) return callback(err);
        callback(err, data[0]);
    });
};1
BaseSQL.prototype.table = function (model) {
    return this._models[model].model.schema.tableName(model);6
};1
BaseSQL.prototype.escapeName = function (name) {
    throw new Error('escapeName method should be declared in adapter');
};1
BaseSQL.prototype.tableEscaped = function (model) {
    return this.escapeName(this.table(model));6
};1
BaseSQL.prototype.define = function (descr) {
    if (!descr.settings) descr.settings = {};1
    this._models[descr.model.modelName] = descr;1
};1
BaseSQL.prototype.defineProperty = function (model, prop, params) {
    this._models[model].properties[prop] = params;
};1
BaseSQL.prototype.save = function (model, data, callback) {
    var sql = 'UPDATE ' + this.tableEscaped(model) + ' SET ' + this.toFields(model, data) + ' WHERE ' + this.escapeName('id') + ' = ' + data.id;
    this.query(sql, function (err) {
        callback(err);
    });
};1
BaseSQL.prototype.exists = function (model, id, callback) {
    var sql = 'SELECT 1 FROM ' +
        this.tableEscaped(model) + ' WHERE ' + this.escapeName('id') + ' = ' + id + ' LIMIT 1';
    this.query(sql, function (err, data) {
        if (err) return callback(err);
        callback(null, data.length === 1);
    });
};1
BaseSQL.prototype.find = function find(model, id, callback) {
    var sql = 'SELECT * FROM ' +
        this.tableEscaped(model) + ' WHERE ' + this.escapeName('id') + ' = ' + id + ' LIMIT 1';
    this.query(sql, function (err, data) {
        if (data && data.length === 1) {
            data[0].id = id;
        } else {
            data = [null];
        }
        callback(err, this.fromDatabase(model, data[0]));
    }.bind(this));
};1
BaseSQL.prototype.destroy = function destroy(model, id, callback) {
    var sql = 'DELETE FROM ' +
        this.tableEscaped(model) + ' WHERE ' + this.escapeName('id') + ' = ' + id;
    this.command(sql, function (err) {
        callback(err);
    });
};1
BaseSQL.prototype.destroyAll = function destroyAll(model, callback) {
    this.command('DELETE FROM ' + this.tableEscaped(model), function (err) {
        if (err) {
            return callback(err, []);
        }
        callback(err);
    }.bind(this));
};1
BaseSQL.prototype.count = function count(model, callback, where) {
    var self = this;
    var props = this._models[model].properties;
    this.queryOne('SELECT count(*) as cnt FROM ' +
        this.tableEscaped(model) + ' ' + buildWhere(where), function (err, res) {
        if (err) return callback(err);
        callback(err, res && res.cnt);
    });
    function buildWhere(conds) {
        var cs = [];
        Object.keys(conds || {}).forEach(function (key) {
            var keyEscaped = self.escapeName(key);
            if (conds[key] === null) {
                cs.push(keyEscaped + ' IS NULL');
            } else {
                cs.push(keyEscaped + ' = ' + self.toDatabase(props[key], conds[key]));
            }
        });
        return cs.length ? ' WHERE ' + cs.join(' AND ') : '';
    }
};1
BaseSQL.prototype.updateAttributes = function updateAttrs(model, id, data, cb) {
    data.id = id;
    this.save(model, data, cb);
};1
BaseSQL.prototype.disconnect = function disconnect() {
    this.client.end();1
};1
BaseSQL.prototype.automigrate = function (cb) {
    var self = this;1
    var wait = 0;1
    Object.keys(this._models).forEach(function (model) {
        wait += 1;1
        self.dropTable(model, function () {
            // console.log('drop', model);
            self.createTable(model, function (err) {
                // console.log('create', model);
                if (err) console.log(err);1
                done();1
            });1
        });1
    });1
    if (wait === 0) cb();1
    function done() {
        if (--wait === 0 && cb) {
            cb();1
        }
    }
};1
BaseSQL.prototype.dropTable = function (model, cb) {
    this.command('DROP TABLE IF EXISTS ' + this.tableEscaped(model), cb);1
};1
BaseSQL.prototype.createTable = function (model, cb) {
    this.command('CREATE TABLE ' + this.tableEscaped(model) +
        ' (\n  ' + this.propertiesSQL(model) + '\n)', cb);1
};1

exports.safeRequire = safeRequire;
function safeRequire(module) {
    try {
        return require(module);1
    } catch(e) {
        console.log('Run "npm install ' + module + '" command to use jugglingdb using this database engine');
        process.exit(1);
    }
}