/*
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef FS_TRANSACTION_H
#define FS_TRANSACTION_H


#include <string>
#include <vector>

#include "FSUtils.h"


class FSTransaction {
public:
			typedef FSUtils::Entry Entry;

			class Operation;
			class CreateOperation;
			class RemoveOperation;
			class MoveOperation;

public:
								FSTransaction();
								~FSTransaction();

			void				RollBack();

			int32				CreateEntry(const Entry& entry,
									int32 modifiedOperation = -1);
			int32				RemoveEntry(const Entry& entry,
									const Entry& backupEntry,
									int32 modifiedOperation = -1);
			int32				MoveEntry(const Entry& fromEntry,
									const Entry& toEntry,
									int32 modifiedOperation = -1);

			void				RemoveOperationAt(int32 index);

private:
			struct OperationInfo;
			typedef std::vector<OperationInfo> OperationList;

private:
	static	std::string			_GetPath(const Entry& entry);

private:
			OperationList		fOperations;
};


class FSTransaction::Operation {
public:
	Operation(FSTransaction* transaction, int32 operation)
		:
		fTransaction(transaction),
		fOperation(operation),
		fIsFinished(false)
	{
	}

	~Operation()
	{
		if (fTransaction != NULL && fOperation >= 0 && !fIsFinished)
			fTransaction->RemoveOperationAt(fOperation);
	}

	/*!	Arms the operation rollback, i.e. rolling back the transaction will
		revert this operation.
	*/
	void Finished()
	{
		fIsFinished = true;
	}

	/*!	Unregisters the operation rollback, i.e. rolling back the transaction
		will not revert this operation.
	*/
	void Unregister()
	{
		if (fTransaction != NULL && fOperation >= 0) {
			fTransaction->RemoveOperationAt(fOperation);
			fIsFinished = false;
			fTransaction = NULL;
			fOperation = -1;
		}
	}

private:
	FSTransaction*	fTransaction;
	int32			fOperation;
	bool			fIsFinished;
};


class FSTransaction::CreateOperation : public FSTransaction::Operation {
public:
	CreateOperation(FSTransaction* transaction, const Entry& entry,
		int32 modifiedOperation = -1)
		:
		Operation(transaction,
			transaction->CreateEntry(entry, modifiedOperation))
	{
	}
};


class FSTransaction::RemoveOperation : public FSTransaction::Operation {
public:
	RemoveOperation(FSTransaction* transaction, const Entry& entry,
		const Entry& backupEntry, int32 modifiedOperation = -1)
		:
		Operation(transaction,
			transaction->RemoveEntry(entry, backupEntry, modifiedOperation))
	{
	}
};


class FSTransaction::MoveOperation : public FSTransaction::Operation {
public:
	MoveOperation(FSTransaction* transaction, const Entry& fromEntry,
		const Entry& toEntry, int32 modifiedOperation = -1)
		:
		Operation(transaction,
			transaction->MoveEntry(fromEntry, toEntry, modifiedOperation))
	{
	}
};


#endif	// FS_TRANSACTION_H