(function (exports, J, store) {

NDDB.compatibility = J.compatibility();
  

exports.NDDB = NDDB;

NDDB.log = console.log;

NDDB.decycle = function(e) {
  if (JSON && JSON.decycle && 'function' === typeof JSON.decycle) {
    e = JSON.decycle(e);
  }
  return e;
};

NDDB.retrocycle = function(e) {
  if (JSON && JSON.retrocycle && 'function' === typeof JSON.retrocycle) {
    e = JSON.retrocycle(e);
  }
  return e;
};

function NDDB (options, db) {                
    options = options || {};
    
    if (!J) throw new Error('JSUS not found.');
    

    this.db = [];
    

    this.tags = {};
    

    this.hooks = {
    insert: [],
      remove: [],
      update: []
    };
    

    this.nddb_pointer = 0; 
    

    if (NDDB.compatibility.getter) {
      this.__defineGetter__('length', function() { return this.db.length; });
    }
  else {
      this.length = null;
    }
   

    this.query = new QueryBuilder();
    

    this.__C = {};
    

    this.__H = {};
    

    this.__I = {};
    

    this.__V = {};
    

    this.__update = {};
    

    this.__update.pointer   = false;
    

    this.__update.indexes   = false;
    

    this.__update.sort    = false;
    
    this.init(options);
    this.importDB(db);   
};

NDDB.prototype.init = function(options) {
  options = options || {};
  
  this.__options = options;
  
  if (options.log) {
    NDDB.log = options.log;
  }
    
  if (options.C) {
    this.__C = options.C;
  }
  
  if (options.H) {
    this.__H = options.H;
  }
  
  if (options.I) {
    this.__I = options.I;
  }
  
  if (options.V) {
    this.__V = options.V;
  }
  
  if (options.tags) {
    this.tags = options.tags;
  }
    
    if (options.nddb_pointer > 0) {
      this.nddb_pointer = options.nddb_pointer;
  }
    
    if (options.hooks) {
      this.hooks = options.hooks;
    }
    
    if (options.update) {
        if ('undefined' !== typeof options.update.pointer) {
          this.__update.pointer = options.update.pointer;
        }
           
        if ('undefined' !== typeof options.update.indexes) {
          this.__update.indexes = options.update.indexes;
        }
                                        
        if ('undefined' !== typeof options.update.sort) {
          this.__update.sort = options.update.sort;
        }
    }
    
    if ('object' === typeof options.operators) {
      for (var op in options.operators) {
        this.query.registerOperator(op, options.operators[op]);
      }
    }
};

NDDB.prototype.globalCompare = function(o1, o2) {
    if ('undefined' === typeof o1 && 'undefined' === typeof o2) return 0;
    if ('undefined' === typeof o2) return -1;  
    if ('undefined' === typeof o1) return 1;
    return -1;
};

NDDB.prototype._autoUpdate = function (options) {
  var update = options ? J.merge(this.__update, options) : this.__update;
  
    if (update.pointer) {
        this.nddb_pointer = this.db.length-1;
    }
    if (update.sort) {
        this.sort();
    }
    
    if (update.indexes) {
        this.rebuildIndexes();
    }
};


function nddb_insert(o, update) {
  if (o === null) return;
  var type = typeof(o);
  if (type === 'undefined') return;
  if (type === 'string') return;
  if (type === 'number') return;
  this.db.push(o);
  if (update) {
    this._indexIt(o, (this.db.length-1));
    this._hashIt(o);
    this._viewIt(o);
  }
    this.emit('insert', o);
}

NDDB.prototype.importDB = function (db) {
    if (!db) return;
    for (var i = 0; i < db.length; i++) {
        nddb_insert.call(this, db[i], this.__update.indexes);
    }
    this._autoUpdate({indexes: false});
};
    

NDDB.prototype.insert = function (o) {
  nddb_insert.call(this, o, this.__update.indexes);
    this._autoUpdate({indexes: false});
};

NDDB.prototype.breed = function (db) {
    db = db || this.db;

    return new this.constructor(this.cloneSettings(), db);
};
    

NDDB.prototype.cloneSettings = function () {
    var options = this.__options || {};
    
    options.H =     this.__H;
    options.I =     this.__I;
    options.C =     this.__C;
    options.V =     this.__V;
    options.tags =    this.tags;
    options.update =  this.__update;
    options.hooks =   this.hooks;
    
    return J.clone(options);
};    

NDDB.prototype.toString = function () {
    var out = '';
    for (var i=0; i< this.db.length; i++) {
        out += this.db[i] + "\n";
    }    
    return out;
};    
    

NDDB.prototype.stringify = function (compressed) {
  if (!this.length) return '[]';
  compressed = ('undefined' === typeof compressed) ? true : compressed;
  
  var spaces = compressed ? 0 : 4;
  
    var out = '[';
    this.each(function(e) {

      e = NDDB.decycle(e);
      out += J.stringify(e) + ', ';
    });
    out = out.replace(/, $/,']');

    return out;
};    

NDDB.prototype.comparator = function (d, comparator) {
    if (!d || !comparator) {
        NDDB.log('Cannot set empty property or empty comparator', 'ERR');
        return false;
    }
    this.__C[d] = comparator;
    return true;
};

NDDB.prototype.c = NDDB.prototype.comparator;

NDDB.prototype.getComparator = function (d) {
    if ('undefined' !== typeof this.__C[d]) {
      return this.__C[d]; 
    }
    
    return function (o1, o2) {

        if ('undefined' === typeof o1 && 'undefined' === typeof o2) return 0;
        if ('undefined' === typeof o1) return 1;
        if ('undefined' === typeof o2) return -1;        
        var v1 = J.getNestedValue(d,o1);
        var v2 = J.getNestedValue(d,o2);

        if ('undefined' === typeof v1 && 'undefined' === typeof v2) return 0;
        if ('undefined' === typeof v1) return 1;
        if ('undefined' === typeof v2) return -1;
        if (v1 > v2) return 1;
        if (v2 > v1) return -1;
        return 0;
    };    
};

NDDB.prototype.isReservedWord = function (key) {
  return (this[key]) ? true : false; 
};

NDDB.prototype._isValidIndex = function (idx) {
  if ('undefined' === typeof idx) {
    NDDB.log('A valid index name must be provided', 'ERR');
    return false;
  }
  if (this.isReservedWord(idx)) {
    var str = 'A reserved word have been selected as an index. ';
    str += 'Please select another one: ' + idx;
    NDDB.log(str, 'ERR');
    return false;
  }
  return true;
};

NDDB.prototype.index = function (idx, func) {
  if (!func || !this._isValidIndex(idx)) return false;
  this.__I[idx] = func, this[idx] = new NDDBIndex(idx, this);
  return true;
};

NDDB.prototype.i = NDDB.prototype.index;

NDDB.prototype.view = function (idx, func) {
  if (!func || !this._isValidIndex(idx)) return false;
  this.__V[idx] = func, this[idx] = new this.constructor();
  return true;
};

NDDB.prototype.hash = function (idx, func) {
  if (!func || !this._isValidIndex(idx)) return false;
  this.__H[idx] = func, this[idx] = {};
  return true;
};

NDDB.prototype.h = NDDB.prototype.hash; 

NDDB.prototype.resetIndexes = function(options) {
  var reset = options || J.merge({
    h: true,
    v: true,
    i: true
  }, options);
  var key;
  if (reset.h) {
    for (key in this.__H) {
      if (this.__H.hasOwnProperty(key)) {
        this[key] = {};
      }
    }
  }
  if (reset.v) {
    for (key in this.__V) {
      if (this.__V.hasOwnProperty(key)) {
        this[key] = new this.constructor();
      }
    }
  }
  if (reset.v) {
    for (key in this.__I) {
      if (this.__I.hasOwnProperty(key)) {
        this[key] = new NDDBIndex(key, this);
      }
    }
  }

};

NDDB.prototype.rebuildIndexes = function() {
  var h = !(J.isEmpty(this.__H)),
    i = !(J.isEmpty(this.__I)),
    v = !(J.isEmpty(this.__V));
  
  var cb, idx;
  if (!h && !i && !v) return;
  

  this.resetIndexes({h: h, v: v, i: i});
  
  if (h && !i && !v) {
    cb = this._hashIt;
  }
  else if (!h && i && !v) {
    cb = this._indexIt;
  }
  else if (!h && !i && v) {
    cb = this._viewIt;
  }
  else if (h && i && !v) {
    cb = function(o, idx) {
      this._hashIt(o);
      this._indexIt(o, idx);
    };
  }
  else if (!h && i && v) {
    cb = function(o, idx) {
      this._indexIt(o, idx);
      this._viewIt(o);
    };
  }
  else if (h && !i && v) {
    cb = function(o, idx) {
      this._hashIt(o);
      this._viewIt(o);
    };
  }
  else {
    cb = function(o, idx) {
      this._indexIt(o, idx);
      this._hashIt(o);
      this._viewIt(o);
    };
  }
  
  for (idx = 0 ; idx < this.db.length ; idx++) {

    cb.call(this, this.db[idx], idx);
  }
};

NDDB.prototype._indexIt = function(o, dbidx) {
    if (!o || J.isEmpty(this.__I)) return;
  var func, id, index;
  
  for (var key in this.__I) {
    if (this.__I.hasOwnProperty(key)) {
      func = this.__I[key];           
      index = func(o);

      if ('undefined' === typeof index) continue;
      
      if (!this[key]) this[key] = new NDDBIndex(key, this);
      this[key]._add(index, dbidx);
    }
  }
};

NDDB.prototype._viewIt = function(o) {
    if (!o || J.isEmpty(this.__V)) return;
  
  var func, id, index;
  
  for (var key in this.__V) {
    if (this.__V.hasOwnProperty(key)) {
      func = this.__V[key];
      index = func(o);
      if ('undefined' === typeof index) continue;
      
      if (!this[key]) this[key] = new this.constructor();
      this[key].insert(o);
    }
  }
};

NDDB.prototype._hashIt = function(o) {
    if (!o || J.isEmpty(this.__H)) return false;
  
  var h, id, hash;
  
  for (var key in this.__H) {
    if (this.__H.hasOwnProperty(key)) {
      h = this.__H[key];            
      hash = h(o);

      if ('undefined' === typeof hash) continue;
      if (!this[key]) this[key] = {};
      
      if (!this[key][hash]) {
        this[key][hash] = new this.constructor();
      }
      this[key][hash].insert(o);    
    }
  }
};

NDDB.prototype.on = function(event, func) {
  if (!event || !func || !this.hooks[event]) return;
    this.hooks[event].push(func);
    return true;
};

NDDB.prototype.off = function(event, func) {
  if (!event || !this.hooks[event] || !this.hooks[event].length) return;
   
    if (!func) {
      this.hooks[event] = [];
      return true;
    }
     
    for (var i=0; i < this.hooks[event].length; i++) {
      if (this.hooks[event][i] == func) {
        this.hooks[event].splice(i, 1);
          return true;
      }
  }
     
    return false;
}

NDDB.prototype.emit = function(event, o) {
  if (!event || !this.hooks[event] || !this.hooks[event].length) {    
    return;
  }
  
  for (var i=0; i < this.hooks[event].length; i++) {
    this.hooks[event][i].call(this, o);
  }
};

NDDB.prototype._analyzeQuery = function (d, op, value) {
    
    var raiseError = function (d,op,value) {
        var miss = '(?)';
        var err = 'Malformed query: ' + d || miss + ' ' + op || miss + ' ' + value || miss;
        NDDB.log(err, 'WARN');
        return false;
    };
    

    if ('undefined' === typeof d) raiseError(d,op,value);
    

    if ('undefined' !== typeof op) {
        
        if (op === '=') {
            op = '==';
        }
      
        if (!(op in this.query.operators)) {
            NDDB.log('Query error. Invalid operator detected: ' + op, 'WARN');
            return false;
        }

        if (J.in_array(op,['><', '<>', 'in', '!in'])) {
          
            if (!(value instanceof Array)) {
                NDDB.log('Range-queries need an array as third parameter', 'WARN');
                raiseError(d,op,value);
            }
            if (op === '<>' || op === '><') {
                
                value[0] = J.setNestedValue(d, value[0]);
                value[1] = J.setNestedValue(d, value[1]);
            }
        }
        
        else if (J.in_array(op, ['>', '==', '>=', '<', '<='])){

          if ('undefined' === typeof value) raiseError(d,op,value);

            value = J.setNestedValue(d,value);
        }
        

        
    }
    else if ('undefined' !== typeof value) {
        raiseError(d,op,value);
    }
    else {
        op = 'E'; // exists
        value = '';
    }
    
    return {d:d,op:op,value:value};
};

NDDB.prototype.distinct = function () {
  return this.breed(J.distinct(this.db));
};

NDDB.prototype.select = function (d, op, value) {
    this.query.reset();
    return arguments.length ? this.and(d, op, value) : this;
};

NDDB.prototype.and = function (d, op, value) {

    var condition = this._analyzeQuery(d, op, value);        
      if (!condition) return false;
      this.query.addCondition('AND', condition, this.getComparator(d));

  return this;
};

NDDB.prototype.or = function (d, op, value) {

    var condition = this._analyzeQuery(d, op, value);        
      if (!condition) return false;
      this.query.addCondition('OR', condition, this.getComparator(d));

  return this;
};

NDDB.prototype.selexec = function (d, op, value) {
    return this.select(d, op, value).execute();
};

NDDB.prototype.execute = function () {
    return this.filter(this.query.get.call(this.query));
};

NDDB.prototype.exists = function (o) {
  if (!o) return false;
  
  for (var i = 0 ; i < this.db.length ; i++) {
    if (J.equals(this.db[i], o)) {
      return true;
    }
  }
  
    return false;
};

NDDB.prototype.limit = function (limit) {
  limit = limit || 0;
    if (limit === 0) return this.breed();
    var db = (limit > 0) ? this.db.slice(0, limit) :
                           this.db.slice(limit);
    
    return this.breed(db);
};
    

NDDB.prototype.reverse = function () {
    this.db.reverse();
    return this;
};
    

  NDDB.prototype.sort = function (d) {

    if (!d) {
        var func = this.globalCompare;
    }
    

    else if ('function' === typeof d) {
      var func = d;
    }
    

    else if (d instanceof Array) {
      var that = this;
      var func = function (a,b) {
        for (var i=0; i < d.length; i++) {
          var result = that.getComparator(d[i]).call(that,a,b);
          if (result !== 0) return result;
        }
        return result;
      }
    }
    

    else {
      var func = this.getComparator(d);
    }
    
    this.db.sort(func);
    return this;
  };

NDDB.prototype.shuffle = function () {
    this.db = J.shuffle(this.db);
    return this;
};
    

NDDB.prototype.filter = function (func) {
    return this.breed(this.db.filter(func));
};

NDDB.prototype.each = NDDB.prototype.forEach = function () {
    if (arguments.length === 0) return;
    var func = arguments[0], i;    
    for (i = 0 ; i < this.db.length ; i++) {
        arguments[0] = this.db[i];
        func.apply(this, arguments);
    }
};

NDDB.prototype.map = function () {
    if (arguments.length === 0) return;
    var func = arguments[0], 
      out = [], o, i;
    for (i = 0 ; i < this.db.length ; i++) {
        arguments[0] = this.db[i];
        o = func.apply(this, arguments);
        if ('undefined' !== typeof o) out.push(o);
    }
    return out;
};

NDDB.prototype.update = function (update) {
  if (!this.db.length || !update) return this;
      
  for (var i = 0; i < this.db.length; i++) {
    J.mixin(this.db[i], update);
    this.emit('update', this.db[i]);
    }
  
  this._autoUpdate();
  return this;
};  

NDDB.prototype.remove = function () {
  if (!this.length) return this;
  
  this.emit('remove', this.db);
  this.db = [];
  this._autoUpdate();
  return this;
};    

NDDB.prototype.clear = function (confirm) {
    if (confirm) {
        this.db = [];
        this.tags = {};
        this.query.reset();
        this.nddb_pointer = 0;
        
        var i;
        for (i in this.__H) {
          if (this[i]) delete this[i]
        }
        for (i in this.__C) {
          if (this[i]) delete this[i]
        }
        for (var i in this.__I) {
          if (this[i]) delete this[i]
        }
    }
    else {
        NDDB.log('Do you really want to clear the current dataset? Please use clear(true)', 'WARN');
    }
    
    return confirm;
};    

NDDB.prototype.join = function (key1, key2, pos, select) {

    return this._join(key1, key2, J.equals, pos, select);
};

NDDB.prototype.concat = function (key1, key2, pos, select) {        
    return this._join(key1, key2, function(){ return true;}, pos, select);
};

NDDB.prototype._join = function (key1, key2, comparator, pos, select) {
  if (!key1 || !key2) return this.breed([]);
  
    comparator = comparator || J.equals;
    pos = ('undefined' !== typeof pos) ? pos : 'joined';
    if (select) {
        select = (select instanceof Array) ? select : [select];
    }
    var out = [], idxs = [], foreign_key, key;
    
    for (var i=0; i < this.db.length; i++) {
       
       foreign_key = J.getNestedValue(key1, this.db[i]);
       if ('undefined' !== typeof foreign_key) { 
         for (var j=i+1; j < this.db.length; j++) {
           
           key = J.getNestedValue(key2, this.db[j]);
               
               if ('undefined' !== typeof key) { 
                 if (comparator(foreign_key, key)) {

                      var o = J.clone(this.db[i]);
                      var o2 = (select) ? J.subobj(this.db[j], select) : this.db[j];
                      o[pos] = o2;
                      out.push(o);
                 }
                    
                }
            }
        }
    }
    
    return this.breed(out);
};

NDDB.prototype.split = function (key) {    
    var out = [], i;
    for (i = 0; i < this.db.length; i++) {
        out = out.concat(J.split(this.db[i], key));
    }
    return this.breed(out);
};

NDDB.prototype.fetch = function () {
    return this.db;
};

NDDB.prototype.fetchSubObj= function (key) {
  if (!key) return [];
  var i, el, out = [];
  for (i=0; i < this.db.length; i++) {
      el = J.subobj(this.db[i], key);
      if (!J.isEmpty(el)) out.push(el);
    }
    return out;
};

NDDB.prototype.fetchValues = function(key) {
  var el, i, out, typeofkey;
  
  typeofkey = typeof key, out = {};
  
  if (typeofkey === 'undefined') {  
    for (i=0; i < this.db.length; i++) {
      J.augment(out, this.db[i], J.keys(this.db[i]));
    } 
  }
  
  else if (typeofkey === 'string') {
    out[key] = [];
    for (i=0; i < this.db.length; i++) {
      el = J.getNestedValue(key, this.db[i]);
          if ('undefined' !== typeof el) {
            out[key].push(el);
          }
    }
    
    
  }
    
  else if (J.isArray(key)) {
      out = J.melt(key, J.rep([], key.length)); // object not array  
        for ( i = 0 ; i < this.db.length ; i++) {
          el = J.subobj(this.db[i], key);
          if (!J.isEmpty(el)) {
              J.augment(out, el);
            }
        }   
  }
  
    return out;
};

function getValuesArray(o, key) {
  return J.obj2Array(o, 1);
};

function getKeyValuesArray(o, key) {
  return J.obj2KeyedArray(o, 1);
};


function getValuesArray_KeyString(o, key) {
    var el = J.getNestedValue(key, o);
    if ('undefined' !== typeof el) {
        return J.obj2Array(el,1);
    }
};

function getValuesArray_KeyArray(o, key) {
    var el = J.subobj(o, key);
    if (!J.isEmpty(el)) {
      return J.obj2Array(el,1);
  }
};


function getKeyValuesArray_KeyString(o, key) {
    var el = J.getNestedValue(key, o);
    if ('undefined' !== typeof el) {
        return key.split('.').concat(J.obj2KeyedArray(el));
    }
};

function getKeyValuesArray_KeyArray(o, key) {
  var el = J.subobj(o, key);
    if (!J.isEmpty(el)) {
        return J.obj2KeyedArray(el);
  }
};

NDDB.prototype._fetchArray = function (key, keyed) {
  
    var cb, out, el, i;
    
    if (keyed) {
      
      if (!key) cb = getKeyValuesArray;
      
      else if ('string' === typeof key) {
        cb = getKeyValuesArray_KeyString;
      }
      else {
        cb = getKeyValuesArray_KeyArray;
      }
    }
    else {
      if (!key) cb = getValuesArray;
      
      else if ('string' === typeof key) {
        cb = getValuesArray_KeyString;
      }
      else {
        cb = getValuesArray_KeyArray;
      }
    }
    
    out = [];
    for (i=0; i < this.db.length; i++) {
        el = cb.call(this.db[i], this.db[i], key);
        if ('undefined' !== typeof el) out.push(el);
    }    
    
    return out;
}

NDDB.prototype.fetchArray = function (key) {
    return this._fetchArray(key);
};

NDDB.prototype.fetchKeyArray = function (key) {
    return this._fetchArray(key, true);
};
            

NDDB.prototype.groupBy = function (key) {
    if (!key) return this.db;
    
    var groups = [], outs = [], i, el, out;
    for (i = 0 ; i < this.db.length ; i++) {
        el = J.getNestedValue(key, this.db[i]);
        if ('undefined' === typeof el) continue;

        if (!J.in_array(el, groups)) {
            groups.push(el);
            out = this.filter(function (elem) {
                if (J.equals(J.getNestedValue(key, elem), el)) {
                    return this;
                }
            });   

            out.nddb_pointer = 0;
            outs.push(out);
        }
    }
    return outs;
};