/*
 * adhoc.cpp - 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
 *
 */

#include <qcombobox.h>
#include <qmessagebox.h>
#include <qpushbutton.h>
#include <qlayout.h>

#include "adhoc.h"
#include "psiaccount.h"

#include "xmpp_xmlcommon.h"
#include "xmpp_tasks.h"
#include "xmpp_xdata.h"
#include "xdata_widget.h"

using namespace XMPP;

#define AHC_NS "http://jabber.org/protocol/commands"
#define XMPPSTANZA_NS "urn:ietf:params:xml:ns:xmpp-stanzas"

// -------------------------------------------------------------------------- 
// AHCommand: The class representing an Ad-Hoc command request or reply.
// -------------------------------------------------------------------------- 

AHCommand::AHCommand(const QString& node, const QString& sessionId, Action action) : node_(node), hasData_(false), status_(NoStatus), defaultAction_(NoAction), action_(action), sessionId_(sessionId)
{ 
}
	
AHCommand::AHCommand(const QString& node, XData data, const QString& sessionId, Action action) : node_(node), hasData_(true), data_(data), status_(NoStatus), defaultAction_(NoAction), action_(action), sessionId_(sessionId)
{ 
}

AHCommand::AHCommand(const QDomElement& q) : hasData_(false), defaultAction_(NoAction)
{
	// Parse attributes
	QString status = q.attribute("status");
	setStatus(string2status(status));
	node_ = q.attribute("node");
	action_ = string2action(q.attribute("action"));
	sessionId_ = q.attribute("sessionid");

	// Parse the body
	for (QDomNode n = q.firstChild(); !n.isNull(); n = n.nextSibling()) {
		QDomElement e = n.toElement();
		if (e.isNull())
			continue;

		QString tag = e.tagName();

		// A form
		if (tag == "x" && e.attribute("xmlns") =="jabber:x:data") {
			data_.fromXml(e);
			hasData_ = true;
		}

		// Actions
		else if (tag == "actions") {
			QString execute = e.attribute("execute");
			if (!execute.isEmpty()) 
				setDefaultAction(string2action(execute));

			for (QDomNode m = e.firstChild(); !m.isNull(); m = m.nextSibling()) {
				Action a = string2action(m.toElement().tagName());
				if (a == Prev || a == Next || a == Complete)
					actions_ += a;
			}
		}
	}
}

QDomElement AHCommand::toXml(QDomDocument* doc, bool submit) const
{
	QDomElement command = doc->createElement("command");
	command.setAttribute("xmlns", AHC_NS);
	if (status_ != NoStatus) 
		command.setAttribute("status",status2string(status()));
	if (hasData()) 
		command.appendChild(data().toXml(doc, submit));
	if (action_ != Execute) 
		command.setAttribute("action",action2string(action_));
	command.setAttribute("node", node_);
	if (!sessionId_.isEmpty())
		command.setAttribute("sessionid", sessionId_);
		
	return command;
}


AHCommand AHCommand::formReply(const AHCommand& c, const XData& data)
{
	AHCommand r(c.node(), data, c.sessionId());
	r.setStatus(AHCommand::Executing);
	return r;
}

AHCommand AHCommand::formReply(const AHCommand& c, const XData& data, const QString& sessionId)
{
	AHCommand r(c.node(), data, sessionId);
	r.setStatus(AHCommand::Executing);
	return r;
}

AHCommand AHCommand::canceledReply(const AHCommand& c) 
{
	AHCommand r(c.node(), c.sessionId());
	r.setStatus(Canceled);
	return r;
}

AHCommand AHCommand::completedReply(const AHCommand& c) 
{
	AHCommand r(c.node(), c.sessionId());
	r.setStatus(Completed);
	return r;
}

AHCommand AHCommand::completedReply(const AHCommand& c, const XData& d) 
{
	AHCommand r(c.node(), d, c.sessionId());
	r.setStatus(Completed);
	return r;
}
	
