#include "cardmanager.h"

Card::Card(const QString &id, QObject *parent) :
	QObject(parent), _id(id),
	_vibrate(true), _open(false), _visible(false)
{
}

QString Card::id() const
{
	return _id;
}

QString Card::header() const
{
	return _header;
}

void Card::setHeader(const QString &header)
{
	if (_header != header) {
		_header = header;
		emit headerChanged();
	}
}

QString Card::title() const
{
	return _title;
}

void Card::setTitle(const QString &title)
{
	if (_title != title) {
		_title = title;
		emit titleChanged();
	}
}

QString Card::info() const
{
	return _info;
}

void Card::setInfo(const QString &info)
{
	if (_info != info) {
		_info = info;
		emit infoChanged();
	}
}

QDateTime Card::dateTime() const
{
	return _dateTime;
}

void Card::setDateTime(const QDateTime &dt)
{
	if (_dateTime != dt) {
		_dateTime = dt;
		emit dateTimeChanged();
	}
}

bool Card::isVibrate() const
{
	return _vibrate;
}

void Card::setVibrate(bool vibrate)
{
	if (_vibrate != vibrate) {
		_vibrate = vibrate;
		emit vibrateChanged();
	}
}

QString Card::text() const
{
	return _text;
}

void Card::setText(const QString &text)
{
	if (_text != text) {
		_text = text;
		emit textChanged();
	}
}

QStringList Card::menuOptions() const
{
	return _options;
}

void Card::setMenuOptions(const QStringList &options)
{
	if (_options != options) {
		_options = options;
		emit menuOptionsChanged();
	}
}

bool Card::isOpen() const
{
	return _open;
}

void Card::setOpen(bool open)
{
	_open = open;
}

bool Card::isVisible() const
{
	return _visible;
}

void Card::setVisible(bool visible)
{
	_visible = visible;
}

CardDeck::CardDeck(const QString &package, const QString &application, QObject *parent) :
	QObject(parent),
	_package(package), _application(application),
	_refreshTimer(new QTimer(this))
{
	_refreshTimer->setSingleShot(true);
	_refreshTimer->setInterval(100);
	connect(_refreshTimer, &QTimer::timeout,
			this, &CardDeck::needsRefresh);
}

QString CardDeck::package() const
{
	return _package;
}

QString CardDeck::application() const
{
	return _application;
}

QList<Card*> CardDeck::cards() const
{
	return _deck;
}

Card* CardDeck::cardAt(int position) const
{
	return _deck.at(position);
}

void CardDeck::appendCard(Card *card)
{
	insertCard(_deck.size(), card);
}

void CardDeck::insertCard(int position, Card *card)
{
	if (_ids.contains(card->id())) {
		qWarning() << "Card" << card->id() << "already present";
		return;
	}

	_deck.insert(position, card);
	_ids.insert(card->id(), card);

	connect(card, &Card::headerChanged, this, &CardDeck::scheduleRefresh);
	connect(card, &Card::titleChanged, this, &CardDeck::scheduleRefresh);
	connect(card, &Card::infoChanged, this, &CardDeck::scheduleRefresh);
	connect(card, &Card::vibrateChanged, this, &CardDeck::scheduleRefresh);
	connect(card, &Card::textChanged, this, &CardDeck::scheduleRefresh);
	connect(card, &Card::menuOptionsChanged, this, &CardDeck::scheduleRefresh);

	emit cardAdded(card);
	scheduleRefresh();
}

void CardDeck::removeCard(int position)
{
	Card * card = _deck.takeAt(position);
	_ids.remove(card->id());

	disconnect(card, 0, this, 0);

	emit cardRemoved(card);
	scheduleRefresh();
}

void CardDeck::removeCard(Card *card)
{
	int position = _deck.indexOf(card);
	if (position >= 0) {
		removeCard(position);
	} else {
		qWarning() << "Card not found";
	}
}

void CardDeck::scheduleRefresh()
{
	if (!_refreshTimer->isActive()) {
		_refreshTimer->start();
	}
}

