module workspaced.com.moduleman;

import dparse.ast;
import dparse.lexer;
import dparse.parser;
import dparse.rollback_allocator;

import std.algorithm;
import std.array;
import std.file;
import std.functional;
import std.path;
import std.string;

import workspaced.api;

@component("moduleman")
class ModulemanComponent : ComponentWrapper
{
	mixin DefaultComponentWrapper;

	protected void load()
	{
		config.stringBehavior = StringBehavior.source;
	}

	/// Renames a module to something else (only in the project root).
	/// Params:
	/// 	renameSubmodules: when `true`, this will rename submodules of the module too. For example when renaming `lib.com` to `lib.coms` this will also rename `lib.com.*` to `lib.coms.*`
	/// Returns: all changes that need to happen to rename the module. If no module statement could be found this will return an empty array.
	FileChanges[] rename(string mod, string rename, bool renameSubmodules = true)
	{
		if (!refInstance)
			throw new Exception("moduleman.rename requires to be instanced");

		FileChanges[] changes;
		bool foundModule = false;
		auto from = mod.split('.');
		auto to = rename.split('.');
		foreach (file; dirEntries(instance.cwd, SpanMode.depth))
		{
			if (file.extension != ".d")
				continue;
			string code = readText(file);
			auto tokens = getTokensForParser(cast(ubyte[]) code, config, &workspaced.stringCache);
			auto parsed = parseModule(tokens, file, &rba);
			auto reader = new ModuleChangerVisitor(file, from, to, renameSubmodules);
			reader.visit(parsed);
			if (reader.changes.replacements.length)
				changes ~= reader.changes;
			if (reader.foundModule)
				foundModule = true;
		}
		if (!foundModule)
			return [];
		return changes;
	}

	/// Renames/adds/removes a module from a file to match the majority of files in the folder.
	/// Params:
	/// 	file: File path to the file to normalize
	/// 	code: Current code inside the text buffer
	CodeReplacement[] normalizeModules(string file, string code)
	{
		if (!refInstance)
			throw new Exception("moduleman.rename requires to be instanced");

		int[string] modulePrefixes;
		modulePrefixes[""] = 0;
		string modName = file.replace("\\", "/").stripExtension;
		if (modName.baseName == "package")
			modName = modName.dirName;
		if (modName.startsWith(instance.cwd.replace("\\", "/")))
			modName = modName[instance.cwd.length .. $];
		modName = modName.stripLeft('/');
		foreach (imp; importPaths)
		{
			imp = imp.replace("\\", "/");
			if (imp.startsWith(instance.cwd.replace("\\", "/")))
				imp = imp[instance.cwd.length .. $];
			imp = imp.stripLeft('/');
			if (modName.startsWith(imp))
			{
				modName = modName[imp.length .. $];
				break;
			}
		}
		auto sourcePos = (modName ~ '/').indexOf("/source/");
		if (sourcePos != -1)
			modName = modName[sourcePos + "/source".length .. $];
		modName = modName.stripLeft('/').replace("/", ".");
		if (!modName.length)
			return [];
		auto existing = describeModule(code);
		if (modName == existing.moduleName)
		{
			return [];
		}
		else
		{
			if (modName == "")
				return [CodeReplacement([existing.outerFrom, existing.outerTo], "")];
			else
				return [CodeReplacement([existing.outerFrom, existing.outerTo], "module " ~ modName ~ ";")];
		}
	}

	/// Returns the module name parts of a D code
	const(string)[] getModule(string code)
	{
		return describeModule(code).raw;
	}

	/// Returns the normalized module name as string of a D code
	string moduleName(string code)
	{
		return describeModule(code).moduleName;
	}

	///
	FileModuleInfo describeModule(string code)
	{
		auto tokens = getTokensForParser(cast(ubyte[]) code, config, &workspaced.stringCache);
		ptrdiff_t start = -1;
		size_t from, to;
		size_t outerFrom, outerTo;

		foreach (i, Token t; tokens)
		{
			if (t.type == tok!"module")
			{
				start = i;
				outerFrom = t.index;
				break;
			}
		}

		if (start == -1)
			return FileModuleInfo.init;

		const(string)[] raw;
		string moduleName;
		foreach (t; tokens[start + 1 .. $])
		{
			if (t.type == tok!";")
			{
				outerTo = t.index + 1;
				break;
			}
			if (t.type == tok!"identifier")
			{
				if (from == 0)
					from = t.index;
				moduleName ~= t.text;
				to = t.index + t.text.length;
				raw ~= t.text;
			}
			if (t.type == tok!".")
			{
				moduleName ~= ".";
			}
		}
		return FileModuleInfo(raw, moduleName, from, to, outerFrom, outerTo);
	}

private:
	RollbackAllocator rba;
	LexerConfig config;
}