//AHCommand AHCommand::errorReply(const AHCommand& c, const AHCError& error)
//{
//	AHCommand r(c.node(), c.sessionId());
//	r.setError(error);
//	return r;
//}

void AHCommand::setStatus(Status s)
{
	status_ = s;
}

void AHCommand::setError(const AHCError& e)
{
	error_ = e;
}

void AHCommand::setDefaultAction(Action a)
{
	defaultAction_ = a;
}

QString AHCommand::status2string(Status status)
{
	QString s;
	switch (status) {
		case Executing : s = "executing"; break;
		case Completed : s = "completed"; break;
		case Canceled : s = "canceled"; break;
		case NoStatus : s = ""; break;
	}
	return s;
}

QString AHCommand::action2string(Action action) 
{
	QString s;
	switch (action) {
		case Prev : s = "prev"; break;
		case Next : s = "next"; break;
		case Cancel : s = "cancel"; break;
		case Complete : s = "complete"; break;
		default: break;
	}
	return s;
}
	
AHCommand::Action AHCommand::string2action(const QString& s)
{
	if (s == "prev") 
		return Prev;
	else if (s == "next") 
		return Next;
	else if (s == "complete") 
		return Complete;
	else if (s == "cancel") 
		return Cancel;
	else 
		return Execute;
}

AHCommand::Status AHCommand::string2status(const QString& s)
{
	if (s == "canceled")
		return Canceled;
	else if (s == "completed")
		return Completed;
	else if (s == "executing")
		return Executing;
	else 
		return NoStatus;
}


// -------------------------------------------------------------------------- 
// AHCError: The class representing an Ad-Hoc command error
// -------------------------------------------------------------------------- 

AHCError::AHCError(ErrorType t) : type_(t)
{
}

AHCError::AHCError(const QDomElement& e) : type_(None)
{
	QString errorGeneral = "", errorSpecific = "";

	for(QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
		QDomElement i = n.toElement();
		if(i.isNull())
			continue;
		
		QString tag = i.tagName();
		
		if ((tag == "bad-request" || tag == "not-allowed" || tag == "forbidden" || tag == "forbidden" || tag == "item-not-found" || tag == "feature-not-implemented") && e.attribute("xmlns") == XMPPSTANZA_NS) {
			errorGeneral = tag;
		}
		else if ((tag == "malformed-action" || tag == "bad-action" || tag == "bad-locale" || tag == "bad-payload" || tag == "bad-sessionid" || tag == "session-expired") && e.attribute("xmlns") == AHC_NS) {
			errorSpecific = tag;
		}
	}

	type_ = strings2error(errorGeneral, errorSpecific);
}
	
QDomElement AHCError::toXml(QDomDocument* doc) const
{
	QDomElement err = doc->createElement("error");

	// Error handling
	if (type_ != None) {
		QString desc, specificCondition = "";
		switch (type_) {
			case MalformedAction:
				desc = "bad-request";
				specificCondition = "malformed-action";
				break;
			case BadAction:
				desc = "bad-request";
				specificCondition = "bad-action";
				break;
			case BadLocale:
				desc = "bad-request";
				specificCondition = "bad-locale";
				break;
			case BadPayload:
				desc = "bad-request";
				specificCondition = "bad-payload";
				break;
			case BadSessionID:
				desc = "bad-request";
				specificCondition = "bad-sessionid";
				break;
			case SessionExpired:
				desc = "not-allowed";
				specificCondition = "session-expired";
				break;
			case Forbidden:
				desc = "forbidden";
				break;
			case ItemNotFound:
				desc = "item-not-found";
				break;
			case FeatureNotImplemented:
				desc = "feature-not-implemented";
				break;
			case None:
				break;
		}

		// General error condition
		QDomElement generalElement = doc->createElement(desc);
		generalElement.setAttribute("xmlns", XMPPSTANZA_NS);
		err.appendChild(generalElement);
		
		// Specific error condition
		if (!specificCondition.isEmpty()) {
			QDomElement generalElement = doc->createElement(specificCondition);
			generalElement.setAttribute("xmlns", AHC_NS);
			err.appendChild(generalElement);
		}
	}

	return err;
}

