/* $Id$ */

/** @file ai_transactionmode.hpp class to switch the AI to Transaction mode */

#ifndef AI_TRANSACTIONMODE_HPP
#define AI_TRANSACTIONMODE_HPP

#include "ai_object.hpp"
#include <queue>

/**
 * Class to switch current mode to Transaction mode.
 * If you create an instance of this class, the mode will be switched to
 *   Transaction. The original mode is stored and recovered from when ever the
 *   instance is destroyed.
 * In Transaction mode all commands will be tested, and if not fail, queued.
 *   Later on you can execute a queue for real. The Transaction keeps on
 *   recording all commands till it is destructed or execute or stopped.
 * On execute the transaction can return false, because maps change over time.
 *   If this happens you can use the rollback feature to remove all already
 *   built things.
 */
class AITransactionMode : public AIObject {
private:
	struct AITransactionModeCommand {
		TileIndex tile;
		uint32 p1;
		uint32 p2;
		uint procc;
		char *text;
	};

	AIModeProc *last_mode;
	AIObject *last_instance;
	std::queue<AITransactionModeCommand> command_stack;
	std::queue<AITransactionModeCommand> reverse_stack;
	bool stopped;
	CommandCost costs;

protected:
	/**
	 * The callback proc for Transaction mode.
	 */
	static bool ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, CommandCost costs);

public:
	/**
	 * The name of the class, needed by several sub-processes.
	 */
	static const char *GetClassName() { return "AITransactionMode"; }

	/**
	 * Creating instance of this class switches the build mode to Transaction.
	 * @note when the instance is destroyed, he restores the mode that was
	 *   current when the instance was created!
	 */
	AITransactionMode();

	/**
	 * Destroying this instance reset the building mode to the mode it was
	 *   in when the instance was created.
	 */
	~AITransactionMode();

	/**
	 * Execute all recorded commands.
	 * @return false if any command recorded failed to execute. All other
	 *   commands that follow won't be executed either.
	 * @note when Execute() is called, the transaction is stopped (like calling
	 *   Stop() yourself).
	 * @note Execute() is always executed, no matter what mode you gave it in
	 *   the outside world. It forces itself into executing it for real. To add
	 *   it to an other list, use Append().
	 */
	bool Execute();

	/**
	 * Stop recording the commands and switch to the last mode, like the
	 *   instance was destroyed.
	 */
	void Stop();

	/**
	 * Rollbacks rolls the whole transaction back in case Execute() returned
	 *   false. In case Execute() returned true, there won't be anything to roll
	 *   back, so this command will do nothing.
	 * It rolls back all commands by looking up the reverse of every command
	 *   issued and executes that. Of course it can happen that even that fails.
	 *   In that case the problem will be silently ignored.
	 * @note as you might want to get a costs estimate about the rollback first
	 *   you need to make sure you set the right mode yourself!
	 * @note this command isn't finished yet!!
	 */
	void Rollback();

	/**
	 * Get the costs it takes to execute this transaction (on average, real
	 *   numbers can always differ).
	 */
	Money GetCosts();

	/**
	 * Append one transaction list to an other.
	 * @param transaction the list that will be appended after the instance you call append on.
	 */
	void Append(AITransactionMode *transaction);
};

#endif /* AI_TRANSACTIONMODE_HPP */