/// Represents a module statement in a file.
struct FileModuleInfo
{
	/// Parts of the module name as array.
	const(string)[] raw;
	/// Whole modulename as normalized string in form a.b.c etc.
	string moduleName = "";
	/// Code index of the moduleName
	size_t from, to;
	/// Code index of the whole module statement starting right at module and ending right after the semicolon.
	size_t outerFrom, outerTo;
}

private:

class ModuleChangerVisitor : ASTVisitor
{
	this(string file, string[] from, string[] to, bool renameSubmodules)
	{
		changes.file = file;
		this.from = from;
		this.to = to;
		this.renameSubmodules = renameSubmodules;
	}

	alias visit = ASTVisitor.visit;

	override void visit(const ModuleDeclaration decl)
	{
		auto mod = decl.moduleName.identifiers.map!(a => a.text).array;
		auto orig = mod;
		if (mod.startsWith(from) && renameSubmodules)
			mod = to ~ mod[from.length .. $];
		else if (mod == from)
			mod = to;
		if (mod != orig)
		{
			foundModule = true;
			changes.replacements ~= CodeReplacement([decl.moduleName.identifiers[0].index,
					decl.moduleName.identifiers[$ - 1].index + decl.moduleName.identifiers[$ - 1].text.length],
					mod.join('.'));
		}
	}

	override void visit(const SingleImport imp)
	{
		auto mod = imp.identifierChain.identifiers.map!(a => a.text).array;
		auto orig = mod;
		if (mod.startsWith(from) && renameSubmodules)
			mod = to ~ mod[from.length .. $];
		else if (mod == from)
			mod = to;
		if (mod != orig)
		{
			changes.replacements ~= CodeReplacement([imp.identifierChain.identifiers[0].index,
					imp.identifierChain.identifiers[$ - 1].index
					+ imp.identifierChain.identifiers[$ - 1].text.length], mod.join('.'));
		}
	}

	override void visit(const ImportDeclaration decl)
	{
		if (decl)
		{
			return decl.accept(this);
		}
	}

	override void visit(const BlockStatement content)
	{
		if (content)
		{
			return content.accept(this);
		}
	}

	string[] from, to;
	FileChanges changes;
	bool renameSubmodules, foundModule;
}

unittest
{
	auto backend = new WorkspaceD();
	auto workspace = makeTemporaryTestingWorkspace;
	workspace.createDir("source/newmod");
	workspace.createDir("unregistered/source");
	workspace.writeFile("source/newmod/color.d", "module oldmod.color;void foo(){}");
	workspace.writeFile("source/newmod/render.d", "module oldmod.render;import std.color,oldmod.color;import oldmod.color.oldmod:a=b, c;import a=oldmod.a;void bar(){}");
	workspace.writeFile("source/newmod/display.d", "module newmod.displaf;");
	workspace.writeFile("source/newmod/input.d", "");
	workspace.writeFile("source/newmod/package.d", "");
	workspace.writeFile("unregistered/source/package.d", "");
	workspace.writeFile("unregistered/source/app.d", "");
	auto instance = backend.addInstance(workspace.directory);
	backend.register!ModulemanComponent;
	auto mod = backend.get!ModulemanComponent(workspace.directory);

	instance.importPathProvider = () => ["source"];

	FileChanges[] changes = mod.rename("oldmod", "newmod").sort!"a.file < b.file".array;

	assert(changes.length == 2);
	assert(changes[0].file.endsWith("color.d"));
	assert(changes[1].file.endsWith("render.d"));

	assert(changes[0].replacements == [CodeReplacement([7, 19], "newmod.color")]);
	assert(changes[1].replacements == [CodeReplacement([7, 20], "newmod.render"),
			CodeReplacement([38, 50], "newmod.color"), CodeReplacement([58, 77],
				"newmod.color.oldmod"), CodeReplacement([94, 102], "newmod.a")]);

	foreach (change; changes)
	{
		string code = readText(change.file);
		foreach_reverse (op; change.replacements)
			code = op.apply(code);
		std.file.write(change.file, code);
	}

	auto nrm = mod.normalizeModules(workspace.getPath("source/newmod/input.d"), "");
	assert(nrm == [CodeReplacement([0, 0], "module newmod.input;")]);

	nrm = mod.normalizeModules(workspace.getPath("source/newmod/package.d"), "");
	assert(nrm == [CodeReplacement([0, 0], "module newmod;")]);

	nrm = mod.normalizeModules(workspace.getPath("source/newmod/display.d"),
			"module oldmod.displaf;");
	assert(nrm == [CodeReplacement([0, 22], "module newmod.display;")]);

	nrm = mod.normalizeModules(workspace.getPath("unregistered/source/app.d"), "");
	assert(nrm == [CodeReplacement([0, 0], "module app;")]);

	nrm = mod.normalizeModules(workspace.getPath("unregistered/source/package.d"), "");
	assert(nrm == []);

	auto fetched = mod.describeModule("/* hello world */ module\nfoo . \nbar  ;\n\nvoid foo() {");
	assert(fetched == FileModuleInfo(["foo", "bar"], "foo.bar", 25, 35, 18, 38));
}