/*
 * Copyright (c) 2012 Tobias Markmann
 * Licensed under the simplified BSD license.
 * See Documentation/Licenses/BSD-simplified.txt for more information.
 */

#include "QtVCardWidget.h"
#include "ui_QtVCardWidget.h"

#include <QDebug>
#include <QLineEdit>
#include <QMenu>


#include "QtVCardAddressField.h"
#include "QtVCardAddressLabelField.h"
#include "QtVCardBirthdayField.h"
#include "QtVCardDescriptionField.h"
#include "QtVCardEMailField.h"
#include "QtVCardJIDField.h"
#include "QtVCardOrganisationField.h"
#include "QtVCardRoleField.h"
#include "QtVCardTelephoneField.h"
#include "QtVCardTitleField.h"
#include "QtVCardURLField.h"

#include "QtSwiftUtil.h"

#include <boost/algorithm/string.hpp>

#include <Swiften/Base/Log.h>

namespace Swift {

QtVCardWidget::QtVCardWidget(QWidget* parent) :
	QWidget(parent),
	ui(new ::Ui::QtVCardWidget) {
	ui->setupUi(this);

	menu = new QMenu(this);

	menu->addMenu(ui->photoAndName->getAddFieldMenu());
	ui->toolButton->setMenu(menu);

	//addFieldType(menu, boost::make_shared<QtVCardAddressField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardEMailField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardJIDField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardBirthdayField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardTelephoneField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardRoleField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardTitleField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardOrganisationField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardURLField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardDescriptionField::FieldInfo>());
	//addFieldType(menu, boost::make_shared<QtVCardAddressLabelField::FieldInfo>());

	setEditable(false);
}

QtVCardWidget::~QtVCardWidget() {
	delete ui;
}

bool QtVCardWidget::isEditable() const {
	return editable;
}

void QtVCardWidget::setEditable(bool editable) {
	this->editable = editable;

	ui->photoAndName->setProperty("editable", QVariant(editable));
	//ui->photoAndName->setStyleSheet(editable ? "" : "background: transparent;");

	for(int n = 0; n < ui->cardFields->count(); n++) {
		QWidget* widget = ui->cardFields->itemAt(n)->widget();
		if (!widget) continue;
		if (widget->property("editable").isValid()) {
			widget->setProperty("editable", QVariant(editable));
			//widget->setStyleSheet(editable ? "" : "background: transparent;");
		}
	}
	if (editable) {
		ui->toolButton->show();
		if ((findChild<QtVCardBirthdayField*>() == 0)) {
		}
	} else {
		ui->toolButton->hide();
	}

	editableChanged(editable);
}

void QtVCardWidget::setVCard(VCard::ref vcard) {
	SWIFT_LOG(debug) << std::endl;
	clearFields();
	this->vcard = vcard;
	ui->photoAndName->setFormattedName(P2QSTRING(vcard->getFullName()));
	ui->photoAndName->setNickname(P2QSTRING(vcard->getNickname()));
	ui->photoAndName->setPrefix(P2QSTRING(vcard->getPrefix()));
	ui->photoAndName->setGivenName(P2QSTRING(vcard->getGivenName()));
	ui->photoAndName->setMiddleName(P2QSTRING(vcard->getMiddleName()));
	ui->photoAndName->setFamilyName(P2QSTRING(vcard->getFamilyName()));
	ui->photoAndName->setSuffix(P2QSTRING(vcard->getSuffix()));
	ui->photoAndName->setAvatar(vcard->getPhoto(), vcard->getPhotoType());

	/*
	foreach (const VCard::EMailAddress& address, vcard->getEMailAddresses()) {
		QtVCardEMailField* emailField = new QtVCardEMailField(this);
		emailField->setAddress(P2QSTRING(address.address));
		emailField->setType(address.isX400 ? QtVCardEMailField::X_400 : QtVCardEMailField::Internet);
		emailField->setWork(address.isWork);
		emailField->setHome(address.isHome);
		emailField->setPreferred(address.isPreferred);
		ui->cardFields->insertWidget(ui->cardFields->count(), emailField);
	}

	if (!vcard->getBirthday().is_not_a_date_time()) {
		QtVCardBirthdayField* bdayField = new QtVCardBirthdayField(this);
		bdayField->setBirthday(B2QDATE(vcard->getBirthday()).date());
		ui->cardFields->insertWidget(ui->cardFields->count(), bdayField);
	}

	foreach (const JID& jid, vcard->getJIDs()) {
		QtVCardJIDField* jidField = new QtVCardJIDField(this);
		jidField->setJID(P2QSTRING(jid.toString()));
		ui->cardFields->insertWidget(ui->cardFields->count(), jidField);
	}

	foreach (const std::string& url, vcard->getURLs()) {
		QtVCardURLField* urlField = new QtVCardURLField(this);
		urlField->setURL(P2QSTRING(url));
		ui->cardFields->insertWidget(ui->cardFields->count(), urlField);
	}

	foreach (const VCard::Telephone& telephone, vcard->getTelephones()) {
		QtVCardTelephoneField* telField = new QtVCardTelephoneField(this);
		telField->setNumber(P2QSTRING(telephone.number));
		telField->setHome(telephone.isHome);
		telField->setWork(telephone.isWork);
		telField->setVoice(telephone.isVoice);
		telField->setFax(telephone.isFax);
		telField->setPager(telephone.isPager);
		telField->setMSG(telephone.isMSG);
		telField->setCell(telephone.isCell);
		telField->setVideo(telephone.isVideo);
		telField->setBBS(telephone.isBBS);
		telField->setModem(telephone.isModem);
		telField->setISDN(telephone.isISDN);
		telField->setPCS(telephone.isPCS);
		telField->setPreferred(telephone.isPreferred);
		ui->cardFields->insertWidget(ui->cardFields->count(), telField);
	}

	if (!vcard->getDescription().empty()) {
		QtVCardDescriptionField* descriptionField = new QtVCardDescriptionField(this);
		descriptionField->setDescription(P2QSTRING(vcard->getDescription()));
		ui->cardFields->insertWidget(ui->cardFields->count(), descriptionField);
	}

	foreach (const std::string& role, vcard->getRoles()) {
		QtVCardRoleField* roleField = new QtVCardRoleField(this);
		roleField->setRole(P2QSTRING(role));
		ui->cardFields->insertWidget(ui->cardFields->count(), roleField);
	}

	foreach (const std::string& title, vcard->getTitles()) {
		QtVCardTitleField* titleField = new QtVCardTitleField(this);
		titleField->setTitle(P2QSTRING(title));
		ui->cardFields->insertWidget(ui->cardFields->count(), titleField);
	}

	foreach (const VCard::Organization organisation, vcard->getOrganizations()) {
		QtVCardOrganisationField* organisationField = new QtVCardOrganisationField(this);
		organisationField->setName(P2QSTRING(organisation.name));

		QList<QString> units;
		foreach(const std::string& unit, organisation.units) {
			units.push_back(P2QSTRING(unit));
		}
		organisationField->setUnits(units);
		ui->cardFields->insertWidget(ui->cardFields->count(), organisationField);
	}

	foreach (const VCard::Address& address, vcard->getAddresses()) {
		QtVCardAddressField* addressField = new QtVCardAddressField(this);
		addressField->setHome(address.isHome);
		addressField->setWork(address.isWork);
		addressField->setPostal(address.isPostal);
		addressField->setParcel(address.isParcel);
		addressField->setDeliveryType(address.deliveryType == VCard::InternationalDelivery ? QtVCardAddressField::InternationalDelivery : QtVCardAddressField::DomesticDelivery);
		addressField->setPreferred(address.isPreferred);

		addressField->setPOBox(P2QSTRING(address.poBox));
		addressField->setAddressExtension(P2QSTRING(address.addressExtension));
		addressField->setStreet(P2QSTRING(address.street));
		addressField->setLocality(P2QSTRING(address.locality));
		addressField->setRegion(P2QSTRING(address.region));
		addressField->setPostalCode(P2QSTRING(address.postalCode));
		addressField->setCountry(P2QSTRING(address.country));

		ui->cardFields->insertWidget(ui->cardFields->count(), addressField);
	}

	foreach (const VCard::AddressLabel& addressLabel, vcard->getAddressLabels()) {
		QtVCardAddressLabelField* addressLabelField = new QtVCardAddressLabelField(this);
		addressLabelField->setHome(addressLabel.isHome);
		addressLabelField->setWork(addressLabel.isWork);
		addressLabelField->setPostal(addressLabel.isPostal);
		addressLabelField->setParcel(addressLabel.isParcel);
		addressLabelField->setDeliveryType(addressLabel.deliveryType == VCard::InternationalDelivery ? QtVCardAddressLabelField::InternationalDelivery : QtVCardAddressLabelField::DomesticDelivery);
		addressLabelField->setPreferred(addressLabel.isPreferred);

		std::string joinedLines = boost::algorithm::join(addressLabel.lines, "\n");
		addressLabelField->setLines(P2QSTRING(joinedLines));

		ui->cardFields->insertWidget(ui->cardFields->count(), addressLabelField);
	}
	*/

	setEditable(editable);
}

VCard::ref QtVCardWidget::getVCard() {
	SWIFT_LOG(debug) << std::endl;
	clearEmptyFields();
	vcard->setFullName(Q2PSTRING(ui->photoAndName->getFormattedName()));
	vcard->setNickname(Q2PSTRING(ui->photoAndName->getNickname()));
	vcard->setPrefix(Q2PSTRING(ui->photoAndName->getPrefix()));
	vcard->setGivenName(Q2PSTRING(ui->photoAndName->getGivenName()));
	vcard->setMiddleName(Q2PSTRING(ui->photoAndName->getMiddleName()));
	vcard->setFamilyName(Q2PSTRING(ui->photoAndName->getFamilyName()));
	vcard->setSuffix(Q2PSTRING(ui->photoAndName->getSuffix()));
	vcard->setPhoto(ui->photoAndName->getAvatarData());
	vcard->setPhotoType(ui->photoAndName->getAvatarType());

	vcard->clearEMailAddresses();
	vcard->clearJIDs();
	vcard->clearURLs();
	vcard->clearTelephones();
	vcard->clearRoles();
	vcard->clearTitles();
	vcard->clearOrganizations();
	vcard->clearAddresses();
	vcard->clearAddressLabels();

	QtVCardBirthdayField* bdayField = NULL;
	QtVCardDescriptionField* descriptionField = NULL;
	for(int n = 0; n < ui->cardFields->count(); n++) {
		QWidget* widget = ui->cardFields->itemAt(n)->widget();

		QtVCardEMailField* emailField;
		if ((emailField = dynamic_cast<QtVCardEMailField*>(widget))) {
			VCard::EMailAddress address;
			address.address = Q2PSTRING(emailField->getAddress());
			address.isInternet = emailField->getType() == QtVCardEMailField::Internet;
			address.isX400 = emailField->getType() == QtVCardEMailField::X_400;
			address.isHome = emailField->getHome();
			address.isWork = emailField->getWork();
			address.isPreferred = emailField->getPreferred();
			vcard->addEMailAddress(address);
			continue;
		}

		QtVCardJIDField* jidField;
		if ((jidField = dynamic_cast<QtVCardJIDField*>(widget))) {
			JID jid(Q2PSTRING(jidField->getJID()));
			if (jid.isValid()) {
				vcard->addJID(jid);
			}
			continue;
		}

		QtVCardURLField* urlField;
		if ((urlField = dynamic_cast<QtVCardURLField*>(widget))) {
			vcard->addURL(Q2PSTRING(urlField->getURL()));
			continue;
		}

		QtVCardTelephoneField* telephoneField;
		if ((telephoneField = dynamic_cast<QtVCardTelephoneField*>(widget))) {
			VCard::Telephone telephone;
			telephone.number = Q2PSTRING(telephoneField->getNumber());
			telephone.isHome = telephoneField->getHome();
			telephone.isWork = telephoneField->getWork();
			telephone.isVoice = telephoneField->getVoice();
			telephone.isFax = telephoneField->getFax();
			telephone.isPager = telephoneField->getPager();
			telephone.isMSG = telephoneField->getMSG();
			telephone.isCell = telephoneField->getCell();
			telephone.isVideo = telephoneField->getVideo();
			telephone.isBBS = telephoneField->getBBS();
			telephone.isModem = telephoneField->getModem();
			telephone.isISDN = telephoneField->getISDN();
			telephone.isPCS = telephoneField->getPCS();
			telephone.isPreferred = telephoneField->getPreferred();
			vcard->addTelephone(telephone);
			continue;
		}

		if (dynamic_cast<QtVCardBirthdayField*>(widget)) {
			bdayField = dynamic_cast<QtVCardBirthdayField*>(widget);
			continue;
		}

		if (dynamic_cast<QtVCardDescriptionField*>(widget)) {
			descriptionField = dynamic_cast<QtVCardDescriptionField*>(widget);
			continue;
		}

		QtVCardRoleField* roleField;
		if ((roleField = dynamic_cast<QtVCardRoleField*>(widget))) {
			vcard->addRole(Q2PSTRING(roleField->getRole()));
			continue;
		}

		QtVCardTitleField* titleField;
		if ((titleField = dynamic_cast<QtVCardTitleField*>(widget))) {
			vcard->addTitle(Q2PSTRING(titleField->getTitle()));
			continue;
		}

		QtVCardOrganisationField* organisationField;
		if ((organisationField = dynamic_cast<QtVCardOrganisationField*>(widget))) {
			VCard::Organization organisation;
			organisation.name = Q2PSTRING(organisationField->getName());
			foreach(const QString &unit, organisationField->getUnits()) {
				organisation.units.push_back(Q2PSTRING(unit));
			}
			vcard->addOrganization(organisation);
			continue;
		}

		QtVCardAddressField* addressField;
		if ((addressField = dynamic_cast<QtVCardAddressField*>(widget))) {
			VCard::Address address;
			address.isHome = addressField->getHome();
			address.isWork = addressField->getWork();
			address.isPostal = addressField->getPostal();
			address.isParcel = addressField->getParcel();
			address.deliveryType = addressField->getDeliveryType() == QtVCardAddressField::InternationalDelivery ? VCard::InternationalDelivery : VCard::DomesticDelivery;
			address.isPreferred = addressField->getPreferred();

			address.poBox = Q2PSTRING(addressField->getPOBox());
			address.addressExtension = Q2PSTRING(addressField->getAddressExtension());
			address.street = Q2PSTRING(addressField->getStreet());
			address.locality = Q2PSTRING(addressField->getLocality());
			address.region = Q2PSTRING(addressField->getRegion());
			address.postalCode = Q2PSTRING(addressField->getPostalCode());
			address.country = Q2PSTRING(addressField->getCountry());
			vcard->addAddress(address);
			continue;
		}

		QtVCardAddressLabelField* addressLabelField;
		if ((addressLabelField = dynamic_cast<QtVCardAddressLabelField*>(widget))) {
			VCard::AddressLabel addressLabel;
			addressLabel.isHome = addressLabelField->getHome();
			addressLabel.isWork = addressLabelField->getWork();
			addressLabel.isPostal = addressLabelField->getPostal();
			addressLabel.isParcel = addressLabelField->getParcel();
			addressLabel.deliveryType = addressLabelField->getDeliveryType() == QtVCardAddressLabelField::InternationalDelivery ? VCard::InternationalDelivery : VCard::DomesticDelivery;
			addressLabel.isPreferred = addressLabelField->getPreferred();

			std::string lines = Q2PSTRING(addressLabelField->getLines());
			boost::split(addressLabel.lines,lines, boost::is_any_of("\n"));

			vcard->addAddressLabel(addressLabel);
			continue;
		}
	}

	if (bdayField) {
		vcard->setBirthday(boost::posix_time::from_time_t(QDateTime(bdayField->getBirthday()).toTime_t()));
	} else {
		vcard->setBirthday(boost::posix_time::ptime());
	}

	if (descriptionField) {
		vcard->setDescription(Q2PSTRING(descriptionField->getDescription()));
	} else {
		vcard->setDescription("");
	}

	return vcard;
}

void QtVCardWidget::addField() {
	QAction* action = NULL;
	if ((action = dynamic_cast<QAction*>(sender()))) {
		boost::shared_ptr<QtVCardFieldInfo> fieldInfo = actionFieldInfo[action];
		ui->cardFields->insertWidget(ui->cardFields->count(), fieldInfo->createFieldInstance(this, true));
	}
}

void QtVCardWidget::addFieldType(QMenu* menu, boost::shared_ptr<QtVCardFieldInfo> fieldType) {
	QAction* action = new QAction(tr("Add ") + fieldType->getMenuName(), this);
	actionFieldInfo[action] = fieldType;
	connect(action, SIGNAL(triggered()), this, SLOT(addField()));
	menu->addAction(action);
}

int QtVCardWidget::fieldTypeInstances(boost::shared_ptr<QtVCardFieldInfo> fieldType) {
	int instances = 0;
	for (int n = 0; n < ui->cardFields->count(); n++) {
		if (fieldType->testInstance(ui->cardFields->itemAt(n)->widget())) instances++;
	}
	return instances;
}

void QtVCardWidget::clearFields() {
	assert(ui->cardFields->count() >= 0);
	while(ui->cardFields->count() > 0) {
		QLayoutItem* child;
		if ((child = ui->cardFields->takeAt(0)) != 0) {
			delete child->widget();
			delete child;
		}
	}
}

void QtVCardWidget::clearEmptyFields() {
	for (int n = 0; n < ui->cardFields->count(); n++) {
		QWidget* field = ui->cardFields->itemAt(n)->widget();
		if (field->property("empty").isValid() && field->property("empty").toBool()) {
			ui->cardFields->removeWidget(field);
			delete field;
			n--;
		}
	}
}

}