AHCError::ErrorType AHCError::strings2error(const QString& g, const QString& s)
{
	if (s == "malformed-action")
		return MalformedAction;
	if (s == "bad-action")
		return BadAction;
	if (s == "bad-locale")
		return BadLocale;
	if (s == "bad-payload")
		return BadPayload;
	if (s == "bad-sessionid")
		return BadSessionID;
	if (s == "session-expired")
		return SessionExpired;
	if (g == "forbidden")
		return Forbidden;
	if (g == "item-not-found")
		return ItemNotFound;
	if (g == "feature-not-implemented")
		return FeatureNotImplemented;
	return None;
}

QString AHCError::error2description(const AHCError& e)
{
	QString desc;
	switch (e.type()) {
		case MalformedAction:
			desc = QString("The responding JID does not understand the specified action");
			break;
		case BadAction:
			desc = QString("The responding JID cannot accept the specified action");
			break;
		case BadLocale:
			desc = QString("The responding JID cannot accept the specified language/locale");
			break;
		case BadPayload:
			desc = QString("The responding JID cannot accept the specified payload (eg the data form did not provide one or more required fields)");
			break;
		case BadSessionID:
			desc = QString("The responding JID cannot accept the specified sessionid");
			break;
		case SessionExpired:
			desc = QString("The requesting JID specified a sessionid that is no longer active (either because it was completed, canceled, or timed out)");
			break;
		case Forbidden:
			desc = QString("The requesting JID is not allowed to execute the command");
			break;
		case ItemNotFound:
			desc = QString("The responding JID cannot find the requested command node");
			break;
		case FeatureNotImplemented:
			desc = QString("The responding JID does not support Ad-hoc commands");
			break;
		case None:
			break;
	}
	return desc;
}

// -------------------------------------------------------------------------- 
// AHCommandServer: The server-side implementation of an Ad-hoc command.
// -------------------------------------------------------------------------- 

AHCommandServer::AHCommandServer(AHCServerManager* manager) : manager_(manager)
{
	manager_->addServer(this);
}


// -------------------------------------------------------------------------- 
// JT_AHCServer: Task to handle ad-hoc command requests
// -------------------------------------------------------------------------- 

class JT_AHCServer : public Task
{
	Q_OBJECT

public:
	JT_AHCServer(Task*, AHCServerManager*);
	bool take(const QDomElement& e);
	void sendReply(const AHCommand&, const Jid& to, const QString& id);

protected:
	bool commandListQuery(const QDomElement& e);
	bool commandExecuteQuery(const QDomElement& e);
	void sendCommandList(const QString& to, const QString& from, const QString& id);

private:
	AHCServerManager* manager_;
};


JT_AHCServer::JT_AHCServer(Task* t, AHCServerManager* manager) : Task(t), manager_(manager)
{
}

bool JT_AHCServer::take(const QDomElement& e)
{
	// Check if it's a query
	if (e.tagName() != "iq")
		return false;

	return (commandListQuery(e) || commandExecuteQuery(e));
}

