/**
 * Testing the browser version of NeDB
 * The goal of these tests is not to be exhaustive, we have the server-side NeDB tests for that
 * This is more of a sanity check which executes most of the code at least once and checks
 * it behaves as the server version does
 */

var assert = chai.assert;

/**
 * Given a docs array and an id, return the document whose id matches, or null if none is found
 */
function findById (docs, id) {
  return _.find(docs, function (doc) { return doc._id === id; }) || null;
}


describe('Basic CRUD functionality', function () {

  it('Able to create a database object in the browser', function () {
    var db = new Nedb();

    assert.equal(db.inMemoryOnly, true);
    assert.equal(db.persistence.inMemoryOnly, true);
  });

  it('Insertion and querying', function (done) {
    var db = new Nedb();

    db.insert({ a: 4 }, function (err, newDoc1) {
      assert.isNull(err);
      db.insert({ a: 40 }, function (err, newDoc2) {
        assert.isNull(err);
        db.insert({ a: 400 }, function (err, newDoc3) {
          assert.isNull(err);

          db.find({ a: { $gt: 36 } }, function (err, docs) {
            var doc2 = _.find(docs, function (doc) { return doc._id === newDoc2._id; })
              , doc3 = _.find(docs, function (doc) { return doc._id === newDoc3._id; })
              ;

            assert.isNull(err);
            assert.equal(docs.length, 2);
            assert.equal(doc2.a, 40);
            assert.equal(doc3.a, 400);

            db.find({ a: { $lt: 36 } }, function (err, docs) {
              assert.isNull(err);
              assert.equal(docs.length, 1);
              assert.equal(docs[0].a, 4);
              done();
            });
          });
        });
      });
    });
  });

  it('Querying with regular expressions', function (done) {
    var db = new Nedb();

    db.insert({ planet: 'Earth' }, function (err, newDoc1) {
      assert.isNull(err);
      db.insert({ planet: 'Mars' }, function (err, newDoc2) {
        assert.isNull(err);
        db.insert({ planet: 'Jupiter' }, function (err, newDoc3) {
          assert.isNull(err);
          db.insert({ planet: 'Eaaaaaarth' }, function (err, newDoc4) {
            assert.isNull(err);
            db.insert({ planet: 'Maaaars' }, function (err, newDoc5) {
              assert.isNull(err);

              db.find({ planet: /ar/ }, function (err, docs) {
                assert.isNull(err);
                assert.equal(docs.length, 4);
                assert.equal(_.find(docs, function (doc) { return doc._id === newDoc1._id; }).planet, 'Earth');
                assert.equal(_.find(docs, function (doc) { return doc._id === newDoc2._id; }).planet, 'Mars');
                assert.equal(_.find(docs, function (doc) { return doc._id === newDoc4._id; }).planet, 'Eaaaaaarth');
                assert.equal(_.find(docs, function (doc) { return doc._id === newDoc5._id; }).planet, 'Maaaars');

                db.find({ planet: /aa+r/ }, function (err, docs) {
                  assert.isNull(err);
                  assert.equal(docs.length, 2);
                  assert.equal(_.find(docs, function (doc) { return doc._id === newDoc4._id; }).planet, 'Eaaaaaarth');
                  assert.equal(_.find(docs, function (doc) { return doc._id === newDoc5._id; }).planet, 'Maaaars');

                  done();
                });
              });
            });
          });
        });
      });
    });
  });

  it('Updating documents', function (done) {
    var db = new Nedb();

    db.insert({ planet: 'Eaaaaarth' }, function (err, newDoc1) {
      db.insert({ planet: 'Maaaaars' }, function (err, newDoc2) {
        // Simple update
        db.update({ _id: newDoc2._id }, { $set: { planet: 'Saturn' } }, {}, function (err, nr) {
          assert.isNull(err);
          assert.equal(nr, 1);

          db.find({}, function (err, docs) {
            assert.equal(docs.length, 2);
            assert.equal(findById(docs, newDoc1._id).planet, 'Eaaaaarth');
            assert.equal(findById(docs, newDoc2._id).planet, 'Saturn');

            // Failing update
            db.update({ _id: 'unknown' }, { $inc: { count: 1 } }, {}, function (err, nr) {
              assert.isNull(err);
              assert.equal(nr, 0);

              db.find({}, function (err, docs) {
                assert.equal(docs.length, 2);
                assert.equal(findById(docs, newDoc1._id).planet, 'Eaaaaarth');
                assert.equal(findById(docs, newDoc2._id).planet, 'Saturn');

                // Document replacement
                db.update({ planet: 'Eaaaaarth' }, { planet: 'Uranus' }, { multi: false }, function (err, nr) {
                  assert.isNull(err);
                  assert.equal(nr, 1);

                  db.find({}, function (err, docs) {
                    assert.equal(docs.length, 2);
                    assert.equal(findById(docs, newDoc1._id).planet, 'Uranus');
                    assert.equal(findById(docs, newDoc2._id).planet, 'Saturn');

                    // Multi update
                    db.update({}, { $inc: { count: 3 } }, { multi: true }, function (err, nr) {
                      assert.isNull(err);
                      assert.equal(nr, 2);

                      db.find({}, function (err, docs) {
                        assert.equal(docs.length, 2);
                        assert.equal(findById(docs, newDoc1._id).planet, 'Uranus');
                        assert.equal(findById(docs, newDoc1._id).count, 3);
                        assert.equal(findById(docs, newDoc2._id).planet, 'Saturn');
                        assert.equal(findById(docs, newDoc2._id).count, 3);

                        done();
                      });
                    });
                  });
                });
              });
            });
          });
        });
      });
    });
  });

  it('Updating documents: special modifiers', function (done) {
    var db = new Nedb();

    db.insert({ planet: 'Earth' }, function (err, newDoc1) {
      // Pushing to an array
      db.update({}, { $push: { satellites: 'Phobos' } }, {}, function (err, nr) {
        assert.isNull(err);
        assert.equal(nr, 1);

        db.findOne({}, function (err, doc) {
          assert.deepEqual(doc, { planet: 'Earth', _id: newDoc1._id, satellites: ['Phobos'] });

          db.update({}, { $push: { satellites: 'Deimos' } }, {}, function (err, nr) {
            assert.isNull(err);
            assert.equal(nr, 1);

            db.findOne({}, function (err, doc) {
              assert.deepEqual(doc, { planet: 'Earth', _id: newDoc1._id, satellites: ['Phobos', 'Deimos'] });

              done();
            });
          });
        });
      });
    });
  });

  it('Upserts', function (done) {
    var db = new Nedb();

    db.update({ a: 4 }, { $inc: { b: 1 } }, { upsert: true }, function (err, nr, upsert) {
      assert.isNull(err);
      // Return upserted document
      assert.equal(upsert.a, 4);
      assert.equal(upsert.b, 1);
      assert.equal(nr, 1);

      db.find({}, function (err, docs) {
        assert.equal(docs.length, 1);
        assert.equal(docs[0].a, 4);
        assert.equal(docs[0].b, 1);

        done();
      });
    });
  });

  it('Removing documents', function (done) {
    var db = new Nedb();

    db.insert({ a: 2 });
    db.insert({ a: 5 });
    db.insert({ a: 7 });

    // Multi remove
    db.remove({ a: { $in: [ 5, 7 ] } }, { multi: true }, function (err, nr) {
      assert.isNull(err);
      assert.equal(nr, 2);

      db.find({}, function (err, docs) {
        assert.equal(docs.length, 1);
        assert.equal(docs[0].a, 2);

        // Remove with no match
        db.remove({ b: { $exists: true } }, { multi: true }, function (err, nr) {
          assert.isNull(err);
          assert.equal(nr, 0);

          db.find({}, function (err, docs) {
            assert.equal(docs.length, 1);
            assert.equal(docs[0].a, 2);

            // Simple remove
            db.remove({ a: { $exists: true } }, { multi: true }, function (err, nr) {
              assert.isNull(err);
              assert.equal(nr, 1);

              db.find({}, function (err, docs) {
                assert.equal(docs.length, 0);

                done();
              });
            });
          });
        });
      });
    });
  });

});   // ==== End of 'Basic CRUD functionality' ==== //


