/*
 * Copyright 2005, Haiku Inc.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *		Jonas Sundström, jonas@kirilla.com
 *		Axel Dörfler, axeld@pinc-software.de.
 */


#include <Application.h>
#include <Clipboard.h>
#include <File.h>
#include <FindDirectory.h>
#include <Path.h>
#include <String.h>

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


extern const char *__progname;
static const char *kProgramName = __progname;

static int sExitValue = EXIT_SUCCESS;


class ClipboardApp : public BApplication {
	public:
		ClipboardApp(void);
		virtual ~ClipboardApp(void);

		virtual void ReadyToRun(void);
		virtual void ArgvReceived(int32 argc, char **argv);

	private:
		void Usage(void);
		status_t Load(const char *path);
		status_t Save(const char *path);
		status_t Copy(const char *string);
		status_t Clear(void);
		status_t Print(bool debug);

		bool fGotArguments;
};


ClipboardApp::ClipboardApp(void)
	: BApplication("application/x-vnd.haiku-clipboard"),
	fGotArguments(false)
{
}


ClipboardApp::~ClipboardApp(void)
{
}


void
ClipboardApp::ArgvReceived(int32 argc, char **argv)
{
	status_t status = B_OK;

	static struct option const kLongOptions[] = {
		{"load", required_argument, 0, 'l'},
		{"save", required_argument, 0, 's'},
		{"copy", required_argument, 0, 'c'},
		{"clear", no_argument, 0, 'r'},
		{"stdin", no_argument, 0, 'i'},
		{"print", no_argument, 0, 'p'},
		{"debug", no_argument, 0, 'd'},
		{"help", no_argument, 0, 'h'},
		{NULL}
	};

	int c;
	while ((c = getopt_long(argc, argv, "l:s:o:c:ripdh", kLongOptions, NULL))
		!= -1) {
		switch (c) {
			case 'l':
				status = Load(optarg);
				break;
			case 's':
			case 'o':
				status = Save(optarg);
				break;
			case 'c':
				status = Copy(optarg);
				break;
			case 'r':
				status = Clear();
				break;
			case 'i':
				status = Copy(NULL);
				break;
			case 'p':
				status = Print(false);
				break;
			case 'd':
				status = Print(true);
				break;
			case 0:
				break;
			case 'h':
				// help text is printed in ReadyToRun()
				return;
			default:
				status = B_ERROR;
				break;
		}
	}

	if (status == B_OK)
		fGotArguments =	true;
	else
		sExitValue = EXIT_FAILURE;
}


void
ClipboardApp::ReadyToRun(void)
{
	if (fGotArguments == false)
		Usage();

	PostMessage(B_QUIT_REQUESTED);
}


void
ClipboardApp::Usage(void)
{
	printf("usage: %s [-olcirpd]\n"
		"  -s, --save=file\tSave clipboard to file (flattened BMessage)\n"
		"  -o\t\t\tthe same\n" // ToDo: (\"-\" for standard output/input)\n"
		"  -l, --load=file\tLoad clipboard from file (flattened BMessage)\n"
		"  -c, --copy=string\tPut the given string on the clipboard\n"
		"  -i, --stdin\t\tLoad clipboard with string from standard input\n\n"

		"  -r, --clear\t\tRemove all contents from clipboard\n\n"

		"  -p, --print\t\tPrint clipboard to standard output\n"
		"  -d, --debug\t\tPrint clipboard message to stdout\n\n"

		"  -h, --help\t\tDisplay this help and exit\n",
		kProgramName);
}