bool JT_AHCServer::commandListQuery(const QDomElement& e)
{
	if (e.attribute("type") == "get") {
		bool found;
		QDomElement q = findSubTag(e, "query", &found);
		if (found && q.attribute("xmlns") == "http://jabber.org/protocol/disco#items" && q.attribute("node") == AHC_NS) {
			sendCommandList(e.attribute("from"),e.attribute("to"),e.attribute("id"));
			return true;
		}
		else if (found && q.attribute("xmlns") == "http://jabber.org/protocol/disco#info" && q.attribute("node") == AHC_NS) {
			QDomElement iq = createIQ(doc(), "result", e.attribute("from"), e.attribute("id"));
			QDomElement query = doc()->createElement("query");
			query.setAttribute("xmlns", "http://jabber.org/protocol/disco#info");
			iq.appendChild(query);

			send(iq);
			return true;
		}
		else if (found && q.attribute("xmlns") == "http://jabber.org/protocol/disco#items" && manager_->hasServer(q.attribute("node"), Jid(e.attribute("from")))) {
			QDomElement iq = createIQ(doc(), "result", e.attribute("from"), e.attribute("id"));
			QDomElement query = doc()->createElement("query");
			query.setAttribute("xmlns", "http://jabber.org/protocol/disco#items");
			query.setAttribute("node",q.attribute("node"));
			iq.appendChild(query);

			send(iq);
			return true;
		}
		else if (found && q.attribute("xmlns") == "http://jabber.org/protocol/disco#info" && manager_->hasServer(q.attribute("node"), Jid(e.attribute("from")))) {
			QDomElement iq = createIQ(doc(), "result", e.attribute("from"), e.attribute("id"));
			QDomElement query = doc()->createElement("query");
			query.setAttribute("xmlns", "http://jabber.org/protocol/disco#info");
			query.setAttribute("node",q.attribute("node"));
			iq.appendChild(query);
			QDomElement identity;
			QDomElement feature;

			identity = doc()->createElement("identity");
			identity.setAttribute("category", "automation");
			identity.setAttribute("type", "command-node");
			query.appendChild(identity);

			feature = doc()->createElement("feature");
			feature.setAttribute("var", AHC_NS);
			query.appendChild(feature);

			feature = doc()->createElement("feature");
			feature.setAttribute("var", "jabber:x:data");
			query.appendChild(feature);

			send(iq);
			return true;
		}

	}
	
	return false;
}

bool JT_AHCServer::commandExecuteQuery(const QDomElement& e)
{
	if (e.attribute("type") == "set") {
		bool found;
		QDomElement q = findSubTag(e, "command", &found);
		if (found && q.attribute("xmlns") == AHC_NS) {
			if (manager_->hasServer(q.attribute("node"), Jid(e.attribute("from")))) {
				AHCommand command(q);
				manager_->execute(command, Jid(e.attribute("from")), e.attribute("id"));
				return true;
			}
			return false;
		} 
		else 
			return false;
	}
	return false;
}

void JT_AHCServer::sendCommandList(const QString& to, const QString& from, const QString& id) 
{
	// Create query element 
	QDomElement iq = createIQ(doc(), "result", to, id);
	QDomElement query = doc()->createElement("query");
	query.setAttribute("xmlns", "http://jabber.org/protocol/disco#items");
	query.setAttribute("node", AHC_NS);
	iq.appendChild(query);

	// Add all commands
	AHCServerManager::ServerList l = manager_->commands(Jid(to));
	for (AHCommandServer* c = l.first(); c; c = l.next()) {
		QDomElement command = doc()->createElement("item");
		command.setAttribute("jid",from);
		command.setAttribute("name",c->name());
		command.setAttribute("node",c->node());
		query.appendChild(command);
	}

	// Send the message
	send(iq);
}
	
void JT_AHCServer::sendReply(const AHCommand& c, const Jid& to, const QString& id)
{
	// if (c.error().type() != AHCError::None) {
		QDomElement iq = createIQ(doc(), "result", to.full(), id);
		QDomElement command = c.toXml(doc(), false);
		iq.appendChild(command);
		send(iq);
	// }
	// else {
	// }
}

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

AHCServerManager::AHCServerManager(PsiAccount *pa) : pa_(pa)
{
	server_task_ = new JT_AHCServer(pa_->client()->rootTask(), this);
}

void AHCServerManager::addServer(AHCommandServer* server)
{
	servers_.append(server);
}