describe('Indexing', function () {

  it('getCandidates works as expected', function (done) {
    var db = new Nedb();

    db.insert({ a: 4 }, function () {
      db.insert({ a: 6 }, function () {
        db.insert({ a: 7 }, function () {
          var candidates = db.getCandidates({ a: 6 })
          assert.equal(candidates.length, 3);
          assert.isDefined(_.find(candidates, function (doc) { return doc.a === 4; }));
          assert.isDefined(_.find(candidates, function (doc) { return doc.a === 6; }));
          assert.isDefined(_.find(candidates, function (doc) { return doc.a === 7; }));

          db.ensureIndex({ fieldName: 'a' });

          candidates = db.getCandidates({ a: 6 })
          assert.equal(candidates.length, 1);
          assert.isDefined(_.find(candidates, function (doc) { return doc.a === 6; }));

          done();
        });
      });
    });
  });

  it('Can use indexes to enforce a unique constraint', function (done) {
    var db = new Nedb();

    db.ensureIndex({ fieldName: 'u', unique: true });

    db.insert({ u : 5 }, function (err) {
      assert.isNull(err);

      db.insert({ u : 98 }, function (err) {
        assert.isNull(err);

        db.insert({ u : 5 }, function (err) {
          assert.equal(err.errorType, 'uniqueViolated');

          done();
        });
      });
    });
  });

});   // ==== End of 'Indexing' ==== //