/*
 * Copyright 2005, Ingo Weinhold, bonefish@users.sf.net.
 * Copyright 2021, Jacob Secunda.
 *
 * Distributed under the terms of the MIT License.
 *
 * Manages the shutdown process.
 */
#ifndef SHUTDOWN_PROCESS_H
#define SHUTDOWN_PROCESS_H

#include <HashMap.h>
#include <HashSet.h>
#include <Locker.h>
#include <Looper.h>

#include "AppInfoList.h"
#include "EventMaskWatcher.h"
#include "RosterAppInfo.h"

class EventQueue;
class TRoster;

// Note: EventMaskWatcher is inherited public due to a gcc bug/C++ feature:
// Once cast into a Watcher dynamic_cast<>()ing it back into an
// EventMaskWatcher fails otherwise.
class ShutdownProcess : public BLooper, public EventMaskWatcher {
public:
								ShutdownProcess(TRoster* roster,
									EventQueue* eventQueue);
	virtual						~ShutdownProcess();

			status_t			Init(BMessage* request);

	virtual	void				MessageReceived(BMessage* message);

	static	void				SendReply(BMessage* request, status_t error);

private:
			void				_SendReply(status_t error);

			void				_NegativeQuitRequestReply(thread_id thread);

			void				_PrepareShutdownMessage(BMessage& message) const;
			status_t			_ShutDown();

			status_t			_PushEvent(uint32 eventType, team_id team,
									int32 phase);
			status_t			_GetNextEvent(uint32& eventType, team_id& team,
									int32& phase, bool block);

			void				_SetPhase(int32 phase);
			void				_ScheduleTimeoutEvent(bigtime_t timeout,
									team_id team = -1);

			bool				_LockAppLists();
			void				_UnlockAppLists();

			void				_InitShutdownWindow();
			void				_SetShowShutdownWindow(bool show);
			void				_AddShutdownWindowApps(AppInfoList& infos);
			void				_RemoveShutdownWindowApp(team_id team);
			void				_SetShutdownWindowCurrentApp(team_id team);
			void				_SetShutdownWindowText(const char* text);
			void				_SetShutdownWindowCancelButtonEnabled(
									bool enabled);
			void				_SetShutdownWindowKillButtonEnabled(
									bool enabled);
			void				_SetShutdownWindowWaitAnimationEnabled(
									bool enabled);
			void				_SetShutdownWindowWaitForShutdown();
			void				_SetShutdownWindowWaitForAbortedOK();

	static	status_t			_WorkerEntry(void* data);
			status_t			_Worker();

			void				_WorkerDoShutdown();
			bool				_WaitForApp(team_id team, AppInfoList* list,
									bool systemApps);
			void				_QuitApps(AppInfoList& list, bool systemApps);
			void				_QuitBackgroundApps();
			void				_WaitForBackgroundApps();
			void				_KillBackgroundApps();
			void				_QuitNonApps();
			void				_QuitBlockingApp(AppInfoList& list, team_id team,
									const char* appName, bool cancelAllowed);
			void				_DisplayAbortingApp(team_id team);
			void				_WaitForDebuggedTeams();

private:
	class TimeoutEvent;
	class InternalEvent;
	struct InternalEventList;
	class QuitRequestReplyHandler;
	class ShutdownWindow;

	typedef HashSet<HashKey32<team_id> > TeamHash;

	friend class QuitRequestReplyHandler;

			BLocker				fWorkerLock;
									// protects fields shared by looper
									// and worker
			BMessage*			fRequest;
			TRoster*			fRoster;
			EventQueue*			fEventQueue;
			TeamHash			fVitalSystemApps;
			AppInfoList			fSystemApps;
			AppInfoList			fUserApps;
			AppInfoList			fBackgroundApps;
			TeamHash			fDebuggedTeams;
			TimeoutEvent*		fTimeoutEvent;
			InternalEventList*	fInternalEvents;
			sem_id				fInternalEventSemaphore;
			QuitRequestReplyHandler* fQuitRequestReplyHandler;
			thread_id			fWorker;
			int32				fCurrentPhase;
			status_t			fShutdownError;
			bool				fHasGUI;
			bool				fReboot;
			bool				fRequestReplySent;
			ShutdownWindow*		fWindow;
};

#endif	// SHUTDOWN_PROCESS_H