/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 *   copyright            : (C) 2003 by Zhang Yong                         *
 *   email                : z-yong163@163.com                              *
 ***************************************************************************/

#include "mailchecker.h"
#include "mailwidget.h"
#include "mail.xpm"
#include <qsocket.h>
#include <qtimer.h>
#include <qdom.h>
#include <qlineedit.h>
#include <qspinbox.h>


class MailWidget : public MailWidgetBase {
public:
	MailWidget(QWidget *parent = 0)
		: MailWidgetBase(parent) {}

	void load(Options &ops);
	void save(Options &ops);
};


static QString readString(const QDomElement &parent, const char *tag)
{
	return parent.elementsByTagName(tag).item(0).toElement().text();
}

static int readInteger(const QDomElement &parent, const char *tag, int def)
{
	QDomElement e = parent.elementsByTagName(tag).item(0).toElement();
	if (e.isNull())
		return def;
	return e.text().toInt();
}

static void writeString(QDomDocument &doc, QDomElement &parent,
						const char *tag, const QString &value)
{
	QDomElement e = doc.createElement(tag);
	e.appendChild(doc.createTextNode(value));
	parent.appendChild(e);
}


Options::Options()
{
	port = 0;
	interval = 0;
}

void Options::load(const QDomElement &pref)
{
	host = readString(pref, "host");
	port = readInteger(pref, "port", 110);
	user = readString(pref, "user");
	password = readString(pref, "password");
	interval = readInteger(pref, "interval", 10);
}

void Options::save(QDomDocument &doc, QDomElement &pref)
{
	writeString(doc, pref, "host", host);
	writeString(doc, pref, "port", QString::number(port));
	writeString(doc, pref, "user", user);
	writeString(doc, pref, "password", password);
	writeString(doc, pref, "interval", QString::number(interval));
}


void MailWidget::load(Options &ops)
{
	hostEdit->setText(ops.host);
	portEdit->setText(QString::number(ops.port));
	userEdit->setText(ops.user);
	passEdit->setText(ops.password);
	intervalSpin->setValue(ops.interval);
}

void MailWidget::save(Options &ops)
{
	ops.host = hostEdit->text();
	ops.port = portEdit->text().toInt();
	ops.user = userEdit->text();
	ops.password = passEdit->text();
	ops.interval = intervalSpin->value();
}


enum {
	CMD_START,
	CMD_USER,
	CMD_PASS,
	CMD_STAT,
	CMD_QUIT,
};
	

MailChecker::MailChecker()
{
	notifyText = NULL;
	lastCmd = CMD_START;

	iconPix = QPixmap((const char **) mail_xpm);

	popSocket = new QSocket(this);
	connect(popSocket, SIGNAL(readyRead()), SLOT(slotDataReady()));

	checkTimer = new QTimer(this);
	connect(checkTimer, SIGNAL(timeout()), SLOT(slotCheckMail()));
}

MailChecker::~MailChecker()
{
}

QString MailChecker::getName()
{
	return tr("Mail Checker");
}

QString MailChecker::getDesc()
{
	return tr("Check new incoming POP3 mail at a specified interval.");
}

bool MailChecker::startTimer()
{
	if (checkTimer->isActive() ||
		options.interval <= 0 ||
		options.host.isEmpty() ||
		options.user.isEmpty())
		return false;

	checkTimer->start(options.interval * 60000);
	return true;
}

bool MailChecker::init(MAPI *mapi)
{
	notifyText = mapi->addNotifyText(NULL);
	return TRUE;
}

void MailChecker::load(const QDomElement &pref)
{
	options.load(pref);

	startTimer();
}

void MailChecker::unload(QDomDocument &doc, QDomElement &pref)
{
	options.save(doc, pref);

	notifyText->hide();
	checkTimer->stop();
	popSocket->close();
}

QWidget *MailChecker::getConfigWidget(QWidget *parent)
{
	MailWidget *w = new MailWidget(parent);
	w->load(options);
	return w;
}

void MailChecker::saveConfig(QWidget *w)
{
	((MailWidget *) w)->save(options);

	startTimer();
}

void MailChecker::sendCmd(const char *cmd)
{
	QCString s = cmd;
	s += "\r\n";
	popSocket->writeBlock(s, s.length());
}

void MailChecker::onStatReply(const QString &reply)
{
	QString s;
	int n;

	QTextIStream(&reply) >> s >> n;

	if (n <= 0)
		notifyText->hide();
	else {
		notifyText->show();
		notifyText->setText(tr("You have %1 mail(s)").arg(n));
	}
}

void MailChecker::slotCheckMail()
{
	lastCmd = CMD_START;
	popSocket->connectToHost(options.host, options.port);
}

void MailChecker::slotDataReady()
{
	QString result = popSocket->readLine();
	if (result.isEmpty())
		return;

	qDebug(result.data());

	if (result[0] != '+') {
		popSocket->close();
		return;
	}

	QCString cmd;

	switch (lastCmd) {
	case CMD_START:
		cmd = "USER ";
		cmd += options.user;
		lastCmd = CMD_USER;
		break;

	case CMD_USER:
		cmd = "PASS ";
		cmd += options.password;
		lastCmd = CMD_PASS;
		break;

	case CMD_PASS:
		cmd = "STAT";
		lastCmd = CMD_STAT;
		break;

	case CMD_STAT:
		onStatReply(result);

		cmd = "QUIT";
		lastCmd = CMD_QUIT;
		break;

	case CMD_QUIT:
		popSocket->close();
		return;
	}

	sendCmd(cmd);
}


LINQ_EXPORT Plugin *getPlugin()
{
	return new MailChecker;
}