CardManager::CardManager(FmsManager *fms, ToqManager *toq) :
	QObject(toq), _toq(toq), _fms(fms)
{
	_toq->setEndpointListener(ToqConnection::AppMessagingEndpoint, this);
}

void CardManager::handleMessage(const ToqConnection::Message &msg)
{

}

void CardManager::installDeck(CardDeck *deck)
{
	if (_decks.contains(deck->package())) {
		qWarning() << "Deck" << deck->package() << "is already installed";
		return;
	}

	_decks.insert(deck->package(), deck);

	connect(deck, &CardDeck::needsRefresh, this, &CardManager::handleDeckNeedsRefresh);
	connect(deck, &CardDeck::cardAdded, this, &CardManager::handleCardAdded);
	connect(deck, &CardDeck::cardRemoved, this, &CardManager::handleCardRemoved);
}

void CardManager::uninstallDeck(CardDeck *deck)
{
	if (!_decks.contains(deck->package())) {
		qWarning() << "Deck" << deck->package() << "is not installed";
	}
	_decks.remove(deck->package());

	disconnect(deck, 0, this, 0);
}

QString CardManager::generateCardDescription(const QString &verb, Card *card) const
{
	QString desc = verb + " { ";
	desc += QString("id = \"%1\", ").arg(card->id());
	desc += QString("version = 2, ");
	if (!card->header().isEmpty()) {
		desc += QString("header = \"%1\", ").arg(card->header());
	}
	if (!card->title().isEmpty()) {
		desc += QString("title = \"%1\", ").arg(card->title());
	}
	if (card->dateTime().isValid()) {
		desc += QString("time = \"%1\", ").arg(card->dateTime().toMSecsSinceEpoch());
	}
	if (!card->info().isEmpty()) {
		desc += QString("title = \"%1\", ").arg(card->info());
	}
	if (!card->isVibrate()) {
		desc += QString("suppressvibe = \"true\", ");
	}
	if (!card->text().isEmpty()) {
		desc += QString("detail = { \"%1\" }").arg(card->text());
	}
	desc += QString("}\n");
	return desc;
}

void CardManager::refreshDeck(CardDeck *deck)
{
	Q_ASSERT(deck);
	Q_ASSERT(_toq->isConnected());

	qDebug() << "Refreshing deck" << deck->package();

	QList<Card*> cards = deck->cards();
	QString data;
	for (Card * card : cards) {
		data += generateCardDescription("NotifyCard", card);
	}

#if 0
	qDebug() << data;
	data = QLatin1String(
				"NotifyCard { id = \"jackpal.androidterm\", version = 2, app = \"Terminal\", title = \"Terminal\", time = \"1427073495379\", cardevents = \"true\", divider = \"true\", icon = \"fms:/jackpal.androidterm.img\", detail = { \"Ses de terminal en ejecucin\" } }\n"
				"NotifyCard { id = \"com.android.vending\", version = 2, app = \"Google Play Store\", title = \"Simulador Chat\", time = \"1427073139463\", divider = \"true\", icon = \"fms:/com.android.vending.img\", detail = { \"Instalada correctamente\" } }\n");
#endif

	qDebug() << data;

	QString cardsFile = QString("/packages/%1/cards.dat").arg(deck->package());
	_fms->updateFile(cardsFile, data.toUtf8());
}

void CardManager::handleToqConnected()
{
	for (const QString &package : _pending) {
		refreshDeck(_decks.value(package));
	}
	_pending.clear();
}

void CardManager::handleDeckNeedsRefresh()
{
	CardDeck *deck = static_cast<CardDeck*>(sender());
	qDebug() << deck->package() << "needs refresh";
	if (_toq->isConnected()) {
		refreshDeck(deck);
	} else {
		_pending.insert(deck->package());
	}
}

void CardManager::handleCardAdded(Card *card)
{
	CardDeck *deck = static_cast<CardDeck*>(sender());
	if (_toq->isConnected()) {

	}
}

void CardManager::handleCardRemoved(Card *card)
{
	CardDeck *deck = static_cast<CardDeck*>(sender());
	if (_toq->isConnected()) {

	}
}