/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Message.h>
#include <String.h>


enum {
	FLAG_MANDATORY_FIELD	= 0x01,
	FLAG_LIST_ATTRIBUTE		= 0x02,
	FLAG_DONT_QUOTE			= 0x04,
};


extern const char* __progname;
const char* kCommandName = __progname;


static const char* kUsage =
	"Usage: %s [ <options> ] <optional package description> "
		"[ <package info> ]\n"
	"Converts an .OptionalPackageDescription to a .PackageInfo. If "
		"<package info>\n"
	"is not specified, the output is printed to stdout.\n"
	"Note that the generated .PackageInfo will not be complete. For several\n"
	"fields an empty string will be used, unless specified via an option.\n"
	"The \"provides\" and \"requires\" lists will always be empty, though\n"
	"\n"
	"Options:\n"
	"  -a <arch>        - Use the given architecture string. Default is to "
		"guess from the file name.\n"
	"  -d <description> - Use the given descripton string. Default is to use\n"
	"                     the summary.\n"
	"  -h, --help       - Print this usage info.\n"
	"  -p <packager>    - Use the given packager string. Default is an empty "
		"string.\n"
	"  -s <summary>     - Use the given summary string. Default is an empty "
		"string.\n"
	"  -v <version>     - Use the given version string. Overrides the version\n"
	"                     from the input file.\n"
	"  -V <vendor>      - Use the given vendor string. Default is an empty "
		"string.\n"
;


static void
print_usage_and_exit(bool error)
{
    fprintf(error ? stderr : stdout, kUsage, kCommandName);
    exit(error ? 1 : 0);
}


static const char*
guess_architecture(const char* name)
{
	if (strstr(name, "x86") != NULL) {
		if (strstr(name, "gcc4") != NULL)
			return "x86";

		return "x86_gcc2";
	}

	return NULL;
}


struct OuputWriter {
	OuputWriter(FILE* output, const BMessage& package)
		:
		fOutput(output),
		fPackage(package)
	{
	}

	void WriteAttribute(const char* attributeName, const char* fieldName,
		const char* defaultValue, uint32 flags)
	{
		if (fieldName != NULL) {
			int32 count;
			type_code type;
			if (fPackage.GetInfo(fieldName, &type, &count) != B_OK) {
				if ((flags & FLAG_MANDATORY_FIELD) != 0) {
					fprintf(stderr, "Error: Missing mandatory field \"%s\" in "
						"input file.\n", fieldName);
					exit(1);
				}
				count = 0;
			}

			if (count > 0) {
				if (count == 1) {
					const char* value;
					fPackage.FindString(fieldName, &value);
					_WriteSingleElementAttribute(attributeName, value, flags);
				} else {
					fprintf(fOutput, "\n%s {\n", attributeName);

					for (int32 i = 0; i < count; i++) {
						fprintf(fOutput, "\t");
						const char* value;
						fPackage.FindString(fieldName, i, &value);
						_WriteValue(value, flags);
						fputc('\n', fOutput);
					}

					fputs("}\n", fOutput);
				}

				return;
			}
		}

		// write the default value
		if (defaultValue != NULL)
			_WriteSingleElementAttribute(attributeName, defaultValue, flags);
	}

private:
	void _WriteSingleElementAttribute(const char* attributeName,
		const char* value, uint32 flags)
	{
		fputs(attributeName, fOutput);

		int32 indentation = 16 - (int32)strlen(attributeName);
		if (indentation > 0)
			indentation = (indentation + 3) / 4;
		else
			indentation = 1;

		for (int32 i = 0; i < indentation; i++)
			fputc('\t', fOutput);

		_WriteValue(value, flags);
		fputc('\n',  fOutput);
	}

	void _WriteValue(const char* value, uint32 flags)
	{
		BString escapedValue(value);

		if ((flags & FLAG_DONT_QUOTE) != 0) {
			escapedValue.CharacterEscape("\\\"' \t", '\\');
			fputs(escapedValue.String(), fOutput);
		} else {
			escapedValue.CharacterEscape("\\\"", '\\');
			fprintf(fOutput, "\"%s\"", escapedValue.String());
		}
	}

private:
	FILE*			fOutput;
	const BMessage&	fPackage;
};


