/*
 * Copyright 2021-2022, Andrew Lindesay <apl@lindesay.co.nz>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */


#include "AbstractProcessNode.h"

#include <unistd.h>

#include "AbstractProcess.h"
#include "Logger.h"


#define SPIN_DELAY_MI 500 * 1000
	// half of a second

#define TIMEOUT_UNTIL_STARTED_SECS 10
#define TIMEOUT_UNTIL_STOPPED_SECS 10


AbstractProcessNode::AbstractProcessNode(AbstractProcess* process)
	:
	fLock(),
	fListener(NULL),
	fProcess(process)
{
}


AbstractProcessNode::~AbstractProcessNode()
{
	delete fProcess;
}


AbstractProcess*
AbstractProcessNode::Process() const
{
	return fProcess;
}


bool
AbstractProcessNode::IsRunning()
{
	return Process()->ProcessState() == PROCESS_RUNNING;
}


void
AbstractProcessNode::SetListener(ProcessListener* listener)
{
	if (fListener != listener) {
		AutoLocker<BLocker> locker(&fLock);
		fListener = listener;
	}
}


/*! This method will spin-lock the thread until the process is in one of the
    states defined by the mask.
 */

status_t
AbstractProcessNode::_SpinUntilProcessState(
	uint32 desiredStatesMask, int32 timeoutSeconds)
{
	bigtime_t start = system_time();
	while (true) {
		if ((Process()->ProcessState() & desiredStatesMask) != 0)
			return B_OK;

		usleep(SPIN_DELAY_MI);

		int32 secondElapsed = static_cast<int32>(
			(system_time() - start) / (1000 * 1000));

		if (timeoutSeconds > 0 && secondElapsed > timeoutSeconds) {
			HDERROR("[Node<%s>] timeout waiting for process state after %"
				B_PRIi32 " seconds", Process()->Name(), secondElapsed);
			return B_ERROR;
		}
	}
}


void
AbstractProcessNode::AddPredecessor(AbstractProcessNode *node)
{
	fPredecessorNodes.AddItem(node);
	node->_AddSuccessor(this);
}


int32
AbstractProcessNode::CountPredecessors() const
{
	return fPredecessorNodes.CountItems();
}


AbstractProcessNode*
AbstractProcessNode::PredecessorAt(int32 index) const
{
	return fPredecessorNodes.ItemAt(index);
}


bool
AbstractProcessNode::AllPredecessorsComplete() const
{
	for (int32 i = 0; i < CountPredecessors(); i++) {
		if (PredecessorAt(i)->Process()->ProcessState() != PROCESS_COMPLETE)
			return false;
	}

	return true;
}


void
AbstractProcessNode::_AddSuccessor(AbstractProcessNode* node)
{
	fSuccessorNodes.AddItem(node);
}


int32
AbstractProcessNode::CountSuccessors() const
{
	return fSuccessorNodes.CountItems();
}


AbstractProcessNode*
AbstractProcessNode::SuccessorAt(int32 index) const
{
	return fSuccessorNodes.ItemAt(index);
}


BString
AbstractProcessNode::LogReport()
{
	return Process()->LogReport();
}