/*
 * Copyright 2015-2018, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef JOB_H
#define JOB_H


#include "BaseJob.h"

#include <map>
#include <set>
#include <vector>

#include <OS.h>
#include <StringList.h>

#include <locks.h>


using namespace BSupportKit;
class BMessage;
class BMessenger;

class Finder;
class Job;
class Target;

struct entry_ref;


typedef std::map<BString, BMessage> PortMap;


class TeamListener {
public:
	virtual	void				TeamLaunched(Job* job, status_t status) = 0;
};


class Job : public BaseJob {
public:
								Job(const char* name);
								Job(const Job& other);
	virtual						~Job();

			::TeamListener*		TeamListener() const;
			void				SetTeamListener(::TeamListener* listener);

			bool				IsEnabled() const;
			void				SetEnabled(bool enable);

			bool				IsService() const;
			void				SetService(bool service);

			bool				CreateDefaultPort() const;
			void				SetCreateDefaultPort(bool createPort);

			void				AddPort(BMessage& data);

			const BStringList&	Arguments() const;
			BStringList&		Arguments();
			void				AddArgument(const char* argument);

			::Target*			Target() const;
			void				SetTarget(::Target* target);

			const BStringList&	Requirements() const;
			BStringList&		Requirements();
			void				AddRequirement(const char* requirement);

			const BStringList&	Pending() const;
			BStringList&		Pending();
			void				AddPending(const char* pending);

	virtual	bool				CheckCondition(ConditionContext& context) const;

			status_t			Init(const Finder& jobs,
									std::set<BString>& dependencies);
			status_t			InitCheck() const;

			team_id				Team() const;

			const PortMap&		Ports() const;
			port_id				Port(const char* name = NULL) const;

			port_id				DefaultPort() const;
			void				SetDefaultPort(port_id port);

			status_t			Launch();
			bool				IsLaunched() const;
			bool				IsRunning() const;
			void				TeamDeleted();
			bool				CanBeLaunched() const;

			bool				IsLaunching() const;
			void				SetLaunching(bool launching);

			status_t			HandleGetLaunchData(BMessage* message);
			status_t			GetMessenger(BMessenger& messenger);

	virtual	status_t			Run();

protected:
	virtual	status_t			Execute();

private:
			Job&				operator=(const Job& other);
			void				_DeletePorts();
			status_t			_AddRequirement(BJob* dependency);
			void				_AddStringList(std::vector<const char*>& array,
									const BStringList& list);

			void				_SetLaunchStatus(status_t launchStatus);

			status_t			_SendLaunchDataReply(BMessage* message);
			void				_SendPendingLaunchDataReplies();

			status_t			_CreateAndTransferPorts();
			port_id				_CreateAndTransferPort(const char* name,
									int32 capacity);

			status_t			_Launch(const char* signature, entry_ref* ref,
									int argCount, const char* const* args,
									const char** environment);

private:
			BStringList			fArguments;
			BStringList			fRequirements;
			bool				fEnabled;
			bool				fService;
			bool				fCreateDefaultPort;
			bool				fLaunching;
			PortMap				fPortMap;
			status_t			fInitStatus;
			team_id				fTeam;
			port_id				fDefaultPort;
			uint32				fToken;
			status_t			fLaunchStatus;
			mutex				fLaunchStatusLock;
			::Target*			fTarget;
			::Condition*		fCondition;
			BStringList			fPendingJobs;
			BObjectList<BMessage>
								fPendingLaunchDataReplies;
			::TeamListener*		fTeamListener;
};


class Finder {
public:
	virtual	Job*				FindJob(const char* name) const = 0;
	virtual	Target*				FindTarget(const char* name) const = 0;
};


#endif // JOB_H