/*
 * decaffeinate suggestions:
 * DS102: Remove unnecessary code created because of implicit returns
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
const SandboxedModule = require('sandboxed-module');
const sinon = require('sinon');
require('chai').should();
const modulePath = require('path').join(__dirname, '../../../app/js/MongoManager');
const {
    ObjectId
} = require("mongojs");
const {
    assert
} = require("chai");

describe("MongoManager", function() {
	beforeEach(function() {
		this.MongoManager = SandboxedModule.require(modulePath, { requires: {
			"./mongojs": {
				db: (this.db = { docs: {}, docOps: {} }),
				ObjectId
			},
			'metrics-sharelatex': {timeAsyncMethod: sinon.stub()},
			'logger-sharelatex': {log(){}}
		}
	});
		this.project_id = ObjectId().toString();
		this.doc_id = ObjectId().toString();
		this.callback = sinon.stub();
		return this.stubbedErr = new Error("hello world");
	});

	describe("findDoc", function() {
		beforeEach(function() {
			this.doc = { name: "mock-doc"};
			this.db.docs.find = sinon.stub().callsArgWith(2, null, [this.doc]);
			this.filter = { lines: true };
			return this.MongoManager.findDoc(this.project_id, this.doc_id, this.filter, this.callback);
		});

		it("should find the doc", function() {
			return this.db.docs.find
				.calledWith({
					_id: ObjectId(this.doc_id),
					project_id: ObjectId(this.project_id)
				}, this.filter)
				.should.equal(true);
		});

		return it("should call the callback with the doc", function() {
			return this.callback.calledWith(null, this.doc).should.equal(true);
		});
	});

	describe("getProjectsDocs", function() {
		beforeEach(function() {
			this.filter = {lines: true};
			this.doc1 = { name: "mock-doc1" };
			this.doc2 = { name: "mock-doc2" };
			this.doc3 = { name: "mock-doc3" };
			this.doc4 = { name: "mock-doc4" };
			return this.db.docs.find = sinon.stub().callsArgWith(2, null, [this.doc, this.doc3, this.doc4]);
		});
		
		describe("with included_deleted = false", function() {
			beforeEach(function() { 
				return this.MongoManager.getProjectsDocs(this.project_id, {include_deleted: false}, this.filter, this.callback);
			});

			it("should find the non-deleted docs via the project_id", function() {
				return this.db.docs.find
					.calledWith({
						project_id: ObjectId(this.project_id),
						deleted: { $ne: true }
					}, this.filter)
					.should.equal(true);
			});

			return it("should call the callback with the docs", function() {
				return this.callback.calledWith(null, [this.doc, this.doc3, this.doc4]).should.equal(true);
			});
		});
				
		return describe("with included_deleted = true", function() {
			beforeEach(function() {
				return this.MongoManager.getProjectsDocs(this.project_id, {include_deleted: true}, this.filter, this.callback);
			});

			it("should find all via the project_id", function() {
				return this.db.docs.find
					.calledWith({
						project_id: ObjectId(this.project_id)
					}, this.filter)
					.should.equal(true);
			});

			return it("should call the callback with the docs", function() {
				return this.callback.calledWith(null, [this.doc, this.doc3, this.doc4]).should.equal(true);
			});
		});
	});

	describe("upsertIntoDocCollection", function() {
		beforeEach(function() {
			this.db.docs.update = sinon.stub().callsArgWith(3, this.stubbedErr);
			return this.oldRev = 77;
		});

		it("should upsert the document", function(done){	
			return this.MongoManager.upsertIntoDocCollection(this.project_id, this.doc_id, {lines: this.lines}, err=> {
				const args = this.db.docs.update.args[0];
				assert.deepEqual(args[0], {_id: ObjectId(this.doc_id)});
				assert.equal(args[1]["$set"]["lines"], this.lines);
				assert.equal(args[1]["$inc"]["rev"], 1);
				assert.deepEqual(args[1]["$set"]["project_id"], ObjectId(this.project_id));
				return done();
			});
		});

		return it("should return the error", function(done){
			return this.MongoManager.upsertIntoDocCollection(this.project_id, this.doc_id, {lines: this.lines}, err=> {
				err.should.equal(this.stubbedErr);
				return done();
			});
		});
	});

	describe("markDocAsDeleted", function() {
		beforeEach(function() {
			this.db.docs.update = sinon.stub().callsArgWith(2, this.stubbedErr);
			return this.oldRev = 77;
		});

		it("should process the update", function(done) {
			return this.MongoManager.markDocAsDeleted(this.project_id, this.doc_id, err=> {
				const args = this.db.docs.update.args[0];
				assert.deepEqual(args[0], {_id: ObjectId(this.doc_id), project_id: ObjectId(this.project_id)});
				assert.equal(args[1]["$set"]["deleted"], true);
				return done();
			});
		});

		return it("should return the error", function(done){
			return this.MongoManager.markDocAsDeleted(this.project_id, this.doc_id, err=> {
				err.should.equal(this.stubbedErr);
				return done();
			});
		});
	});

	describe("destroyDoc", function() {
		beforeEach(function(done) {
			this.db.docs.remove = sinon.stub().yields();
			this.db.docOps.remove = sinon.stub().yields();
			return this.MongoManager.destroyDoc('123456789012', done);
		});

		it("should destroy the doc", function() {
			return sinon.assert.calledWith(this.db.docs.remove, {_id: ObjectId('123456789012')});
		});

		return it("should destroy the docOps", function() {
			return sinon.assert.calledWith(this.db.docOps.remove, {doc_id: ObjectId('123456789012')});
		});
	});

	describe("getDocVersion", function() {
		describe("when the doc exists", function() {
			beforeEach(function() {
				this.doc =
					{version: (this.version = 42)};
				this.db.docOps.find = sinon.stub().callsArgWith(2, null, [this.doc]);
				return this.MongoManager.getDocVersion(this.doc_id, this.callback);
			});

			it("should look for the doc in the database", function() {
				return this.db.docOps.find
					.calledWith({ doc_id: ObjectId(this.doc_id) }, {version: 1})
					.should.equal(true);
			});

			return it("should call the callback with the version", function() {
				return this.callback.calledWith(null, this.version).should.equal(true);
			});
		});

		return describe("when the doc doesn't exist", function() {
			beforeEach(function() {
				this.db.docOps.find = sinon.stub().callsArgWith(2, null, []);
				return this.MongoManager.getDocVersion(this.doc_id, this.callback);
			});

			return it("should call the callback with 0", function() {
				return this.callback.calledWith(null, 0).should.equal(true);
			});
		});
	});

	return describe("setDocVersion", function() {
		beforeEach(function() {
			this.version = 42;
			this.db.docOps.update = sinon.stub().callsArg(3);
			return this.MongoManager.setDocVersion(this.doc_id, this.version, this.callback);
		});

		it("should update the doc version", function() {
			return this.db.docOps.update
				.calledWith({
					doc_id: ObjectId(this.doc_id)
				}, {
					$set: {
						version: this.version
					}
				}, {
					upsert: true 
				})
				.should.equal(true);
		});

		return it("should call the callback", function() {
			return this.callback.called.should.equal(true);
		});
	});
});