AHCServerManager::ServerList AHCServerManager::commands(const Jid& j) const 
{
	ServerList list;
	for (ServerList::ConstIterator it = servers_.begin(); it != servers_.end(); ++it) {
		if ((*it)->isAllowed(j)) 
			list.append(*it);
	}
	return list;
}


void AHCServerManager::execute(const AHCommand& command, const Jid& requester, QString id)
{
	AHCommandServer* c = findServer(command.node());

	// Check if the command is provided
	if (!c) {
		//server_task_->sendReply(AHCommand::errorReply(command,AHCError(AHCError::ItemNotFound)), requester, id);
		return;
	}

	// Check if the requester is allowed to execute the command
	if (c->isAllowed(requester)) {
		if (command.action() == AHCommand::Cancel) {
			c->cancel(command);
			server_task_->sendReply(AHCommand::canceledReply(command), requester, id);
		}
		else
			// Execute the command & send back the response
			server_task_->sendReply(c->execute(command, requester), requester, id);
	}
	else {
		//server_task_->sendReply(AHCommand::errorReply(command,AHCError(AHCError::Forbidden)), requester, id);
		return;
	}
}


AHCommandServer* AHCServerManager::findServer(const QString& node) const
{
	for (ServerList::ConstIterator it = servers_.begin(); it != servers_.end(); ++it) {
		if ((*it)->node() == node) 
			return (*it);
	}
	return 0;
}

bool AHCServerManager::hasServer(const QString& node, const Jid& requester) const
{
	AHCommandServer* c = findServer(node);

	// Check if the command is provided
	if (!c) {
		return false;
	}

	if (c->isAllowed(requester)) {
		return true;
	}
	else {
		return false;
	}
}


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

bool operator<(const AHCommandItem &ci1, const AHCommandItem &ci2)
{
	return ci1.name < ci2.name;
}

bool operator<=(const AHCommandItem &ci1, const AHCommandItem &ci2)
{
	return ci1.name <= ci2.name;
}

bool operator==(const AHCommandItem &ci1, const AHCommandItem &ci2)
{
	return ci1.name == ci2.name;
}

bool operator>(const AHCommandItem &ci1, const AHCommandItem &ci2)
{
	return ci1.name > ci2.name;
}

bool operator>=(const AHCommandItem &ci1, const AHCommandItem &ci2)
{
	return ci1.name >= ci2.name;
}

// -------------------------------------------------------------------------- 
// JT_AHCGetList: A Task to retreive the available commands of a client
// -------------------------------------------------------------------------- 

class JT_AHCGetList : public Task
{
public:
	JT_AHCGetList(Task* t, const Jid& j);

	void onGo();
	bool take(const QDomElement &x);
	
	const QValueList<AHCommandItem>& commands() const { return commands_; }

private:
	Jid receiver_;
	QValueList<AHCommandItem> commands_;
};


JT_AHCGetList::JT_AHCGetList(Task* t, const Jid& j) : Task(t), receiver_(j)
{
}

void JT_AHCGetList::onGo()
{
	QDomElement e = createIQ(doc(), "get", receiver_.full(), id());
	QDomElement q = doc()->createElement("query");
	q.setAttribute("xmlns", "http://jabber.org/protocol/disco#items");
	q.setAttribute("node", AHC_NS);
	e.appendChild(q);
	send(e);
}

bool JT_AHCGetList::take(const QDomElement& e)
{
	if(!iqVerify(e, receiver_, id())) {
		return false;
	}
	
	if (e.attribute("type") == "result") {
		// Extract commands
		commands_.clear();
		bool found;
		QDomElement commands = findSubTag(e, "query", &found);
		if(found) {
			for(QDomNode n = commands.firstChild(); !n.isNull(); n = n.nextSibling()) {
				QDomElement i = n.toElement();
				if(i.isNull())
					continue;

				if(i.tagName() == "item") {
					AHCommandItem ci;
					ci.node = i.attribute("node");
					ci.name = i.attribute("name");
					ci.jid = i.attribute("jid");
					commands_ += ci;
				}
			}
			qHeapSort(commands_);
		}
		setSuccess();
		return true;
	}
	else {
		setError(e);
		return false;
	}
}


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

