/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS102: Remove unnecessary code created because of implicit returns
 * DS206: Consider reworking classes to avoid initClass
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
const SandboxedModule = require('sandboxed-module');
const sinon = require('sinon');
const should = require('chai').should();
const modulePath = require('path').join(__dirname, '../../../app/js/ResourceWriter');
const path = require("path");

describe("ResourceWriter", function() {
	beforeEach(function() {
		let Timer;
		this.ResourceWriter = SandboxedModule.require(modulePath, { requires: {
			"fs": (this.fs = {
				mkdir: sinon.stub().callsArg(1),
				unlink: sinon.stub().callsArg(1)
			}),
			"./ResourceStateManager": (this.ResourceStateManager = {}),
			"wrench": (this.wrench = {}),
			"./UrlCache" : (this.UrlCache = {}),
			"mkdirp" : (this.mkdirp = sinon.stub().callsArg(1)),
			"./OutputFileFinder": (this.OutputFileFinder = {}),
			"logger-sharelatex": {log: sinon.stub(), err: sinon.stub()},
			"./Metrics": (this.Metrics = {
				Timer: (Timer = (function() {
					Timer = class Timer {
						static initClass() {
							this.prototype.done = sinon.stub();
						}
					};
					Timer.initClass();
					return Timer;
				})())
			})
		}
	}
		);
		this.project_id = "project-id-123";
		this.basePath = "/path/to/write/files/to";
		return this.callback = sinon.stub();
	});

	describe("syncResourcesToDisk on a full request", function() {
		beforeEach(function() {
			this.resources = [
				"resource-1-mock",
				"resource-2-mock",
				"resource-3-mock"
			];
			this.ResourceWriter._writeResourceToDisk = sinon.stub().callsArg(3);
			this.ResourceWriter._removeExtraneousFiles = sinon.stub().callsArg(2);
			this.ResourceStateManager.saveProjectState = sinon.stub().callsArg(3);
			return this.ResourceWriter.syncResourcesToDisk({
				project_id: this.project_id,
				syncState: (this.syncState = "0123456789abcdef"),
				resources: this.resources
			}, this.basePath, this.callback);
		});

		it("should remove old files", function() {
			return this.ResourceWriter._removeExtraneousFiles
				.calledWith(this.resources, this.basePath)
				.should.equal(true);
		});

		it("should write each resource to disk", function() {
			return Array.from(this.resources).map((resource) =>
				this.ResourceWriter._writeResourceToDisk
					.calledWith(this.project_id, resource, this.basePath)
					.should.equal(true));
		});

		it("should store the sync state and resource list", function() {
			return this.ResourceStateManager.saveProjectState
				.calledWith(this.syncState, this.resources, this.basePath)
				.should.equal(true);
		});

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

	describe("syncResourcesToDisk on an incremental update", function() {
		beforeEach(function() {
			this.resources = [
				"resource-1-mock"
			];
			this.ResourceWriter._writeResourceToDisk = sinon.stub().callsArg(3);
			this.ResourceWriter._removeExtraneousFiles = sinon.stub().callsArgWith(2, null, (this.outputFiles = []), (this.allFiles = []));
			this.ResourceStateManager.checkProjectStateMatches = sinon.stub().callsArgWith(2, null, this.resources);
			this.ResourceStateManager.saveProjectState = sinon.stub().callsArg(3);
			this.ResourceStateManager.checkResourceFiles = sinon.stub().callsArg(3);
			return this.ResourceWriter.syncResourcesToDisk({
				project_id: this.project_id,
				syncType: "incremental",
				syncState: (this.syncState = "1234567890abcdef"),
				resources: this.resources
			}, this.basePath, this.callback);
		});

		it("should check the sync state matches", function() {
			return this.ResourceStateManager.checkProjectStateMatches
				.calledWith(this.syncState, this.basePath)
				.should.equal(true);
		});

		it("should remove old files", function() {
			return this.ResourceWriter._removeExtraneousFiles
				.calledWith(this.resources, this.basePath)
				.should.equal(true);
		});

		it("should check each resource exists", function() {
			return this.ResourceStateManager.checkResourceFiles
				.calledWith(this.resources, this.allFiles, this.basePath)
				.should.equal(true);
		});

		it("should write each resource to disk", function() {
			return Array.from(this.resources).map((resource) =>
				this.ResourceWriter._writeResourceToDisk
					.calledWith(this.project_id, resource, this.basePath)
					.should.equal(true));
		});

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

	describe("syncResourcesToDisk on an incremental update when the state does not match", function() {
		beforeEach(function() {
			this.resources = [
				"resource-1-mock"
			];
			this.ResourceStateManager.checkProjectStateMatches = sinon.stub().callsArgWith(2, (this.error = new Error()));
			return this.ResourceWriter.syncResourcesToDisk({
				project_id: this.project_id,
				syncType: "incremental",
				syncState: (this.syncState = "1234567890abcdef"),
				resources: this.resources
			}, this.basePath, this.callback);
		});

		it("should check whether the sync state matches", function() {
			return this.ResourceStateManager.checkProjectStateMatches
				.calledWith(this.syncState, this.basePath)
				.should.equal(true);
		});

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


	describe("_removeExtraneousFiles", function() {
		beforeEach(function() {
			this.output_files = [{
				path: "output.pdf",
				type: "pdf"
			}, {
				path: "extra/file.tex",
				type: "tex"
			}, {
				path: "extra.aux",
				type: "aux"
			}, {
				path: "cache/_chunk1"
			},{
				path: "figures/image-eps-converted-to.pdf",
				type: "pdf"
			},{
				path: "foo/main-figure0.md5",
				type: "md5"
			}, {
				path: "foo/main-figure0.dpth",
				type: "dpth"
			}, {
				path: "foo/main-figure0.pdf",
				type: "pdf"
			}, {
				path: "_minted-main/default-pyg-prefix.pygstyle",
				type: "pygstyle"
			}, {
				path: "_minted-main/default.pygstyle",
				type: "pygstyle"
			}, {
				path: "_minted-main/35E248B60965545BD232AE9F0FE9750D504A7AF0CD3BAA7542030FC560DFCC45.pygtex",
				type: "pygtex"
			}, {
				path: "_markdown_main/30893013dec5d869a415610079774c2f.md.tex",
				type: "tex"
			}];
			this.resources = "mock-resources";
			this.OutputFileFinder.findOutputFiles = sinon.stub().callsArgWith(2, null, this.output_files);
			this.ResourceWriter._deleteFileIfNotDirectory = sinon.stub().callsArg(1);
			return this.ResourceWriter._removeExtraneousFiles(this.resources, this.basePath, this.callback);
		});

		it("should find the existing output files", function() {
			return this.OutputFileFinder.findOutputFiles
				.calledWith(this.resources, this.basePath)
				.should.equal(true);
		});

		it("should delete the output files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "output.pdf"))
				.should.equal(true);
		});

		it("should delete the extra files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "extra/file.tex"))
				.should.equal(true);
		});

		it("should not delete the extra aux files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "extra.aux"))
				.should.equal(false);
		});
		
		it("should not delete the knitr cache file", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "cache/_chunk1"))
				.should.equal(false);
		});

		it("should not delete the epstopdf converted files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "figures/image-eps-converted-to.pdf"))
				.should.equal(false);
		});

		it("should not delete the tikz md5 files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "foo/main-figure0.md5"))
				.should.equal(false);
		});

		it("should not delete the tikz dpth files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "foo/main-figure0.dpth"))
				.should.equal(false);
		});

		it("should not delete the tikz pdf files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "foo/main-figure0.pdf"))
				.should.equal(false);
		});

		it("should not delete the minted pygstyle files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "_minted-main/default-pyg-prefix.pygstyle"))
				.should.equal(false);
		});

		it("should not delete the minted default pygstyle files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "_minted-main/default.pygstyle"))
				.should.equal(false);
		});

		it("should not delete the minted default pygtex files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "_minted-main/35E248B60965545BD232AE9F0FE9750D504A7AF0CD3BAA7542030FC560DFCC45.pygtex"))
				.should.equal(false);
		});

		it("should not delete the markdown md.tex files", function() {
			return this.ResourceWriter._deleteFileIfNotDirectory
				.calledWith(path.join(this.basePath, "_markdown_main/30893013dec5d869a415610079774c2f.md.tex"))
				.should.equal(false);
		});

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

		return it("should time the request", function() {
			return this.Metrics.Timer.prototype.done.called.should.equal(true);
		});
	});

	describe("_writeResourceToDisk", function() {
		describe("with a url based resource", function() {
			beforeEach(function() {
				this.resource = {
					path: "main.tex",
					url: "http://www.example.com/main.tex",
					modified: Date.now()
				};
				this.UrlCache.downloadUrlToFile = sinon.stub().callsArgWith(4, "fake error downloading file");
				return this.ResourceWriter._writeResourceToDisk(this.project_id, this.resource, this.basePath, this.callback);
			});

			it("should ensure the directory exists", function() {
				return this.mkdirp
					.calledWith(path.dirname(path.join(this.basePath, this.resource.path)))
					.should.equal(true);
			});

			it("should write the URL from the cache", function() {
				return this.UrlCache.downloadUrlToFile
					.calledWith(this.project_id, this.resource.url, path.join(this.basePath, this.resource.path), this.resource.modified)
					.should.equal(true);
			});
			
			it("should call the callback", function() {
				return this.callback.called.should.equal(true);
			});

			return it("should not return an error if the resource writer errored", function() {
				return should.not.exist(this.callback.args[0][0]);
		});
	});

		describe("with a content based resource", function() {
			beforeEach(function() {
				this.resource = {
					path: "main.tex",
					content: "Hello world"
				};
				this.fs.writeFile = sinon.stub().callsArg(2);
				return this.ResourceWriter._writeResourceToDisk(this.project_id, this.resource, this.basePath, this.callback);
			});

			it("should ensure the directory exists", function() {
				return this.mkdirp
					.calledWith(path.dirname(path.join(this.basePath, this.resource.path)))
					.should.equal(true);
			});

			it("should write the contents to disk", function() {
				return this.fs.writeFile
					.calledWith(path.join(this.basePath, this.resource.path), this.resource.content)
					.should.equal(true);
			});
				
			return it("should call the callback", function() {
				return this.callback.called.should.equal(true);
			});
		});

		return describe("with a file path that breaks out of the root folder", function() {
			beforeEach(function() {
				this.resource = {
					path: "../../main.tex",
					content: "Hello world"
				};
				this.fs.writeFile = sinon.stub().callsArg(2);
				return this.ResourceWriter._writeResourceToDisk(this.project_id, this.resource, this.basePath, this.callback);
			});

			it("should not write to disk", function() {
				return this.fs.writeFile.called.should.equal(false);
			});

			return it("should return an error", function() {
				return this.callback
					.calledWith(new Error("resource path is outside root directory"))
					.should.equal(true);
			});
		});
	});
			
	return describe("checkPath", function() {
		describe("with a valid path", function() {
			beforeEach(function() {
				return this.ResourceWriter.checkPath("foo", "bar", this.callback);
			});

			return it("should return the joined path", function() {
				return this.callback.calledWith(null, "foo/bar")
				.should.equal(true);
			});
		});

		describe("with an invalid path", function() {
			beforeEach(function() {
				return this.ResourceWriter.checkPath("foo", "baz/../../bar", this.callback);
			});

			return it("should return an error", function() {
				return this.callback.calledWith(new Error("resource path is outside root directory"))
				.should.equal(true);
			});
		});

		return describe("with another invalid path matching on a prefix", function() {
			beforeEach(function() {
				return this.ResourceWriter.checkPath("foo", "../foobar/baz", this.callback);
			});

			return it("should return an error", function() {
				return this.callback.calledWith(new Error("resource path is outside root directory"))
				.should.equal(true);
			});
		});
	});
});