status_t
ClipboardApp::Load(const char *path)
{
	status_t status = B_OK;
	BFile file;

	status = file.SetTo(path, B_READ_ONLY);
	if (status != B_OK) {
		fprintf(stderr, "%s: Could not open file: %s\n", kProgramName,
			strerror(status));
		return status;
	}

	// get BMessage from file
	BMessage clipFromFile;
	status = clipFromFile.Unflatten(&file);
	if (status != B_OK) {
		fprintf(stderr, "%s: Could not read clip: %s\n", kProgramName,
			strerror(status));
		return status;
	}

	// load clip into clipboard
	if (!be_clipboard->Lock()) {
		fprintf(stderr, "%s: could not lock clipboard.\n", kProgramName);
		return B_ERROR;
	}

	be_clipboard->Clear();

	BMessage *clip = be_clipboard->Data();
	*clip = clipFromFile;

	status = be_clipboard->Commit();
	if (status != B_OK) {
		fprintf(stderr, "%s: could not commit data to clipboard.\n",
			kProgramName);
		be_clipboard->Unlock();
		return status;
	}

	be_clipboard->Unlock();
	return B_OK;
}


status_t
ClipboardApp::Save(const char *path)
{
	status_t status = B_OK;
	BFile file;

	status = file.SetTo(path, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
	if (status != B_OK) {
		fprintf(stderr, "%s: Could not create file: %s\n", kProgramName,
			strerror(status));
		return status;
	}

	// get clip
	if (!be_clipboard->Lock()) {
		fprintf(stderr, "%s: could not lock clipboard.\n", kProgramName);
		return B_ERROR;
	}

	BMessage *clip = be_clipboard->Data();

	be_clipboard->Unlock();

	// flatten clip to file
	status = clip->Flatten(&file);
	if (status != B_OK) {
		fprintf(stderr, "%s: Could not write data: %s\n", kProgramName,
			strerror(status));
		return status;
	}

	return B_OK;
}


status_t
ClipboardApp::Copy(const char *string)
{
	status_t status = B_OK;
	BString inputString;

	if (string == NULL) {
		// read from standard input
		int c;
		while ((c = fgetc(stdin)) != EOF) {
			inputString += (char)c;
		}

		string = inputString.String();
	}

	// get clipboard BMessage

	if (be_clipboard->Lock()) {
		be_clipboard->Clear();

		BMessage *clip = be_clipboard->Data();

		// add data to clipboard
		clip->AddData("text/plain", B_MIME_TYPE, string, strlen(string));

		status = be_clipboard->Commit();
		if (status != B_OK) {
			fprintf(stderr, "%s: could not commit data to clipboard.\n",
				kProgramName);
			be_clipboard->Unlock();
			return status;
		}

		be_clipboard->Unlock();
	} else {
		fprintf(stderr, "%s: could not lock clipboard.\n", kProgramName);
		return B_ERROR;
	}

	return B_OK;
}


status_t
ClipboardApp::Clear(void)
{
	status_t status = B_OK;

	if (!be_clipboard->Lock()) {
		fprintf(stderr, "%s: could not lock clipboard.\n", kProgramName);
		return B_ERROR;
	}

	be_clipboard->Clear();

	status = be_clipboard->Commit();
	if (status != B_OK) {
		fprintf(stderr, "%s: could not clear clipboard.\n", kProgramName);
		be_clipboard->Unlock();
		return status;
	}

	be_clipboard->Unlock();
	return B_OK;
}


status_t
ClipboardApp::Print(bool debug)
{
	// get clip & print contents
	// (or the entire clip, in case of --debug)

	if (!be_clipboard->Lock()) {
		fprintf(stderr, "%s: could not lock clipboard.\n", kProgramName);
		return B_ERROR;
	}

	BMessage *clip = be_clipboard->Data();

	if (debug)
		clip->PrintToStream();
	else {
		const char * textBuffer;
		ssize_t textLength;
		clip->FindData("text/plain", B_MIME_TYPE, (const void **)&textBuffer,
			&textLength);

		if (textBuffer != NULL && textLength > 0) {
			BString textString(textBuffer, textLength);
			printf("%s\n", textString.String());
		}
	}

	be_clipboard->Unlock();
	return B_OK;
}


//	#pragma mark -


int
main()
{
	ClipboardApp clip_app;
	clip_app.Run();

	return sExitValue;
}