#ifndef TNZ_ACTION_INCLUDED
#define TNZ_ACTION_INCLUDED

#include "tw/tw.h"

#undef DVAPI
#undef DVVAR
#ifdef TWIN_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

class TButton;

//-------------------------------------------------------------------

class DVAPI TGenericCommandAction
{
public:
	TGenericCommandAction() {}
	virtual ~TGenericCommandAction() {}

	virtual void sendCommand() = 0;
	virtual TGenericCommandAction *clone() const = 0;
};

//-------------------------------------------------------------------

template <class T>
class TCommandAction : public TGenericCommandAction
{
public:
	typedef void (T::*CommandMethod)();

	T *m_target;
	CommandMethod m_method;

	TCommandAction<T>(T *target, CommandMethod method) : m_target(target), m_method(method){};
	void sendCommand() { (m_target->*m_method)(); };

	TGenericCommandAction *clone() const
	{
		return new TCommandAction<T>(m_target, m_method);
	}
};

//-------------------------------------------------------------------

template <class T, class Arg>
class TCommandAction1 : public TGenericCommandAction
{
public:
	typedef void (T::*CommandMethod)(Arg arg);

	T *m_target;
	CommandMethod m_method;
	Arg m_arg;

	TCommandAction1<T, Arg>(T *target, CommandMethod method, Arg arg) : m_target(target), m_method(method), m_arg(arg){};
	void sendCommand() { (m_target->*m_method)(m_arg); };

	TGenericCommandAction *clone() const
	{
		return new TCommandAction1<T, Arg>(m_target, m_method, m_arg);
	}
};

//-------------------------------------------------------------------

class DVAPI TCommandSource
{
	vector<TGenericCommandAction *> *m_actions;

public:
	TCommandSource();
	virtual ~TCommandSource();

	void addAction(TGenericCommandAction *action);
	void sendCommand();

private:
	// not implemented
	TCommandSource(const TCommandSource &);
	TCommandSource &operator=(const TCommandSource &);
};

//-------------------------------------------------------------------

template <class T>
inline void tconnect(TCommandSource &src, T *target, void (T::*method)())
{
	src.addAction(new TCommandAction<T>(target, method));
}

//-------------------------------------------------------------------

template <class T, class Arg>
inline void tconnect(
	TCommandSource &src,
	T *target,
	void (T::*method)(Arg arg),
	Arg arg)
{
	src.addAction(new TCommandAction1<T, Arg>(target, method, arg));
}

//-------------------------------------------------------------------

class DVAPI TGuiCommand
{
	class Imp;
	Imp *m_imp;

public:
	TGuiCommand(string cmdName = "none");
	virtual ~TGuiCommand();
	TGuiCommand(const TGuiCommand &);
	TGuiCommand &operator=(const TGuiCommand &);

	//void setHelp(string longHelp, string shortHelp);
	//void setHelp(string help) {setHelp(help, help);}

	//void setTitle(string title);
	//string getTitle();

	bool isToggle() const;
	void setIsToggle(bool on);
	void setStatus(bool on);
	bool getStatus() const;

	void enable();
	void disable();

	void add(TButton *button);
	void setAction(TGenericCommandAction *action);

	// debug!!
	void sendCommand();

	static void execute(string cmdName);
	static void getNames(std::vector<string> &cmdNames);

private:
};

//-------------------------------------------------------------------

class DVAPI TGuiCommandExecutor : public TGuiCommand
{
public:
	TGuiCommandExecutor(string cmdName) : TGuiCommand(cmdName)
	{
		setAction(new TCommandAction<TGuiCommandExecutor>(this, &TGuiCommandExecutor::onCommand));
	}

	virtual ~TGuiCommandExecutor() {}

	virtual void onCommand() = 0;
};

//-------------------------------------------------------------------

class TGuiCommandGenericTarget
{
protected:
	TGuiCommand m_command;

public:
	TGuiCommandGenericTarget(string cmdName) : m_command(cmdName) {}
	virtual ~TGuiCommandGenericTarget() {}
	virtual void activate() = 0;
	virtual void deactivate()
	{
		m_command.setAction(0);
	}
};

//-------------------------------------------------------------------

template <class T>
class TGuiCommandTarget : public TGuiCommandGenericTarget
{
public:
	typedef void (T::*Method)();
	T *m_target;
	Method m_method;

public:
	TGuiCommandTarget(string cmdName, T *target, Method method)
		: TGuiCommandGenericTarget(cmdName), m_target(target), m_method(method) {}

	void activate()
	{
		m_command.setAction(new TCommandAction<T>(m_target, m_method));
	}
};

#endif