// -------------------------------------------------------------------------- 
// JT_AHCExecute: A task to execute a command
// -------------------------------------------------------------------------- 

class JT_AHCExecute : public Task
{
public:
	JT_AHCExecute(Task* t, PsiAccount* pa, Jid j, const AHCommand&);

	void onGo();
	bool take(const QDomElement &x);
	
private:
	Jid receiver_;
	PsiAccount* account_;
	AHCommand command_;
};


JT_AHCExecute::JT_AHCExecute(Task* t, PsiAccount* pa, Jid j, const AHCommand& command) : Task(t), receiver_(j), account_(pa), command_(command)
{
}

void JT_AHCExecute::onGo()
{
	QDomElement e = createIQ(doc(), "set", receiver_.full(), id());
	e.appendChild(command_.toXml(doc(),true));
	send(e);
}

bool JT_AHCExecute::take(const QDomElement& e)
{
	if(!iqVerify(e, receiver_, id())) {
		return false;
	}
	
	// Result of a command
	if (e.attribute("type") == "result") {
		bool found;
		QDomElement i = findSubTag(e, "command", &found);
		if (found) {
			AHCommand c(i);
			if (c.status() == AHCommand::Executing) {
				AHCFormDlg *w = new AHCFormDlg(c,receiver_,account_);
				w->show();
			}
			else if (c.status() == AHCommand::Completed && i.childNodes().count() > 0) {
				AHCFormDlg *w = new AHCFormDlg(c,receiver_,account_, true);
				w->show();
			}
			setSuccess();
			return true;
		}
	}
	// Error
	/*else if (e.attribute("type") == "set") {
		AHCError err(e);
		if (err.type() != None) {
			QMessageBox::critical(0, tr("Error"), AHCommand::error2description(err.type()), QMessageBox::Ok, QMessageBox::NoButton);
		}
		return true;
	}*/
	setError(e);
	return false;
}

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

// -------------------------------------------------------------------------- 
// AHCommandDlg
// -------------------------------------------------------------------------- 