int
main(int argc, const char* const* argv)
{
	const char* architecture = NULL;
	const char* version = NULL;
	const char* summary = "";
	const char* description = "";
	const char* packager = "";
	const char* vendor = "";

	while (true) {
		static const struct option kLongOptions[] = {
			{ "help", no_argument, 0, 'h' },
			{ 0, 0, 0, 0 }
		};

		opterr = 0; // don't print errors
		int c = getopt_long(argc, (char**)argv, "+ha:d:p:s:v:V:", kLongOptions,
			NULL);
		if (c == -1)
			break;

		switch (c) {
			case 'a':
				architecture = optarg;
				break;

			case 'd':
				description = optarg;
				break;

			case 'h':
				print_usage_and_exit(false);
				break;

			case 'p':
				packager = optarg;
				break;

			case 's':
				summary = optarg;
				break;

			case 'v':
				version = optarg;
				break;

			case 'V':
				vendor = optarg;
				break;

			default:
				print_usage_and_exit(true);
				break;
		}
	}

	// One or two argument should remain -- the input file and optionally the
	// output file.
	if (optind + 1 != argc && optind + 2 != argc)
		print_usage_and_exit(true);

	const char* opdName = argv[optind++];
	const char* packageInfoName = optind < argc ? argv[optind++] : NULL;

	// guess architecture from the input file name, if not given
	if (architecture == NULL) {
		const char* fileName = strrchr(opdName, '/');
		if (fileName == NULL)
			fileName = opdName;
		else
			fileName++;

		// Try to guess from the file name.
		architecture = guess_architecture(fileName);

		// If we've got nothing yet, try to guess from the file name.
		if (architecture == NULL && fileName != opdName)
			architecture = guess_architecture(opdName);

		// fallback is "any"
		if (architecture == NULL)
			architecture = "any";
	}

	// open the input
	FILE* input = fopen(opdName, "r");
	if (input == NULL) {
		fprintf(stderr, "Failed to open input file \"%s\": %s\n", opdName,
			strerror(errno));
		exit(1);
	}

	// open the output
	FILE* output = packageInfoName != NULL
		? fopen(packageInfoName, "w+") : stdout;
	if (output == NULL) {
		fprintf(stderr, "Failed to open output file \"%s\": %s\n",
			packageInfoName, strerror(errno));
		exit(1);
	}

	// read and parse the input file
	BMessage package;
	BString fieldName;
	BString fieldValue;
	char lineBuffer[LINE_MAX];
	bool seenPackageAttribute = false;

	while (char* line = fgets(lineBuffer, sizeof(lineBuffer), input)) {
		// chop off line break
		size_t lineLen = strlen(line);
		if (lineLen > 0 && line[lineLen - 1] == '\n')
			line[--lineLen] = '\0';

		// flush previous field, if a new field begins, otherwise append
		if (lineLen == 0 || !isspace(line[0])) {
			// new field -- flush the previous one
			if (fieldName.Length() > 0) {
				fieldValue.Trim();
				package.AddString(fieldName.String(), fieldValue);
				fieldName = "";
			}
		} else if (fieldName.Length() > 0) {
			// append to current field
			fieldValue += line;
			continue;
		} else {
			// bogus line -- ignore
			continue;
		}

		if (lineLen == 0)
			continue;

		// parse new field
		char* colon = strchr(line, ':');
		if (colon == NULL) {
			// bogus line -- ignore
			continue;
		}

		fieldName.SetTo(line, colon - line);
		fieldName.Trim();
		if (fieldName.Length() == 0) {
			// invalid field name
			continue;
		}

		fieldValue = colon + 1;

		if (fieldName == "Package") {
			if (seenPackageAttribute) {
				fprintf(stderr, "Duplicate \"Package\" attribute!\n");
				exit(1);
			}

			seenPackageAttribute = true;
		}
	}

	// write the output
	OuputWriter writer(output, package);

	// name
	writer.WriteAttribute("name", "Package", NULL,
		FLAG_MANDATORY_FIELD | FLAG_DONT_QUOTE);

	// version
	writer.WriteAttribute("version", "Version", version, FLAG_DONT_QUOTE);

	// architecture
	fprintf(output, "architecture\t%s\n", architecture);

	// summary
	fprintf(output, "summary\t\t\t\"%s\"\n", summary);

	// description
	if (description != NULL)
		fprintf(output, "description\t\t\"%s\"\n", description);
	else
		fprintf(output, "description\t\t\"%s\"\n", summary);

	// packager
	fprintf(output, "packager\t\t\"%s\"\n", packager);

	// vendor
	fprintf(output, "vendor\t\t\t\"%s\"\n", vendor);

	// copyrights
	writer.WriteAttribute("copyrights", "Copyright", NULL,
		FLAG_MANDATORY_FIELD | FLAG_LIST_ATTRIBUTE);

	// licenses
	writer.WriteAttribute("licenses", "License", NULL, FLAG_LIST_ATTRIBUTE);

	// empty provides
	fprintf(output, "\nprovides {\n}\n");

	// empty requires
	fprintf(output, "\nrequires {\n}\n");

	// URLs
	writer.WriteAttribute("urls", "URL", NULL, FLAG_LIST_ATTRIBUTE);

	// source URLs
	writer.WriteAttribute("source-urls", "SourceURL", NULL,
		FLAG_LIST_ATTRIBUTE);

	return 0;
}