#include <QtCore/QDebug>
#include <QtCore/QDateTime>

#include "controller.h"

static const QLatin1String setting_address("address");
static const QLatin1String setting_cur_page("cur-page");
static const QLatin1String setting_24h_mode("24h-mode");
static const QLatin1String setting_ddmm_mode("ddmm-mode");
static const QLatin1String setting_seconds("show-seconds");
static const QLatin1String setting_separation_lines("show-separation-lines");
static const QLatin1String setting_auto_backlight("auto-backlight");

Controller::Controller(const QString &settingsPrefix, QQuickView *view, QObject *parent) :
	QObject(parent),
	_settings(new MDConfGroup(this)),
	_metawatch(0),
	_reconnect(new ReconnectTimer(this)),
	_widgets(new WidgetInfoModel(settingsPrefix, this)),
	_curMode(MetaWatch::WatchModeIdle), _curPage(0),
	_batteryCharge(0), _batteryCharging(false)
{
	_settings->setPath(settingsPrefix);
	_curPage = _settings->value(setting_cur_page).toInt();

	connect(_settings, &MDConfGroup::valueChanged, this, &Controller::handleSettingChanged);
	connect(_widgets, &QAbstractItemModel::dataChanged, this, &Controller::handleWidgetChanged);

	connectToAddress(_settings->value(setting_address).toString());
}

Controller::~Controller()
{
}

MetaWatch::WatchMode Controller::mode() const
{
	return _curMode;
}

int Controller::page() const
{
	return _curPage;
}

void Controller::setPage(int page)
{
	if (page != _curPage) {
		_curPage = page;
		_metawatch->updateLcdDisplayPage(_curPage);
		emit pageChanged();
	}
}

int Controller::batteryCharge() const
{
	return _batteryCharge;
}

bool Controller::batteryCharging() const
{
	return _batteryCharging;
}

void Controller::connectToAddress(const QString &address)
{
	if (_metawatch) {
		if (address == _address) {
			// Connecting to the same address and there's already a watch object created
			return;
		}

		_reconnect->stop();
		disconnect(_metawatch, 0, this, 0);
		disconnect(_metawatch, 0, _reconnect, 0);
		delete _metawatch;
		_metawatch = 0;
	}

	_address = address;

	if (_address.isEmpty()) {
		qDebug() << "Empty address, doing nothing except wasting memory";
		return;
	}

	_metawatch = new MetaWatch(_address, this);
	connect(_metawatch, &MetaWatch::connected, _reconnect, &ReconnectTimer::stop);
	connect(_metawatch, &MetaWatch::connected,  this, &Controller::handleMetaWatchConnected);
	connect(_metawatch, &MetaWatch::disconnected, _reconnect, &ReconnectTimer::scheduleNextAttempt);
	connect(_metawatch, &MetaWatch::modeChange, this, &Controller::handleMetaWatchModeChange);
	connect(_metawatch, &MetaWatch::batteryStatus, this, &Controller::handleMetaWatchBatteryStatus);
	connect(_reconnect, &ReconnectTimer::tryReconnect, _metawatch, &MetaWatch::connectDevice);

	_reconnect->scheduleNextAttempt();
}

void Controller::updateProperties()
{
	MetaWatch::WatchProperties props;

	if (_settings->value(setting_24h_mode).toBool()) {
		props |= MetaWatch::WatchPropertyHourFormat24h;
	}

	if (_settings->value(setting_ddmm_mode).toBool()) {
		props |= MetaWatch::WatchPropertyDateFormatDDMM;
	}

	if (_settings->value(setting_seconds).toBool()) {
		props |= MetaWatch::WatchPropertyShowSeconds;
	}

	if (_settings->value(setting_separation_lines).toBool()) {
		props |= MetaWatch::WatchPropertyShowSeparationLines;
	}

	if (_settings->value(setting_auto_backlight).toBool()) {
		props |= MetaWatch::WatchPropertyAutoBacklight;
	}

	_metawatch->configure(props);
}

void Controller::handleSettingChanged(const QString &key)
{
	qDebug() << "Setting" << key << "changed";
	if (key == setting_address) {
		connectToAddress(_settings->value(setting_address).toString());
	} else if (key == setting_cur_page) {
		int page = _settings->value(setting_cur_page).toInt();
		if (_curPage != page) {
			setPage(page);
		}
	} else if (key == setting_24h_mode || key == setting_ddmm_mode || key == setting_seconds
			   || key == setting_separation_lines || key == setting_auto_backlight) {
		updateProperties();
	}
}

void Controller::handleMetaWatchConnected()
{
	qDebug() << "MetaWatch connected, synchronizing date time";

	_metawatch->updateDeviceType();
	_metawatch->updateBatteryStatus();
	_metawatch->setDateTime(QDateTime::currentDateTime());
	_metawatch->updateWidgetList(_widgets->toList());
	_metawatch->updateLcdDisplayPage(_curPage);

	_curMode = MetaWatch::WatchModeIdle;

	updateProperties();
}

void Controller::handleMetaWatchModeChange(MetaWatch::WatchMode mode, int page)
{
	switch (mode) {
	case MetaWatch::WatchModeIdle:
		if (_curMode != mode) {
			_curMode = mode;
			emit modeChanged();
		}
		if (page != _curPage) {
			_curPage = page;
			_settings->setValue(setting_cur_page, QVariant::fromValue(_curPage));
			emit pageChanged();
		}

		break;
	default:
		qWarning() << "Unhandled metawatch mode:" << mode;
		break;
	}
}

void Controller::handleMetaWatchBatteryStatus(bool charging, int charge)
{
	if (_batteryCharging != charging) {
		_batteryCharging = charging;
		emit batteryChargingChanged();
	}
	if (_batteryCharge != charge) {
		_batteryCharge = charge;
		emit batteryChargeChanged();
	}
}

void Controller::handleWidgetChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
{
	if (roles.indexOf(WidgetInfoModel::UrlRole) >= 0) {
		// Can't send partial updates to watch, so entire list must be
		// resubmitted everytime something important changes
		_metawatch->updateWidgetList(_widgets->toList());

		if (_widgets->data(topLeft, WidgetInfoModel::PageRole).toInt() == _curPage) {
			_metawatch->updateLcdDisplayPage(_curPage);
		}
	}
}