// Copyright Epic Games, Inc. All Rights Reserved.

#include <zenutil/commandlineoptions.h>

#include <filesystem>
#if ZEN_WITH_TESTS
#	include <zencore/testing.h>
#endif	// ZEN_WITH_TESTS

void
cxxopts::values::parse_value(const std::string& text, std::filesystem::path& value)
{
	value = zen::StringToPath(text);
}

namespace zen {

std::vector<std::string>
ParseCommandLine(std::string_view CommandLine)
{
	auto IsWhitespaceOrEnd = [](std::string_view CommandLine, std::string::size_type Pos) {
		if (Pos == CommandLine.length())
		{
			return true;
		}
		if (CommandLine[Pos] == ' ')
		{
			return true;
		}
		return false;
	};

	bool IsParsingArg = false;
	bool IsInQuote	  = false;

	std::string::size_type	 Pos	  = 0;
	std::string::size_type	 ArgStart = 0;
	std::vector<std::string> Args;
	while (Pos < CommandLine.length())
	{
		if (IsInQuote)
		{
			if (CommandLine[Pos] == '"' && IsWhitespaceOrEnd(CommandLine, Pos + 1))
			{
				Args.push_back(std::string(CommandLine.substr(ArgStart, Pos - ArgStart + 1)));
				Pos++;
				IsInQuote	 = false;
				IsParsingArg = false;
			}
			else
			{
				Pos++;
			}
		}
		else if (IsParsingArg)
		{
			ZEN_ASSERT(Pos > ArgStart);
			if (CommandLine[Pos] == ' ')
			{
				Args.push_back(std::string(CommandLine.substr(ArgStart, Pos - ArgStart)));
				Pos++;
				IsParsingArg = false;
			}
			else if (CommandLine[Pos] == '"')
			{
				IsInQuote = true;
				Pos++;
			}
			else
			{
				Pos++;
			}
		}
		else if (CommandLine[Pos] == '"')
		{
			IsInQuote	 = true;
			IsParsingArg = true;
			ArgStart	 = Pos;
			Pos++;
		}
		else if (CommandLine[Pos] != ' ')
		{
			IsParsingArg = true;
			ArgStart	 = Pos;
			Pos++;
		}
		else
		{
			Pos++;
		}
	}
	if (IsParsingArg)
	{
		ZEN_ASSERT(Pos > ArgStart);
		Args.push_back(std::string(CommandLine.substr(ArgStart)));
	}

	return Args;
}

std::vector<char*>
StripCommandlineQuotes(std::vector<std::string>& InOutArgs)
{
	std::vector<char*> RawArgs;
	RawArgs.reserve(InOutArgs.size());
	for (std::string& Arg : InOutArgs)
	{
		std::string::size_type EscapedQuotePos = Arg.find("\\\"", 1);
		while (EscapedQuotePos != std::string::npos && Arg.rfind('\"', EscapedQuotePos - 1) != std::string::npos)
		{
			Arg.erase(EscapedQuotePos, 1);
			EscapedQuotePos = Arg.find("\\\"", EscapedQuotePos);
		}

		if (Arg.starts_with("\""))
		{
			if (Arg.find('"', 1) == Arg.length() - 1)
			{
				if (Arg.find(' ', 1) == std::string::npos)
				{
					Arg = Arg.substr(1, Arg.length() - 2);
				}
			}
		}
		RawArgs.push_back(const_cast<char*>(Arg.c_str()));
	}
	return RawArgs;
}

void
MakeSafeAbsolutePathÍnPlace(std::filesystem::path& Path)
{
	if (!Path.empty())
	{
		std::filesystem::path AbsolutePath = std::filesystem::absolute(Path).make_preferred();
#if ZEN_PLATFORM_WINDOWS
		const std::string_view Prefix = "\\\\?\\";
		const std::u8string	   PrefixU8(Prefix.begin(), Prefix.end());
		std::u8string		   PathString = AbsolutePath.u8string();
		if (!PathString.empty() && !PathString.starts_with(PrefixU8))
		{
			PathString.insert(0, PrefixU8);
			Path = PathString;
		}
#endif	// ZEN_PLATFORM_WINDOWS
	}
}

std::filesystem::path
MakeSafeAbsolutePath(const std::filesystem::path& Path)
{
	std::filesystem::path Tmp(Path);
	MakeSafeAbsolutePathÍnPlace(Tmp);
	return Tmp;
}

std::filesystem::path
StringToPath(const std::string_view& Path)
{
	std::string_view UnquotedPath = RemoveQuotes(Path);

	if (UnquotedPath.ends_with('/') || UnquotedPath.ends_with('\\') || UnquotedPath.ends_with(std::filesystem::path::preferred_separator))
	{
		UnquotedPath = UnquotedPath.substr(0, UnquotedPath.length() - 1);
	}

	return std::filesystem::path(UnquotedPath).make_preferred();
}

std::string_view
RemoveQuotes(const std::string_view& Arg)
{
	if (Arg.length() > 2)
	{
		if (Arg[0] == '"' && Arg[Arg.length() - 1] == '"')
		{
			return Arg.substr(1, Arg.length() - 2);
		}
	}
	return Arg;
}

#if ZEN_WITH_TESTS

void
commandlineoptions_forcelink()
{
}

TEST_CASE("CommandLine")
{
	std::vector<std::string> v1 = ParseCommandLine("c:\\my\\exe.exe \"quoted arg\" \"one\",two,\"three\\\"");
	CHECK_EQ(v1[0], "c:\\my\\exe.exe");
	CHECK_EQ(v1[1], "\"quoted arg\"");
	CHECK_EQ(v1[2], "\"one\",two,\"three\\\"");

	std::vector<std::string> v2 = ParseCommandLine(
		"--tracehost 127.0.0.1 builds download --url=https://jupiter.devtools.epicgames.com --namespace=ue.oplog "
		"--bucket=citysample.packaged-build.fortnite-main.windows \"c:\\just\\a\\path\" "
		"--access-token-path=\"C:\\Users\\dan.engelbrecht\\jupiter-token.json\" \"D:\\Dev\\Spaced Folder\\Target\\\" "
		"--alt-path=\"D:\\Dev\\Spaced Folder2\\Target\\\" 07dn23ifiwesnvoasjncasab --build-part-name win64,linux,ps5");

	std::vector<char*> v2Stripped = StripCommandlineQuotes(v2);
	CHECK_EQ(v2Stripped[0], std::string("--tracehost"));
	CHECK_EQ(v2Stripped[1], std::string("127.0.0.1"));
	CHECK_EQ(v2Stripped[2], std::string("builds"));
	CHECK_EQ(v2Stripped[3], std::string("download"));
	CHECK_EQ(v2Stripped[4], std::string("--url=https://jupiter.devtools.epicgames.com"));
	CHECK_EQ(v2Stripped[5], std::string("--namespace=ue.oplog"));
	CHECK_EQ(v2Stripped[6], std::string("--bucket=citysample.packaged-build.fortnite-main.windows"));
	CHECK_EQ(v2Stripped[7], std::string("c:\\just\\a\\path"));
	CHECK_EQ(v2Stripped[8], std::string("--access-token-path=\"C:\\Users\\dan.engelbrecht\\jupiter-token.json\""));
	CHECK_EQ(v2Stripped[9], std::string("\"D:\\Dev\\Spaced Folder\\Target\""));
	CHECK_EQ(v2Stripped[10], std::string("--alt-path=\"D:\\Dev\\Spaced Folder2\\Target\""));
	CHECK_EQ(v2Stripped[11], std::string("07dn23ifiwesnvoasjncasab"));
	CHECK_EQ(v2Stripped[12], std::string("--build-part-name"));
	CHECK_EQ(v2Stripped[13], std::string("win64,linux,ps5"));
}

#endif
}  // namespace zen