module rest.apiv1;

import vibe.core.log;
import vibe.data.json;
import vibe.http.client;
import vibe.stream.operations : readAllUTF8;

import rest.iapiv1;
import exec.iexecprovider;
import contentprovider;

import std.array : replace;
import std.format : format;

class ApiV1: IApiV1
{
	private IExecProvider execProvider_;
	private ContentProvider contentProvider_;
	string githubToken; /// Token for authenticating GitHub requests

	this(IExecProvider execProvider, ContentProvider contentProvider, string githubToken)
	{
		this.execProvider_ = execProvider;
		this.contentProvider_ = contentProvider;
		this.githubToken = "token " ~ githubToken;
	}

	/++
		Parses the message contained in $(D output)
		and fills the appropriate errors and warnings
		arrays.
		Note: parsing s just done when $(D output.success)
		is false.
	+/
	private static void parseErrorsAndWarnings(ref RunOutput output)
	{
		import std.regex: ctRegex, matchFirst, replaceAll;
		import std.conv: to;
		import std..string: lineSplitter;

		static coloring = ctRegex!
			`\x1B\[[0-9;]*[mGK]`;
		static ctr = ctRegex!
			`^[^(]+\(([0-9]+)(,[0-9]+)?\): ([a-zA-Z]+): (.*)$`;

		foreach(line; output.output.replaceAll(coloring, "").lineSplitter) {
			auto m = line.matchFirst(ctr);
			if (m.empty)
				continue;
			auto lineNumber = to!int(m[1]);
			string type = m[3];
			string message = m[4];

			switch (type) {
				case "Warning":
				case "Deprecation":
					output.warnings ~= RunOutput.Message(lineNumber,
						message);
					break;
				default:
					output.errors ~= RunOutput.Message(lineNumber,
						message);
			}
		}
	}

	// --- Argumentation for the chosen limit ---
	// The average line length of Phobos std/ is about 30 characters,
	// while on average files are 1800 lines long. The average file
	// size is 62391 bytes.
	// We pick a rather generous limit of 64k (64 * 1024) which ought
	// to be enough for everybody.
	enum uint maxSourceCodeLength = 64 * 1024;

	RunOutput run(ApiV1.RunInput input)
	{
		if (input.source.length > maxSourceCodeLength) {
			return RunOutput("ERROR: source code size is above limit of 64k bytes.", false);
		}

		// sanitize input and remove weird unicode characters
		input.source = input.source.removeUnicodeSpaces;

		// Be explicit here, in case the exec API and the REST API change
		IExecProvider.RunInput runInput = {
			source: input.source,
			compiler : input.compiler,
			args: input.args,
			runtimeArgs: input.runtimeArgs,
			stdin: input.stdin,
			color: input.color,
		};
		auto result = execProvider_.compileAndExecute(runInput);
		auto output = RunOutput(result.output, result.success);
		parseErrorsAndWarnings(output);
		return output;
	}

	FormatOutput format(string source)
	{
		// https://github.com/dlang-community/dfmt/blob/master/src/dfmt/config.d
		import dfmt.config : Config;
		import dfmt.formatter : format;
		import std.array : appender;
		import std.range.primitives;

		FormatOutput output;
		ubyte[] buffer;
		buffer = cast(ubyte[]) source;

		Config formatterConfig;
		formatterConfig.initializeWithDefaults();
		auto app = appender!string;
		format(source, buffer, app, &formatterConfig);
		output.source = app.data;
		if (output.source.back == '\n')
			output.source.popBack;
		return output;
	}

	ShortenOutput shorten(string source, string compiler, string args)
	{
		import std.format : format;
		import std.uri : encodeComponent;

		ShortenOutput output;
		auto url = "https://run.dlang.io?compiler=%s&source=%s".format(compiler, source.encodeComponent);
		if (args.length > 0)
			url ~= "&args=" ~ args.encodeComponent;

		auto isURL= "https://is.gd/create.php?format=simple&url=%s".format(url.encodeComponent);
		output.url = requestHTTP(isURL, (scope req) {
			req.method = HTTPMethod.POST;
		}).bodyReader.readAllUTF8.replace("https://is.gd/", "https://run.dlang.io/is/");
		output.success = true;
		return output;
	}

	GistOutput gist(string source, string compiler, string args)
	{
		import std.format : format;
		import std.uri : encodeComponent;

		GistOutput output;

	    auto res = requestHTTP("https://api.github.com/gists", (scope req) {
			req.headers["Authorization"] = githubToken;
			Json data = Json.emptyObject;
			data["description"] = "Code shared from run.dlang.io.%s".format(args ?
				" Run with '%s'".format(args) : "");
			data["public"] = true;
			Json files = Json.emptyObject;
			files["main.d"] = Json([
				"content": Json(source),
			]);
			data["files"] = files;
			req.method = HTTPMethod.POST;
            req.writeJsonBody(data);
		});
		enforceHTTP(res.statusCode / 100 == 2, HTTPStatus.internalServerError, "GitHub API not available.");
		auto json = res.readJson;
		auto gistId = json["id"].get!string;
        logInfo("Gist created: %s", gistId);
		output.id = gistId;
		output.htmlUrl = json["html_url"].get!string;

		output.url = "/gist/" ~ gistId;
		if (compiler != "dmd") {
			output.url ~= "?compiler=%s".format(compiler);
			if (args.length > 0)
				output.url ~= "&args=" ~ args.encodeComponent;
		} else if (args.length > 0) {
			output.url ~= "?args=" ~ args.encodeComponent;
		}

		return output;
	}

unittest
{
	string source = `void main() {}`;
	ApiV1 api = new ApiV1(null, null, null);
	auto res = api.format(source);
	assert(res == FormatOutput("void main()\n{\n}", false));
}

