/*
 * Copyright 2002-2025, Haiku Inc.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *		François Revol (mmu_man)
 *		Humdinger, humdinger@mailbox.org
 */


#include <Application.h>
#include <MessageRunner.h>
#include <Messenger.h>
#include <NetworkInterface.h>
#include <NetworkRoster.h>
#include <String.h>

#include <cstdio>
#include <cstdlib>


static int sExitValue = EXIT_FAILURE;
static const char* kProgramName = "waitfor";
static const char* kProgramSig = "application/x-vnd.haiku-waitfor";


#define INTERVAL 100000 // 0.1sec
#define CHECK 'chck'


enum command {
	NONE,
	APP_RUNNING,
	NETWORK,
	THREAD_STARTED,
	THREAD_ENDED
};


class WaitforApp : public BApplication {
public:
	WaitforApp();
	virtual ~WaitforApp();

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

private:
	void _Usage();
	bool _CheckNetworkConnection();

	BMessageRunner* fRunner;
	BString fThreadName;
	BString fAppSig;
	command fOption;
};


WaitforApp::WaitforApp()
	:
	BApplication(kProgramSig),
	fThreadName(NULL),
	fAppSig(NULL),
	fOption(NONE)
{
	BMessage message(CHECK);
	fRunner = new BMessageRunner(this, &message, INTERVAL);
}


WaitforApp::~WaitforApp()
{
	stop_watching_network(this);
	delete fRunner;
}


void
WaitforApp::ArgvReceived(int32 argc, char** argv)
{
	if (argc == 2 && strcmp(argv[1], "-n") == 0) {
		fOption = NETWORK;
	} else if (argc == 2) {
		fOption = THREAD_STARTED;
		fThreadName = argv[1];
	} else if (argc == 3 && strcmp(argv[1], "-e") == 0) {
		fOption = THREAD_ENDED;
		fThreadName = argv[2];
	} else if (argc == 3 && strcmp(argv[1], "-m") == 0) {
		fOption = APP_RUNNING;
		fAppSig = argv[2];
	} else
		fOption = NONE;
}


void
WaitforApp::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case CHECK:
		{
			switch (fOption) {
				case APP_RUNNING:
				{
					BMessenger messenger(fAppSig);
					if (messenger.IsValid()) {
						sExitValue = EXIT_SUCCESS;
						PostMessage(B_QUIT_REQUESTED);
					}
					break;
				}
				case THREAD_STARTED:
				{
					if (find_thread(fThreadName) >= 0) {
						sExitValue = EXIT_SUCCESS;
						PostMessage(B_QUIT_REQUESTED);
					}
					break;
				}
				case THREAD_ENDED:
				{
					if (find_thread(fThreadName) < 0) {
						sExitValue = EXIT_SUCCESS;
						PostMessage(B_QUIT_REQUESTED);
					}
					break;
				}
				case NONE:
				{
					_Usage();
					PostMessage(B_QUIT_REQUESTED);
					break;
				}
				default:
					break;
			}
			break;
		}
		case B_NETWORK_MONITOR:
		{
			if (_CheckNetworkConnection())
				PostMessage(B_QUIT_REQUESTED);
			break;
		}
		default:
		{
			BApplication::MessageReceived(message);
			break;
		}
	}
}


void
WaitforApp::ReadyToRun()
{
	if (fOption == NETWORK) {
		if (_CheckNetworkConnection())
			PostMessage(B_QUIT_REQUESTED);
		else {
			start_watching_network(
				B_WATCH_NETWORK_INTERFACE_CHANGES | B_WATCH_NETWORK_LINK_CHANGES, this);
		}
	}
}


bool
WaitforApp::_CheckNetworkConnection()
{
	BNetworkRoster& roster = BNetworkRoster::Default();
	BNetworkInterface interface;
	uint32 cookie = 0;
	while (roster.GetNextInterface(&cookie, interface) == B_OK) {
		uint32 flags = interface.Flags();
		if ((flags & IFF_LOOPBACK) == 0 && (flags & (IFF_UP | IFF_LINK)) == (IFF_UP | IFF_LINK)) {
			sExitValue = EXIT_SUCCESS;
			return true;
		}
	}
	// No network connection detected
	return false;
}


void
WaitforApp::_Usage()
{
	BString usageText("Usage:\n"
					  "  %s <thread_name>\n"
					  "      wait until a thread with 'thread_name' has been started.\n\n"
					  "  %s -e <thread_name>\n"
					  "      wait until all threads with thread_name have ended.\n\n"
					  "  %s -m <app_signature>\n"
					  "      wait until the application specified by 'app_signature' is "
					  "ready to receive messages.\n\n"
					  "  %s -n\n"
					  "      wait until the network connection is up.\n");
	usageText.ReplaceAll("%s", kProgramName);
	fprintf(stderr, usageText);
}


int
main(int argc, char** argv)
{
	WaitforApp waitforApp;
	waitforApp.Run();

	return sExitValue;
}