/*
 * adhoc.h - Client & Server implementation of JEP-50 (Ad-Hoc Commands)
 * Copyright (C) 2005  Remko Troncon
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
 
#ifndef ADHOC_H
#define ADHOC_H

#include <qdialog.h>
#include <qstring.h>
#include <qpair.h>
#include <qmap.h>

#include "xmpp.h"
#include "xmpp_xdata.h"
#include "busywidget.h"

using namespace XMPP;

class PsiAccount;
class QObject;


// -------------------------------------------------------------------------- 
// General Ad-Hoc Commands classes
// -------------------------------------------------------------------------- 

class AHCError 
{
public:
	enum ErrorType { 
		None, MalformedAction, BadAction, BadLocale, 
		BadPayload, BadSessionID, SessionExpired, Forbidden, ItemNotFound, 
		FeatureNotImplemented 
	};

	AHCError(ErrorType = None);
	AHCError(const QDomElement& e);	

	ErrorType type() const { return type_; }
	static QString error2description(const AHCError&);
	QDomElement toXml(QDomDocument* doc) const;

protected:
	static ErrorType strings2error(const QString&, const QString&);

private:
	ErrorType type_;
};


class AHCommand 
{
public:
	// Types
	enum Action { NoAction, Execute, Prev, Next, Complete, Cancel };
	enum Status { NoStatus, Completed, Executing, Canceled };
	typedef QValueList<Action> ActionList;

	// Constructors
	AHCommand(const QString& node, const QString& sessionId = "", Action action = Execute);
	AHCommand(const QString& node, XData data, const QString& sessionId = "", Action action = Execute);
	AHCommand(const QDomElement &e);

	// Inspectors
	const QString& node() const { return node_; }
	bool hasData() const { return hasData_; }
	const XData& data() const { return data_; }
	const ActionList& actions() const { return actions_; }
	Action defaultAction() const { return defaultAction_; }
	Status status() const { return status_; }
	Action action() const { return action_; }
	const QString& sessionId() const { return sessionId_; }
	const AHCError& error() const { return error_; }

	// XML conversion
	QDomElement toXml(QDomDocument* doc, bool submit) const;

	// Helper constructors
	static AHCommand formReply(const AHCommand&, const XData&);
	static AHCommand formReply(const AHCommand&, const XData&, const QString& sessionId);
	static AHCommand canceledReply(const AHCommand&);
	static AHCommand completedReply(const AHCommand&);
	static AHCommand completedReply(const AHCommand&, const XData&);
	//static AHCommand errorReply(const AHCommand&, const AHCError&);
	
protected:
	void setStatus(Status s);
	void setError(const AHCError& e);
	void setDefaultAction(Action a);

	static QString action2string(Action);
	static QString status2string(Status);
	static Action string2action(const QString&);
	static Status string2status(const QString&);

private: 
	QString node_;
	bool hasData_;
	XData data_;
	Status status_;
	Action defaultAction_;
	ActionList actions_;
	Action action_;
	QString sessionId_;
	AHCError error_;
};

	
// -------------------------------------------------------------------------- 
// Ad-Hoc Commands Server classes
// -------------------------------------------------------------------------- 

class AHCServerManager;
class JT_AHCServer;
class XDataWidget;

class AHCommandServer
{
public:
	AHCommandServer(AHCServerManager*);

	virtual QString name() const = 0; 
	virtual QString node() const = 0; 
	virtual bool isAllowed(const Jid&) const { return true; }
	virtual AHCommand execute(const AHCommand&, const Jid& requester) = 0;
	virtual void cancel(const AHCommand&) { }

protected:
	AHCServerManager* manager() const { return manager_; }

private:
	AHCServerManager* manager_;
};

class AHCServerManager 
{
public:
	AHCServerManager(PsiAccount* pa);
	void addServer(AHCommandServer*);
	
	typedef QPtrList<AHCommandServer> ServerList;
	ServerList commands(const Jid&) const;
	void execute(const AHCommand& command, const Jid& requester, QString id);
	PsiAccount* account() const { return pa_; }
	bool hasServer(const QString& node, const Jid& requester) const;

protected:
	AHCommandServer* findServer(const QString& node) const;

private:
	PsiAccount* pa_;
	JT_AHCServer* server_task_;
	ServerList servers_;
};

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

// -------------------------------------------------------------------------- 
// Ad-Hoc Commands Client Classes
// -------------------------------------------------------------------------- 

class QComboBox;
class QPushButton;
class JT_AHCGetList;
	
typedef struct { QString jid, node, name; } AHCommandItem;

bool operator<(const AHCommandItem &ci1, const AHCommandItem &ci2);
bool operator<=(const AHCommandItem &ci1, const AHCommandItem &ci2);
bool operator==(const AHCommandItem &ci1, const AHCommandItem &ci2);
bool operator>(const AHCommandItem &ci1, const AHCommandItem &ci2);
bool operator>=(const AHCommandItem &ci1, const AHCommandItem &ci2);

class AHCommandDlg : public QDialog
{
	Q_OBJECT

public:
	AHCommandDlg(PsiAccount*, const Jid& receiver);
	static void executeCommand(PsiAccount*, const Jid& j, const QString &node);

protected slots:
	void refreshCommands();
	void listReceived();
	void executeCommand();
	void commandExecuted();

private:
	PsiAccount* pa_;
	QPushButton *pb_execute, *pb_close, *pb_refresh /*,*pb_info*/;
	Jid receiver_;
	JT_AHCGetList* task_list_;
	QComboBox* cb_commands;
	QValueList<AHCommandItem> commands_;
	BusyWidget *busy;
};


class AHCFormDlg : public QDialog
{
	Q_OBJECT
public:
	AHCFormDlg(const AHCommand& r, const Jid& receiver, PsiAccount* account, bool final = false);

protected:
	XData data() const;

protected slots:
	void doPrev();
	void doNext();
	void doComplete();
	void doExecute();
	void doCancel();
	void commandExecuted();

private:
	QPushButton *pb_prev, *pb_next, *pb_complete, *pb_cancel;
	XDataWidget *xdata_;
	Jid receiver_;
	QString node_;
	PsiAccount* account_;
	QString sessionId_;
	BusyWidget *busy;
};

#endif