/*
 * Copyright 2009-2016, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2011-2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


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

#include <new>

#include <Application.h>
#include <Entry.h>
#include <Message.h>
#include <ObjectList.h>
#include <Path.h>

#include <ArgumentVector.h>
#include <AutoDeleter.h>
#include <AutoLocker.h>

#include "AppMessageCodes.h"
#include "CommandLineUserInterface.h"
#include "ConnectionConfigHandlerRoster.h"
#include "ConnectionConfigWindow.h"
#include "DebuggerGlobals.h"
#include "DebuggerSettingsManager.h"
#include "DebuggerUiSettingsFactory.h"
#include "ElfFile.h"
#include "GraphicalUserInterface.h"
#include "MessageCodes.h"
#include "ReportUserInterface.h"
#include "SignalSet.h"
#include "StartTeamWindow.h"
#include "TargetHostInterface.h"
#include "TargetHostInterfaceRoster.h"
#include "TeamDebugger.h"
#include "TeamsWindow.h"
#include "ValueHandlerRoster.h"


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

static const char* const kDebuggerSignature
	= "application/x-vnd.Haiku-Debugger";


static const char* const kUsage =
	"Usage: %s [ <options> ]\n"
	"       %s [ <options> ] <command line>\n"
	"       %s [ <options> ] --team <team>\n"
	"       %s [ <options> ] --thread <thread>\n"
	"       %s [ <options> ] --core <file>\n"
	"\n"
	"The first form starts the debugger displaying a requester to choose a\n"
	"running team to debug respectively to specify the program to run and\n"
	"debug.\n"
	"\n"
	"The second form runs the given command line and attaches the debugger to\n"
	"the new team. Unless specified otherwise the program will be stopped at\n"
	"the beginning of its main() function.\n"
	"\n"
	"The third and fourth forms attach the debugger to a running team. The\n"
	"fourth form additionally stops the specified thread.\n"
	"\n"
	"The fifth form loads a core file.\n"
	"\n"
	"Options:\n"
	"  -h, --help        - Print this usage info and exit.\n"
	"  -c, --cli         - Use command line user interface\n"
	"  -s, --save-report - Save crash report for the targetted team and exit.\n"
	"                      Implies --cli.\n"
;


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


struct Options {
	int					commandLineArgc;
	const char* const*	commandLineArgv;
	team_id				team;
	thread_id			thread;
	bool				useCLI;
	bool				saveReport;
	const char*			reportPath;
	const char*			coreFilePath;

	Options()
		:
		commandLineArgc(0),
		commandLineArgv(NULL),
		team(-1),
		thread(-1),
		useCLI(false),
		saveReport(false),
		reportPath(NULL),
		coreFilePath(NULL)
	{
	}
};


static void
set_debugger_options_from_options(TeamDebuggerOptions& _debuggerOptions,
	const Options& options)
{
	_debuggerOptions.commandLineArgc = options.commandLineArgc;
	_debuggerOptions.commandLineArgv = options.commandLineArgv;
	_debuggerOptions.team = options.team;
	_debuggerOptions.thread = options.thread;
	_debuggerOptions.coreFilePath = options.coreFilePath;

	if (options.coreFilePath != NULL)
		_debuggerOptions.requestType = TEAM_DEBUGGER_REQUEST_LOAD_CORE;
	else if (options.commandLineArgc != 0)
		_debuggerOptions.requestType = TEAM_DEBUGGER_REQUEST_CREATE;
	else
		_debuggerOptions.requestType = TEAM_DEBUGGER_REQUEST_ATTACH;
}



static bool
parse_arguments(int argc, const char* const* argv, bool noOutput,
	Options& options)
{
	optind = 1;

	while (true) {
		static struct option sLongOptions[] = {
			{ "help", no_argument, 0, 'h' },
			{ "cli", no_argument, 0, 'c' },
			{ "save-report", optional_argument, 0, 's' },
			{ "team", required_argument, 0, 't' },
			{ "thread", required_argument, 0, 'T' },
			{ "core", required_argument, 0, 'C' },
			{ 0, 0, 0, 0 }
		};

		opterr = 0; // don't print errors

		int c = getopt_long(argc, (char**)argv, "+chs", sLongOptions, NULL);
		if (c == -1)
			break;

		switch (c) {
			case 'c':
				options.useCLI = true;
				break;

			case 'C':
				options.coreFilePath = optarg;
				break;

			case 'h':
				if (noOutput)
					return false;
				print_usage_and_exit(false);
				break;

			case 's':
			{
				options.saveReport = true;
				options.reportPath = optarg;
				break;
			}

			case 't':
			{
				options.team = strtol(optarg, NULL, 0);
				if (options.team <= 0) {
					if (noOutput)
						return false;
					print_usage_and_exit(true);
				}
				break;
			}

			case 'T':
			{
				options.thread = strtol(optarg, NULL, 0);
				if (options.thread <= 0) {
					if (noOutput)
						return false;
					print_usage_and_exit(true);
				}
				break;
			}

			default:
				if (noOutput)
					return false;
				print_usage_and_exit(true);
				break;
		}
	}

	if (optind < argc) {
		options.commandLineArgc = argc - optind;
		options.commandLineArgv = argv + optind;
	}

	int exclusiveParams = 0;
	if (options.team > 0)
		exclusiveParams++;
	if (options.thread > 0)
		exclusiveParams++;
	if (options.commandLineArgc > 0)
		exclusiveParams++;

	if (exclusiveParams == 0) {
		return true;
	} else if (exclusiveParams != 1) {
		if (noOutput)
			return false;
		print_usage_and_exit(true);
	}

	return true;
}


// #pragma mark - Debugger application class


class Debugger : public BApplication,
	private TargetHostInterfaceRoster::Listener {
public:
								Debugger();
								~Debugger();

			status_t			Init();
	virtual void 				MessageReceived(BMessage* message);
	virtual void 				ReadyToRun();
	virtual void 				ArgvReceived(int32 argc, char** argv);
	virtual	void				RefsReceived(BMessage* message);

private:
	virtual bool 				QuitRequested();
	virtual void 				Quit();

	// TargetHostInterfaceRoster::Listener
	virtual	void				TeamDebuggerCountChanged(int32 count);

private:
			status_t			_ShowStartTeamWindow(TargetHostInterface* interface);
			status_t			_StartNewTeam(TargetHostInterface* interface,
									const char* teamPath, const char* args);
			status_t			_HandleOptions(const Options& options);

private:
			DebuggerSettingsManager fSettingsManager;
			ConnectionConfigWindow* fConnectionWindow;
			TeamsWindow*		fTeamsWindow;
			StartTeamWindow*	fStartTeamWindow;
};


// #pragma mark - CliDebugger


class CliDebugger : private TargetHostInterfaceRoster::Listener {
public:
								CliDebugger();
								~CliDebugger();

			bool				Run(const Options& options);
};


class ReportDebugger : private TargetHostInterfaceRoster::Listener  {
public:
								ReportDebugger();
								~ReportDebugger();
			bool				Run(const Options& options);
};


// #pragma mark - Debugger application class


Debugger::Debugger()
	:
	BApplication(kDebuggerSignature),
	TargetHostInterfaceRoster::Listener(),
	fConnectionWindow(NULL),
	fTeamsWindow(NULL),
	fStartTeamWindow(NULL)
{
}


Debugger::~Debugger()
{
	DebuggerUiSettingsFactory::DeleteDefault();
	ValueHandlerRoster::DeleteDefault();
	ConnectionConfigHandlerRoster::DeleteDefault();

	debugger_global_uninit();
}


status_t
Debugger::Init()
{
	status_t error = debugger_global_init(this);
	if (error != B_OK)
		return error;

	error = DebuggerUiSettingsFactory::CreateDefault();
	if (error != B_OK)
		return error;

	error = ValueHandlerRoster::CreateDefault();
	if (error != B_OK)
		return error;

	error = ConnectionConfigHandlerRoster::CreateDefault();
	if (error != B_OK)
		return error;

	return fSettingsManager.Init(DebuggerUiSettingsFactory::Default());
}


void
Debugger::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case MSG_SHOW_TEAMS_WINDOW:
		{
			if (fTeamsWindow) {
				fTeamsWindow->Activate(true);
				break;
			}

			try {
				fTeamsWindow = TeamsWindow::Create(&fSettingsManager);
				if (fTeamsWindow != NULL)
					fTeamsWindow->Show();
			} catch (...) {
				// TODO: Notify the user!
				fprintf(stderr, "Error: Failed to create Teams window\n");
			}
			break;
		}
		case MSG_TEAMS_WINDOW_CLOSED:
		{
			fTeamsWindow = NULL;
			Quit();
			break;
		}
		case MSG_SHOW_START_TEAM_WINDOW:
		{
			TargetHostInterface* hostInterface;
			if (message->FindPointer("interface",
					reinterpret_cast<void**>(&hostInterface)) != B_OK) {
				// if an interface isn't explicitly supplied, fall back to
				// the default local interface.
				hostInterface = TargetHostInterfaceRoster::Default()
					->ActiveInterfaceAt(0);
			}

			_ShowStartTeamWindow(hostInterface);
			break;
		}
		case MSG_START_TEAM_WINDOW_CLOSED:
		{
			fStartTeamWindow = NULL;
			Quit();
			break;
		}
		case MSG_SHOW_CONNECTION_CONFIG_WINDOW:
		{
			if (fConnectionWindow != NULL) {
				fConnectionWindow->Activate(true);
				break;
			}

			try {
				fConnectionWindow = ConnectionConfigWindow::Create();
				if (fConnectionWindow != NULL)
					fConnectionWindow->Show();
			} catch (...) {
				// TODO: Notify the user!
				fprintf(stderr, "Error: Failed to create Teams window\n");
			}
			break;
		}
		case MSG_CONNECTION_CONFIG_WINDOW_CLOSED:
		{
			fConnectionWindow = NULL;
			break;
		}
		case MSG_DEBUG_THIS_TEAM:
		{
			team_id teamID;
			if (message->FindInt32("team", &teamID) != B_OK)
				break;

			TargetHostInterface* interface = NULL;
			if (message->FindPointer("interface", reinterpret_cast<void**>(
					&interface)) != B_OK) {
				// No interface specified: presume local.
				TargetHostInterfaceRoster* roster = TargetHostInterfaceRoster::Default();
				for (int32 i = 0; i < roster->CountActiveInterfaces(); i++) {
					TargetHostInterface* iface = roster->ActiveInterfaceAt(i);
					if (iface->IsLocal()) {
						interface = iface;
						break;
					}
				}
				if (interface == NULL)
					break;
			}

			TeamDebuggerOptions options;
			options.requestType = TEAM_DEBUGGER_REQUEST_ATTACH;
			options.settingsManager = &fSettingsManager;
			options.team = teamID;
			options.userInterface = new(std::nothrow) GraphicalUserInterface;
			if (options.userInterface == NULL) {
				// TODO: notify user.
				fprintf(stderr, "Error: Failed to create GUI\n");
				break;
			}
			BReference<UserInterface> uiReference(options.userInterface, true);
			status_t error = interface->StartTeamDebugger(options);
			if (error != B_OK) {
				// TODO: notify user.
				fprintf(stderr, "Error: Failed to start team debugger\n");
			}
			break;
		}
		case MSG_START_NEW_TEAM:
		{
			TargetHostInterface* interface;
			if (message->FindPointer("interface", reinterpret_cast<void**>(
					&interface)) != B_OK) {
				break;
			}

			const char* teamPath = NULL;
			const char* args = NULL;

			message->FindString("path", &teamPath);
			message->FindString("arguments", &args);

			status_t result = _StartNewTeam(interface, teamPath, args);
			BMessage reply;
			reply.AddInt32("status", result);
			message->SendReply(&reply);
			break;
		}
		case MSG_LOAD_CORE_TEAM:
		{
			TargetHostInterface* interface;
			if (message->FindPointer("interface", reinterpret_cast<void**>(
					&interface)) != B_OK) {
				break;
			}

			entry_ref ref;
			if (message->FindRef("core", &ref) != B_OK)
				break;

			BPath path(&ref);
			if (path.InitCheck() != B_OK)
				break;

			Options options;
			options.coreFilePath = path.Path();
			_HandleOptions(options);
			break;
		}
		default:
			BApplication::MessageReceived(message);
			break;
	}
}


void
Debugger::ReadyToRun()
{
	TargetHostInterfaceRoster* roster = TargetHostInterfaceRoster::Default();
	AutoLocker<TargetHostInterfaceRoster> lock(roster);
	if (roster->CountRunningTeamDebuggers() == 0 && fStartTeamWindow == NULL)
		PostMessage(MSG_SHOW_TEAMS_WINDOW);
}


void
Debugger::ArgvReceived(int32 argc, char** argv)
{
	Options options;
	if (!parse_arguments(argc, argv, true, options)) {
		printf("Debugger::ArgvReceived(): parsing args failed!\n");
		return;
	}

	_HandleOptions(options);
}


void
Debugger::RefsReceived(BMessage* message)
{
	// iterate through the refs and handle the files we can handle
	entry_ref ref;
	for (int32 i = 0; message->FindRef("refs", i, &ref) == B_OK; i++) {
		BPath path;
		if (path.SetTo(&ref) != B_OK)
			continue;

		ElfFile elfFile;
		if (elfFile.Init(path.Path()) != B_OK)
			continue;

		switch (elfFile.Type()) {
			case ET_CORE:
			{
				// open the core file
				Options options;
				options.coreFilePath = path.Path();
				_HandleOptions(options);
				break;
			}
			case ET_EXEC:
			case ET_DYN:
			{
				// ask the user for arguments to pass to the executable
				TargetHostInterface* hostInterface = TargetHostInterfaceRoster::Default()
						->ActiveInterfaceAt(0);
				status_t error = _ShowStartTeamWindow(hostInterface);
				if (error != B_OK)
					continue;

				BMessage message(MSG_SET_TEAM_PATH);
				message.AddRef("refs", &ref);
				fStartTeamWindow->PostMessage(&message);
				break;
			}
		}
	}
}


bool
Debugger::QuitRequested()
{
	// NOTE: The default implementation will just ask all windows'
	// QuitRequested() hooks. This in turn will ask the TeamWindows.
	// For now, this is what we want. If we have more windows later,
	// like the global TeamsWindow, then we want to just ask the
	// TeamDebuggers, the TeamsWindow should of course not go away already
	// if one or more TeamDebuggers want to stay later. There are multiple
	// ways how to do this. For example, TeamDebugger could get a
	// QuitRequested() hook or the TeamsWindow and other global windows
	// could always return false in their QuitRequested().
	return BApplication::QuitRequested();
		// TODO: This is ugly. The team debuggers own the windows, not the
		// other way around.
}

void
Debugger::Quit()
{
	TargetHostInterfaceRoster* roster = TargetHostInterfaceRoster::Default();
	AutoLocker<TargetHostInterfaceRoster> lock(roster);
	// don't quit before all team debuggers have been quit
	if (roster->CountRunningTeamDebuggers() == 0 && fTeamsWindow == NULL)
		BApplication::Quit();
}


void
Debugger::TeamDebuggerCountChanged(int32 count)
{
	if (count == 0) {
		AutoLocker<Debugger> lock(this);
		Quit();
	}
}


status_t
Debugger::_ShowStartTeamWindow(TargetHostInterface* interface)
{
	if (fStartTeamWindow == NULL) {
		TargetHostInterface* hostInterface = TargetHostInterfaceRoster::Default()
			->ActiveInterfaceAt(0);
		fStartTeamWindow = StartTeamWindow::Create(hostInterface);
		if (fStartTeamWindow == NULL)
			return B_NO_MEMORY;
		fStartTeamWindow->Show();
	} else
		fStartTeamWindow->Activate();

	return B_OK;
}


status_t
Debugger::_StartNewTeam(TargetHostInterface* interface, const char* path,
	const char* args)
{
	if (path == NULL)
		return B_BAD_VALUE;

	BString data;
	data.SetToFormat("\"%s\" %s", path, args);
	if (data.Length() == 0)
		return B_NO_MEMORY;

	ArgumentVector argVector;
	argVector.Parse(data.String());

	TeamDebuggerOptions options;
	options.requestType = TEAM_DEBUGGER_REQUEST_CREATE;
	options.settingsManager = &fSettingsManager;
	options.userInterface = new(std::nothrow) GraphicalUserInterface;
	if (options.userInterface == NULL)
		return B_NO_MEMORY;
	BReference<UserInterface> uiReference(options.userInterface, true);
	options.commandLineArgc = argVector.ArgumentCount();
	if (options.commandLineArgc <= 0)
		return B_BAD_VALUE;

	char** argv = argVector.DetachArguments();

	options.commandLineArgv = argv;
	MemoryDeleter deleter(argv);

	status_t error = interface->StartTeamDebugger(options);
	if (error == B_OK) {
		deleter.Detach();
	}

	return error;
}


status_t
Debugger::_HandleOptions(const Options& options)
{
	TeamDebuggerOptions debuggerOptions;
	set_debugger_options_from_options(debuggerOptions, options);
	debuggerOptions.settingsManager = &fSettingsManager;
	debuggerOptions.userInterface = new(std::nothrow) GraphicalUserInterface;
	if (debuggerOptions.userInterface == NULL)
		return B_NO_MEMORY;
	BReference<UserInterface> uiReference(debuggerOptions.userInterface, true);
	TargetHostInterface* hostInterface
		= TargetHostInterfaceRoster::Default()->ActiveInterfaceAt(0);
	return hostInterface->StartTeamDebugger(debuggerOptions);
}


// #pragma mark - CliDebugger


CliDebugger::CliDebugger()
{
}


CliDebugger::~CliDebugger()
{
	DebuggerUiSettingsFactory::DeleteDefault();
	debugger_global_uninit();
}


bool
CliDebugger::Run(const Options& options)
{
	if (options.commandLineArgc == 0
		&& options.team < 0
		&& options.thread < 0
		&& options.coreFilePath == NULL) {
		fprintf(stderr, "No target specified to debug\n");
		return false;
	}

	// Block SIGINT, in this thread so all threads created by it inherit the
	// a block mask with the signal blocked. In the input loop the signal will
	// be unblocked again.
	SignalSet(SIGINT).BlockInCurrentThread();

	// initialize global objects and settings manager
	status_t error = debugger_global_init(this);
	if (error != B_OK) {
		fprintf(stderr, "Error: Global initialization failed: %s\n",
			strerror(error));
		return false;
	}

	error = DebuggerUiSettingsFactory::CreateDefault();
	if (error != B_OK) {
		fprintf(stderr, "Error: Failed to create default settings factory: "
			"%s\n",	strerror(error));
		return false;
	}


	DebuggerSettingsManager settingsManager;
	error = settingsManager.Init(DebuggerUiSettingsFactory::Default());
	if (error != B_OK) {
		fprintf(stderr, "Error: Settings manager initialization failed: "
			"%s\n", strerror(error));
		return false;
	}

	// create the command line UI
	CommandLineUserInterface* userInterface
		= new(std::nothrow) CommandLineUserInterface();
	if (userInterface == NULL) {
		fprintf(stderr, "Error: Out of memory!\n");
		return false;
	}
	BReference<UserInterface> userInterfaceReference(userInterface, true);

	// TODO: once we support specifying a remote interface via command line
	// args, this needs to be adjusted. For now, always assume actions
	// are being taken via the local interface.
	TargetHostInterface* hostInterface
		= TargetHostInterfaceRoster::Default()->ActiveInterfaceAt(0);

	TeamDebuggerOptions debuggerOptions;
	set_debugger_options_from_options(debuggerOptions, options);
	debuggerOptions.userInterface = userInterface;
	debuggerOptions.settingsManager = &settingsManager;
	error = hostInterface->StartTeamDebugger(debuggerOptions);
	if (error != B_OK)
		return false;

	TeamDebugger* teamDebugger = hostInterface->TeamDebuggerAt(0);
	thread_id teamDebuggerThread = teamDebugger->Thread();

	// run the input loop
	userInterface->Run();

	// wait for the team debugger thread to terminate
	wait_for_thread(teamDebuggerThread, NULL);

	return true;
}


// #pragma mark - ReportDebugger


ReportDebugger::ReportDebugger()
{
}


ReportDebugger::~ReportDebugger()
{
	debugger_global_uninit();
}


bool
ReportDebugger::Run(const Options& options)
{
	// initialize global objects and settings manager
	status_t error = debugger_global_init(this);
	if (error != B_OK) {
		fprintf(stderr, "Error: Global initialization failed: %s\n",
			strerror(error));
		return false;
	}

	// create the report UI
	ReportUserInterface* userInterface
		= new(std::nothrow) ReportUserInterface(options.thread, options.reportPath);
	if (userInterface == NULL) {
		fprintf(stderr, "Error: Out of memory!\n");
		return false;
	}
	BReference<UserInterface> userInterfaceReference(userInterface, true);

	TargetHostInterface* hostInterface
		= TargetHostInterfaceRoster::Default()->ActiveInterfaceAt(0);

	TeamDebuggerOptions debuggerOptions;
	set_debugger_options_from_options(debuggerOptions, options);
	debuggerOptions.userInterface = userInterface;
	error = hostInterface->StartTeamDebugger(debuggerOptions);
	if (error != B_OK)
		return false;

	TeamDebugger* teamDebugger = hostInterface->TeamDebuggerAt(0);
	thread_id teamDebuggerThread = teamDebugger->Thread();

	// run the input loop
	userInterface->Run();

	// wait for the team debugger thread to terminate
	wait_for_thread(teamDebuggerThread, NULL);

	return true;
}


// #pragma mark -


int
main(int argc, const char* const* argv)
{
	// We test-parse the arguments here, so that, when we're started from the
	// terminal and there's an instance already running, we can print an error
	// message to the terminal, if something's wrong with the arguments.
	// Otherwise, the arguments are reparsed in the actual application,
	// unless the option to use the command line interface was chosen.

	Options options;
	parse_arguments(argc, argv, false, options);

	if (options.useCLI) {
		CliDebugger debugger;
		return debugger.Run(options) ? 0 : 1;
	} else if (options.saveReport) {
		ReportDebugger debugger;
		return debugger.Run(options) ? 0 : 1;
	}

	Debugger app;
	status_t error = app.Init();
	if (error != B_OK) {
		fprintf(stderr, "Error: Failed to init application: %s\n",
			strerror(error));
		return 1;
	}

	app.Run();

	return 0;
}