	SourceOutput getSource(string _language, string _chapter, string _section)
	{
		auto tourData = contentProvider_.getContent(_language, _chapter, _section);
		if (tourData.content == null) {
			throw new HTTPStatusException(404,
				"Couldn't find tour data for chapter '%s', section %d".format(_language, _chapter, _section));
		}

		return SourceOutput(tourData.content.sourceCode);
	}
}

unittest {
	string run1 = `onlineapp.d(6): Error: found '}' when expecting ';' following statement
onlineapp.d(6): Error: found 'EOF' when expecting '}' following compound statement
Failed: ["dmd", "-v", "-o-", "onlineapp.d", "-I."]`;

	auto test2 = ApiV1.RunOutput(run1, false);
	ApiV1.parseErrorsAndWarnings(test2);
	assert(test2.errors.length == 2);
	assert(test2.errors[0].line == 6);
	assert(test2.errors[0].message[0 .. 9] == "found '}'");
	assert(test2.errors[1].line == 6);
	assert(test2.errors[1].message[0 .. 11] == "found 'EOF'");

	string run2 = `dlang-tour ~master: building configuration "executable"...
../.dub/packages/dyaml-0.5.2/source/dyaml/dumper.d(15,8): Deprecation: module std.stream is deprecated - It will be removed from Phobos in October 2016. If you still need it, go to https://github.com/DigitalMars/undeaD
../.dub/packages/dyaml-0.5.2/source/dyaml/emitter.d(21,8): Deprecation: module std.stream is deprecated - It will be removed from Phobos in October 2016. If you still need it, go to https://github.com/DigitalMars/undeaD
../.dub/packages/dyaml-0.5.2/source/dyaml/representer.d(679,8): Deprecation: module std.stream is deprecated - It will be removed from Phobos in October 2016. If you still need it, go to https://github.com/DigitalMars/undeaD
../.dub/packages/dyaml-0.5.2/source/dyaml/loader.d(171,16): Deprecation: module std.stream is deprecated - It will be removed from Phobos in October 2016. If you still need it, go to https://github.com/DigitalMars/undeaD`;
	auto test3 = ApiV1.RunOutput(run2, false);
	ApiV1.parseErrorsAndWarnings(test3);
	assert(test3.warnings.length == 4);
	import std.algorithm: all;
	assert(test3.warnings.all!(x => x.message[0 .. 31] == "module std.stream is deprecated"));
	assert(test3.warnings[0].line == 15);
	assert(test3.warnings[1].line == 21);
	assert(test3.warnings[2].line == 679);
	assert(test3.warnings[3].line == 171);

	auto run3 =
	"\u001B[1md.d(1): \u001B[1;31mError: \u001B[mbasic type expected, not {\n" ~
	"\u001B[1md.d(1): \u001B[1;31mError: \u001B[mfound '{' when expecting ')'\n" ~
	"\u001B[1md.d(1): \u001B[1;31mError: \u001B[msemicolon expected following function declaration\n" ~
	"\u001B[1md.d(1): \u001B[1;31mError: \u001B[munrecognized declaration\n";

	auto test4 = ApiV1.RunOutput(run3, false);
	ApiV1.parseErrorsAndWarnings(test4);

	assert(test4.errors.length == 4);
	assert(test4.errors[0] ==
	       ApiV1.RunOutput.Message(1, "basic type expected, not {"));
	assert(test4.errors[1] ==
	       ApiV1.RunOutput.Message(1, "found '{' when expecting ')'"));
	assert(test4.errors[2] ==
	       ApiV1.RunOutput.Message(1, "semicolon expected following function declaration"));
	assert(test4.errors[3] ==
	       ApiV1.RunOutput.Message(1, "unrecognized declaration"));
}

// remove weird unicode spaces
private string removeUnicodeSpaces(S)(S input) {
	import std.algorithm.iteration : map;
	import std.array : array;
	import std.uni : isSpace;
	// selective import will trigger false-positive deprecation warning
	import std.utf;
	return (cast(dstring) input.map!(c => c.isSpace ? ' ' : c).array).toUTF8;
}

// weird 0xa0 unicode space tokens on android
unittest {
	import std..string : representation;
	ubyte[] helloWorldNormal = [10, 32, 32, 32, 32, 32, 32, 119, 114, 105];
	ubyte[] helloWorldAndroid = [10, 32, 194, 160, 32, 194, 160, 32, 32, 119, 114, 105];
	string res = cast(string) helloWorldAndroid;
	assert(res.removeUnicodeSpaces.representation == helloWorldNormal);
}