AHCommandDlg::AHCommandDlg(PsiAccount* pa, const Jid& receiver) : pa_(pa), receiver_(receiver)
{
	QVBoxLayout *vb = new QVBoxLayout(this, 11, 6);

	// Command list + Buttons
	QLabel* lb_commands = new QLabel(tr("Command:"),this);
	vb->addWidget(lb_commands);
	QHBoxLayout *hb1 = new QHBoxLayout(vb);
	cb_commands = new QComboBox(this);
	cb_commands->setSizePolicy ( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
	hb1->addWidget(cb_commands);
	/*pb_info = new QPushButton(tr("Info"), this);
	hb1->addWidget(pb_info);*/
	pb_execute = new QPushButton(tr("Execute"), this);
	hb1->addWidget(pb_execute);
	connect(pb_execute, SIGNAL(clicked()), SLOT(executeCommand()));

	vb->addStretch(1);
	
	// Bottom row
	QHBoxLayout *hb2 = new QHBoxLayout(vb);

	busy = new BusyWidget(this);
	hb2->addWidget(busy);
	hb2->addStretch(1);

	// Refresh button
	pb_refresh = new QPushButton(tr("Refresh"), this);
	hb2->addWidget(pb_refresh);
	connect(pb_refresh, SIGNAL(clicked()), SLOT(refreshCommands()));

	// Close button
	pb_close = new QPushButton(tr("Close"), this);
	hb2->addWidget(pb_close);
	connect(pb_close, SIGNAL(clicked()), SLOT(close()));
	pb_close->setDefault(true);
	pb_close->setFocus();

	setCaption(QString("Execute Command (%1)").arg(receiver.full()));

	// Initialize other things
	task_list_ = 0;

	// Load commands
	refreshCommands();
}


void AHCommandDlg::refreshCommands()
{
	cb_commands->clear();
	pb_execute->setEnabled(false);
	//pb_info->setEnabled(false);
	busy->start();
	if (task_list_)
		disconnect(task_list_,SIGNAL(finished()),this,SLOT(listReceived()));

	task_list_= new JT_AHCGetList(pa_->client()->rootTask(),receiver_);
	connect(task_list_,SIGNAL(finished()),SLOT(listReceived()));
	task_list_->go(true);
}

void AHCommandDlg::listReceived()
{
	QValueList<AHCommandItem> l = task_list_->commands();
	QValueList<AHCommandItem>::ConstIterator it;
	for (it = l.begin(); it != l.end(); ++it) {
		cb_commands->insertItem((*it).name);	
		commands_.append(*it);
	}
	pb_execute->setEnabled(cb_commands->count()>0);
	busy->stop();
	
	// FIXME delete task_list_ ?;
	task_list_ = 0;
}

void AHCommandDlg::executeCommand()
{
	if (cb_commands->count() > 0) {
		busy->start();
		Jid to(commands_[cb_commands->currentItem()].jid);
		QString node = commands_[cb_commands->currentItem()].node;
		JT_AHCExecute* t = new JT_AHCExecute(pa_->client()->rootTask(),pa_,to,AHCommand(node));
		connect(t,SIGNAL(finished()),SLOT(commandExecuted()));
		t->go(true);
	}
}

void AHCommandDlg::commandExecuted()
{
	busy->stop();
	close();
}

void AHCommandDlg::executeCommand(PsiAccount* pa, const Jid& j, const QString &node)
{
	JT_AHCExecute* t = new JT_AHCExecute(pa->client()->rootTask(),pa,j,AHCommand(node));
	t->go(true);
}

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

AHCFormDlg::AHCFormDlg(const AHCommand& r, const Jid& receiver, PsiAccount* account, bool final) : receiver_(receiver), account_(account)
{
	// Save node
	node_ = r.node();
	sessionId_ = r.sessionId();

	QVBoxLayout *vb = new QVBoxLayout(this, 11, 6);

	// Instructions
	if (!r.data().instructions().isEmpty()) {
		QLabel* lb_instructions = new QLabel(r.data().instructions(),this);
		vb->addWidget(lb_instructions);
	}
	
	// XData form
	xdata_ = new XDataWidget(this);
	xdata_->setFields(r.data().fields());
	vb->addWidget(xdata_);

	vb->addStretch(1);

	// Buttons
	QHBoxLayout *hb = new QHBoxLayout(vb);
	pb_complete = pb_cancel = pb_prev = pb_next = 0;
	if (!final) {

		busy = new BusyWidget(this);
		hb->addWidget(busy);
		hb->addStretch(1);

		if (r.actions().empty()) {
			// Single stage dialog
			pb_complete = new QPushButton(tr("Finish"),this);
			connect(pb_complete,SIGNAL(clicked()),SLOT(doExecute()));
			hb->addWidget(pb_complete);
		}
		else {
			// Multi-stage dialog

			// Previous
			pb_prev = new QPushButton(tr("Previous"),this);
			if (r.actions().contains(AHCommand::Prev)) {
				if (r.defaultAction() == AHCommand::Prev) {
					connect(pb_prev,SIGNAL(clicked()),SLOT(doExecute()));
					pb_prev->setDefault(true);
					pb_prev->setFocus();
				}
				else
					connect(pb_prev,SIGNAL(clicked()),SLOT(doPrev()));
				pb_prev->setEnabled(true);
			}
			else 
				pb_prev->setEnabled(false);
			hb->addWidget(pb_prev);

			// Next
			pb_next = new QPushButton(tr("Next"),this);
			if (r.actions().contains(AHCommand::Next)) {
				if (r.defaultAction() == AHCommand::Next) {
					connect(pb_next,SIGNAL(clicked()),SLOT(doExecute()));
					pb_next->setDefault(true);
					pb_next->setFocus();
				}
				else
					connect(pb_next,SIGNAL(clicked()),SLOT(doNext()));
				pb_next->setEnabled(true);
			}
			else {
				pb_next->setEnabled(false);
			}
			hb->addWidget(pb_next);
			
			// Complete
			pb_complete = new QPushButton(tr("Finish"),this);
			if (r.actions().contains(AHCommand::Complete)) {
				if (r.defaultAction() == AHCommand::Complete) {
					connect(pb_complete,SIGNAL(clicked()),SLOT(doExecute()));
					pb_complete->setDefault(true);
					pb_complete->setFocus();
				}
				else
					connect(pb_complete,SIGNAL(clicked()),SLOT(doComplete()));
				pb_complete->setEnabled(true);
			}
			else {
				pb_complete->setEnabled(false);
			}
			hb->addWidget(pb_complete);
		}
		pb_cancel = new QPushButton(tr("Cancel"), this);
		connect(pb_cancel, SIGNAL(clicked()),SLOT(doCancel()));
		hb->addWidget(pb_cancel);
	}
	else {
		pb_complete = new QPushButton(tr("Ok"),this);
		connect(pb_complete,SIGNAL(clicked()),SLOT(close()));
		hb->addWidget(pb_complete);
	}

	if (!r.data().title().isEmpty()) {
		setCaption(QString("%1 (%2)").arg(r.data().title()).arg(receiver.full()));
	}
	else {
		setCaption(QString("%1").arg(receiver.full()));
	}
}

void AHCFormDlg::doPrev()
{
	busy->start();
	JT_AHCExecute* t = new JT_AHCExecute(account_->client()->rootTask(),account_,receiver_,AHCommand(node_,data(),sessionId_,AHCommand::Prev));
	connect(t,SIGNAL(finished()),SLOT(commandExecuted()));
	t->go(true);
}

void AHCFormDlg::doNext()
{
	busy->start();
	JT_AHCExecute* t = new JT_AHCExecute(account_->client()->rootTask(),account_,receiver_,AHCommand(node_,data(),sessionId_,AHCommand::Next));
	connect(t,SIGNAL(finished()),SLOT(commandExecuted()));
	t->go(true);
}

void AHCFormDlg::doExecute()
{
	busy->start();
	JT_AHCExecute* t = new JT_AHCExecute(account_->client()->rootTask(),account_,receiver_,AHCommand(node_,data(),sessionId_));
	connect(t,SIGNAL(finished()),SLOT(commandExecuted()));
	t->go(true);
}

void AHCFormDlg::doComplete()
{
	busy->start();
	JT_AHCExecute* t = new JT_AHCExecute(account_->client()->rootTask(),account_,receiver_,AHCommand(node_,data(),sessionId_,AHCommand::Complete));
	connect(t,SIGNAL(finished()),SLOT(commandExecuted()));
	t->go(true);
}

void AHCFormDlg::doCancel()
{
	busy->start();
	JT_AHCExecute* t = new JT_AHCExecute(account_->client()->rootTask(),account_,receiver_,AHCommand(node_,sessionId_,AHCommand::Cancel));
	connect(t,SIGNAL(finished()),SLOT(commandExecuted()));
	t->go(true);
}

void AHCFormDlg::commandExecuted()
{
	busy->stop();
	close();
}

XData AHCFormDlg::data() const
{
	XData x;
	x.setFields(xdata_->fields());
	x.setType(XData::Data_Submit);
	return x;
}

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

#include "adhoc.moc"