/*
 * Copyright (C) 2009,2010,2013 Rolf Eike Beer <kde@opensource.sf-tec.de>
 */

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

#include "kgpgsearchresultmodel.h"

#include <KDateTime>
#include <KDebug>
#include <KLocale>
#include <QString>
#include <QStringList>
#include <QTextCodec>

#include "core/convert.h"
#include "core/kgpgkey.h"

class SearchResult {
private:
	QStringList m_emails;
	QStringList m_names;

public:
	SearchResult(const QString &line);

	bool m_validPub;	// true when the "pub" line passed to constructor was valid

	void addUid(const QString &id);
	const QString &getName(const int index) const;
	const QString &getEmail(const int index) const;
	int getUidCount() const;

	QString m_fingerprint;
	unsigned int m_uatCount;

	QVariant summary() const;
private:
	KDateTime m_expiry;
	KDateTime m_creation;
	bool m_revoked;
	unsigned int m_bits;
	KgpgCore::KgpgKeyAlgo m_algo;
};

class KGpgSearchResultModelPrivate {
public:
	explicit KGpgSearchResultModelPrivate();
	~KGpgSearchResultModelPrivate();

	QList<SearchResult *> m_items;

	QString urlDecode(const QString &line);
};

SearchResult::SearchResult(const QString &line)
	: m_validPub(false),
	m_uatCount(0),
	m_revoked(false),
	m_bits(0)
{
	const QStringList parts(line.split(QLatin1Char( ':' )));

	if (parts.count() < 6)
		return;

	if (parts.at(1).isEmpty())
		return;

	m_fingerprint = parts.at(1);
	m_algo = KgpgCore::Convert::toAlgo(parts.at(2));
	m_bits = parts.at(3).toUInt();
	m_creation.setTime_t(parts.at(4).toULongLong());
	m_revoked = (parts.at(6) == QLatin1String( "r" ));

	m_validPub = true;
}

void
SearchResult::addUid(const QString &id)
{
	Q_ASSERT(m_emails.count() == m_names.count());
	QRegExp hasmail( QLatin1String( "(.*) <(.*)>" ));

	if (hasmail.exactMatch(id)) {
		m_names.append(hasmail.capturedTexts().at(1));
		m_emails.append(hasmail.capturedTexts().at(2));
	} else {
		m_names.append(id);
		m_emails.append(QString());
	}
}

const QString &
SearchResult::getName(const int index) const
{
	return m_names.at(index);
}

const QString &
SearchResult::getEmail(const int index) const
{
	return m_emails.at(index);
}

int
SearchResult::getUidCount() const
{
	Q_ASSERT(m_emails.count() == m_names.count());

	return m_emails.count();
}

QVariant
SearchResult::summary() const
{
	if (m_revoked) {
		return i18nc("example: ID abc123xy, 1024-bit RSA key, created Jan 12 2009, revoked",
				"ID %1, %2-bit %3 key, created %4, revoked", m_fingerprint,
				m_bits, KgpgCore::Convert::toString(m_algo),
				m_creation.toString(KDateTime::LocalDate));
	} else {
		return i18nc("example: ID abc123xy, 1024-bit RSA key, created Jan 12 2009",
				"ID %1, %2-bit %3 key, created %4", m_fingerprint,
				m_bits, KgpgCore::Convert::toString(m_algo),
				m_creation.toString(KDateTime::LocalDate));
	}
}

KGpgSearchResultModelPrivate::KGpgSearchResultModelPrivate()
{
}

KGpgSearchResultModelPrivate::~KGpgSearchResultModelPrivate()
{
	foreach (SearchResult *item, m_items)
		delete item;
}

QString
KGpgSearchResultModelPrivate::urlDecode(const QString &line)
{
	if (!line.contains(QLatin1Char( '%' )))
		return line;

	QByteArray tmp(line.toAscii());
	const QRegExp hex( QLatin1String( "[A-F0-9]{2}" ));	// URL-encoding uses only uppercase

	int pos = -1;	// avoid error if '%' is URL-encoded
	while ((pos = tmp.indexOf("%", pos + 1)) >= 0) {
		const QByteArray hexnum(tmp.mid(pos + 1, 2));

		// the input is not properly URL-encoded, so assume it does not need to be decoded at all
		if (!hex.exactMatch(QLatin1String( hexnum )))
			return line;

		char n[2];
		// this must work as we checked the regexp before
		n[0] = hexnum.toUShort(NULL, 16);
		n[1] = '\0';	// to use n as a 0-terminated string

		tmp.replace(pos, 3, n);
	}

	return QTextCodec::codecForName("utf8")->toUnicode(tmp);
}

KGpgSearchResultModel::KGpgSearchResultModel(QObject *parent)
	: QAbstractItemModel(parent), d(new KGpgSearchResultModelPrivate())
{
}

KGpgSearchResultModel::~KGpgSearchResultModel()
{
	delete d;
}

