#include <iostream>
#include <string>
#include <algorithm>
#include <utility>
#include <utility>
#include <cstdlib>

#if defined(_WIN32) || defined(__MINGW32__) || defined(__MSYS__)
#define USE_WINDOWS_API 1
#endif

#if defined(USE_WINDOWS_API)
#include <windows.h>
#endif

// For testing on MinGW32 and MSYS
// #undef USE_WINDOWS_API

std::string escape_slashes(const std::string& str)
{
	std::string temp;
	temp.reserve(temp.size() + 16);

	for (size_t i=0; i<str.size(); ++i)
	{
		temp += str[i];
		if (str[i] == '\\')
			temp += '\\';
	}

	return temp;
}

std::string safe_path_unix(const std::string& str, bool c_declare)
{
	std::string the_path(str);

	std::string temp_path;
	temp_path.reserve(the_path.size()+8);

	bool need_quote = the_path.find(' ') != std::string::npos;

	if (need_quote && c_declare) {
		temp_path += "\"\\\"";
	}
	else if (need_quote) {
		temp_path += "\"";
	}

	if (c_declare) {
		temp_path += escape_slashes(the_path);
	}
	else {
		temp_path += the_path;
	}

	if (need_quote && c_declare) {
		temp_path += "\\\"\";";
	}
	else if (need_quote) {
		temp_path += "\"";
	}

	std::swap(the_path, temp_path);

	return the_path;
}

#if defined(USE_WINDOWS_API)
std::string safe_path_windows(const std::string& str, bool c_declare)
{
	std::string the_path(str);
	std::string temp_path;

	// GetShortPathName returns the size including the NULL for this case
	DWORD res1 = GetShortPathName(the_path.c_str(), NULL, 0);
	if (res1 == 0) {
		// Fallback to Unix escaping
		return safe_path_unix(str, c_declare);
	}

	temp_path.resize((size_t)res1);

	// GetShortPathName does not include the NULL for this case
	DWORD res2 = GetShortPathName(the_path.c_str(), &temp_path[0], res1);
	if (res2 == 0) {
		// Fallback to Unix escaping
		return safe_path_unix(str, c_declare);
	}

	// NULL is not included because the buffer was well sized
	temp_path.resize(res2);

	std::swap(the_path, temp_path);

	if (c_declare)
	{
		temp_path = "\"";
		temp_path += escape_slashes(the_path);
		temp_path += "\";";

		std::swap(the_path, temp_path);
	}

	return the_path;
}
#endif

int main(int argc, char* argv[])
{
	std::string the_path;
	bool c_declare = false;
	int index = 1;

	if (argc == 1) {
		std::exit(EXIT_FAILURE);
	}

    // -c option means format as C declare	
	if (argv[index][0] == '-' && argv[index][1] == 'c') {
		c_declare = true;
		index++;
	}

	// piece paths back together
	for (int i=index; i<argc; ++i) {
		if (i != index)
			the_path += ' ';

		the_path += argv[i];
	}

#if defined(USE_WINDOWS_API)
	the_path = safe_path_windows(the_path, c_declare);
#else
	the_path = safe_path_unix(the_path, c_declare);
#endif

	std::cout << the_path << std::endl;

	return EXIT_SUCCESS;
}