QVariant
KGpgSearchResultModel::data(const QModelIndex &index, int role) const
{
	if (!index.isValid())
		return QVariant();

	if (role != Qt::DisplayRole)
		return QVariant();

	if (index.row() < 0)
		return QVariant();

	SearchResult *tmp = static_cast<SearchResult *>(index.internalPointer());
	int row;

	if (tmp == NULL) {
		// this is a "top" item, show the first uid
		if (index.row() >= d->m_items.count())
			return QVariant();

		tmp = d->m_items.at(index.row());
		row = 0;
	} else {
		row = index.row() + 1;
		int summaryRow = tmp->getUidCount();
		int uatRow;
		if (tmp->m_uatCount != 0) {
			uatRow = summaryRow;
			summaryRow++;
		} else {
			uatRow = -1;
		}

		if (row == uatRow) {
			if (index.column() == 0)
				return i18np("One Photo ID", "%1 Photo IDs", tmp->m_uatCount);
			else
				return QVariant();
		} else if (row == summaryRow) {
			if (index.column() == 0)
				return tmp->summary();
			else
				return QVariant();
		}
		Q_ASSERT(row < tmp->getUidCount());
	}

	switch (index.column()) {
	case 0:
		return tmp->getName(row);
	case 1:
		return tmp->getEmail(row);
	default:
		return QVariant();
	}
}

int
KGpgSearchResultModel::columnCount(const QModelIndex &parent) const
{
	if (parent.isValid()) {
		if (parent.column() != 0)
			return 0;

		SearchResult *tmp = static_cast<SearchResult *>(parent.internalPointer());

		if (tmp == NULL)
			return 2;
		else
			return 0;
	} else {
		return 2;
	}
}

QModelIndex
KGpgSearchResultModel::index(int row, int column, const QModelIndex &parent) const
{
	// there are three hierarchy levels:
	// root: this is simply QModelIndex()
	// key items: parent is invalid, internalPointer is NULL
	// uid entries: parent is key item, internalPointer is set to SearchResult*

	if (parent.isValid()) {
		if (parent.internalPointer() != NULL) {
			return QModelIndex();
		} else {
			if (parent.row() >= d->m_items.count())
				return QModelIndex();
			SearchResult *tmp = d->m_items.at(parent.row());
			int maxRow = tmp->getUidCount();
			if (tmp->m_uatCount != 0)
				maxRow++;
			if ((row >= maxRow) || (column > 1))
				return QModelIndex();
			return createIndex(row, column, tmp);
		}
	} else {
		if ((row >= d->m_items.count()) || (column > 1) || (row < 0) || (column < 0))
			return QModelIndex();
		return createIndex(row, column);
	}
}

QModelIndex
KGpgSearchResultModel::parent(const QModelIndex &index) const
{
	if (!index.isValid())
		return QModelIndex();

	SearchResult *tmp = static_cast<SearchResult *>(index.internalPointer());

	if (tmp == NULL)
		return QModelIndex();

	return createIndex(d->m_items.indexOf(tmp), 0);
}

int
KGpgSearchResultModel::rowCount(const QModelIndex &parent) const
{
	if (!parent.isValid()) {
		return d->m_items.count();
	} else if (parent.column() == 0) {
		if (parent.internalPointer() != NULL)
			return 0;

		SearchResult *item = d->m_items.at(parent.row());
		int cnt = item->getUidCount();
		if (item->m_uatCount != 0)
			cnt++;

		return cnt;
	} else {
		return 0;
	}
}

QVariant
KGpgSearchResultModel::headerData(int section, Qt::Orientation orientation, int role) const
{
	if (role != Qt::DisplayRole)
		return QVariant();

	if (orientation != Qt::Horizontal)
		return QVariant();

	switch (section) {
	case 0:
		return i18n("Name");
	case 1:
		return QString(i18nc("@title:column Title of a column of emails", "Email"));
	default:
		return QVariant();
	}
}

const QString &
KGpgSearchResultModel::idForIndex(const QModelIndex &index) const
{
	Q_ASSERT(index.isValid());

	SearchResult *tmp = static_cast<SearchResult *>(index.internalPointer());
	if (tmp == NULL)
		tmp = d->m_items.at(index.row());

	return tmp->m_fingerprint;
}

void
KGpgSearchResultModel::slotAddKey(QStringList lines)
{
	Q_ASSERT(!lines.isEmpty());
	Q_ASSERT(lines.first().startsWith(QLatin1String("pub:")));

	if (lines.count() == 1)
		return;

	SearchResult *nkey = new SearchResult(lines.takeFirst());
	if (!nkey->m_validPub) {
		delete nkey;
		return;
	}

	foreach (const QString &line, lines) {
		if (line.startsWith(QLatin1String("uid:"))) {
			QString kid = d->urlDecode(line.section(QLatin1Char( ':' ), 1, 1));

			nkey->addUid(kid);
		} else if (line.startsWith(QLatin1String("uat:"))) {
			nkey->m_uatCount++;
		} else {
			kDebug(2100) << "ignored search result line" << line;
		}
	}

	if (nkey->getUidCount() > 0) {
		beginInsertRows(QModelIndex(), d->m_items.count(), d->m_items.count());
		d->m_items.append(nkey);
		endInsertRows();
	} else {
		// key server sent back a crappy key
		delete nkey;
	}
}

#include "moc_kgpgsearchresultmodel.cpp"