lolautoaccept/src/runemanager.cpp

#include "runemanager.h"
#include "ui_runemanager.h"

#include <QDebug>
#include <QListWidgetItem>
#include <QTimer>

#include "clientapi.h"

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

	ui->listClientRunes->setIsClient(true);
	ui->listaaRunes->setIsClient(false);
	ui->listClientRunes->setOther(ui->listaaRunes);
	ui->listaaRunes->setOther(ui->listClientRunes);

	QObject::connect(ui->listaaRunes, &RunePageList::runepageChanged, this, &RuneManager::saveRunePageAA);
	QObject::connect(ui->listClientRunes, &RunePageList::runepageChanged, this, &RuneManager::saveRunePageClient);

	QObject::connect(ui->listaaRunes, &RunePageList::runepageDeleted, this, &RuneManager::deleteRunepageAA);
	QObject::connect(ui->listClientRunes, &RunePageList::runepageDeleted, this, &RuneManager::deleteRunepageClient);

	QObject::connect(ui->chkAutoCopy, &QCheckBox::clicked, this, &RuneManager::autoSyncToggled);


	initialLoadTimer = new QTimer(this);
	QObject::connect(initialLoadTimer, &QTimer::timeout, this, &RuneManager::loadRunes);
	initialLoadTimer->setInterval(std::chrono::milliseconds(1));
	initialLoadTimer->setSingleShot(true);
	initialLoadTimer->start();
}

RuneManager::~RuneManager() {
	delete this->ui;
}

void RuneManager::setConfig(Config& config) {
	this->config = &config;
	Config::GeneralRunePageConfig& rpc = config.getConfig().runepagesConfig;
	ui->listaaRunes->loadRunePages(rpc.runePages);
	ui->chkAutoCopy->setChecked(rpc.autoSync);

	if(rpc.autoSync) {
		syncRunes();
	}
}

void RuneManager::setDataDragon(DataDragon& dd) {
	ui->listaaRunes->setDataDragon(dd);
	ui->listClientRunes->setDataDragon(dd);
}

void RuneManager::loadRunes() {
	if(initialLoadTimer) {
		initialLoadTimer->deleteLater();
		initialLoadTimer = nullptr;
	}

	this->ui->btnRetry->setEnabled(false);
	QCoreApplication::processEvents();

	if(!client) {
		auto ca = ClientAccess::find();

		if(ca) {
			client = std::make_shared<ClientAPI>(*ca.get());
		}
	}

	if(client) {
		try {
			// load meta data
			runeInfo = client->getAllRuneAspekts();
			QCoreApplication::processEvents();
			runeStyles = client->getAllRuneStyles();
			QCoreApplication::processEvents();

			ui->listClientRunes->setClient(*client);
			ui->listaaRunes->setClient(*client);

			this->ui->listClientRunes->setRuneInfos(runeInfo, runeStyles);
			this->ui->listaaRunes->setRuneInfos(runeInfo, runeStyles);

			// load runepages
			const std::vector<ClientAPI::RunePage> runePages = client->getAllRunePages();
			ui->listClientRunes->loadRunePages(runePages);

			// reload runepages - so they ids can get their names
			reloadAARunes();

			// check if autosync is enabled
			if(config && config->getConfig().runepagesConfig.autoSync) {
				syncRunes();
			}
		} catch(RestClient::WebException& e) {
			qCritical() << "webexception: " << e.curlresponse;

			if(e.curlresponse == CURLE_COULDNT_CONNECT) {
				client.reset();
			}
		}
	}

	setRunesEnabled(!!client); // cast to bool
	this->ui->btnRetry->setEnabled(true);
}


void RuneManager::setRunesEnabled(bool enabled) {
	this->ui->lblClientRunes->setEnabled(enabled);
	this->ui->listClientRunes->setEnabled(enabled);
}

void RuneManager::saveRunePageClient(int id, QString name, const RunePage& rp) {
	if(client) {
		ClientAPI::RunePage newPage;
		newPage.name = name;
		newPage.runepage = rp;
		newPage.id = id;

		try {
			if(id == -1) {
				// create new page
				if(!client->createRunePage(newPage)) {
					// TODO: some error occured
				}
			} else {
				// edit existing page
				if(!client->editRunePage(newPage)) {
					// TODO: some error occured
				}
			}
		} catch(RestClient::WebException& e) {
			qCritical() << "webexception: " << e.curlresponse;

			if(e.curlresponse == CURLE_COULDNT_CONNECT) {
				client.reset();

				setRunesEnabled(false);
			}
		}
	}
}

void RuneManager::saveRunePageAA(int id, QString name, const RunePage& rp) {
	if(!config) return;

	Config::RootConfig& rc = config->getConfig();
	auto& pages = rc.runepagesConfig.runePages;
	if(id == -1) {
		// int newId = pages.size();
		pages.push_back(std::make_shared<Config::RunePageConfig>(name, rp));
	} else {
		if((int) pages.size() > id && id >= 0) {
			pages.at(id)->runepage = rp;
			pages.at(id)->name = name;
		} else {
			// unkown id
			qWarning() << "unknown runepage id:" << id;
		}
	}

	config->save();

	// reload runes
	ui->listaaRunes->loadRunePages(pages);
}

void RuneManager::deleteRunepageClient(int id) {
	if(client) {
		try {
			if(!client->deleteRunePage(id)) {
				// TODO: some error occured
			}
		} catch(RestClient::WebException& e) {
			qCritical() << "webexception: " << e.curlresponse;

			if(e.curlresponse == CURLE_COULDNT_CONNECT) {
				client.reset();

				setRunesEnabled(false);
			}
		}
	}
}

void RuneManager::deleteRunepageAA(int id) {
	if(!config) return;

	Config::RootConfig& rc = config->getConfig();
	auto& pages = rc.runepagesConfig.runePages;
	if((int) pages.size() > id && id >= 0) {
		pages.erase(pages.begin() + id);

		config->save();

		ui->listaaRunes->loadRunePages(pages);
	} else {
		// unkown id
		qWarning() << "unknown runepage id:" << id;
	}
}

void RuneManager::autoSyncToggled() {
	bool autoSync = (ui->chkAutoCopy->isChecked());
	if(config) {
		config->getConfig().runepagesConfig.autoSync = autoSync;
		config->save();
	}

	if(autoSync) {
		syncRunes();
	}
}

void RuneManager::syncRunes() {
	qInfo() << "syncing" << ui->listClientRunes->count() << "runes";

	std::vector<std::shared_ptr<Config::RunePageConfig>>& configs = config->getConfig().runepagesConfig.runePages;
	bool changed = false;

	for(int i = 0; i < ui->listClientRunes->count(); ++i) {
		const QListWidgetItem* item = ui->listClientRunes->item(i);
		QString name = item->text();
		const RunePage* rp = (RunePage*) item->data(RunePageList::RolePointer).toULongLong();

		auto itFound = std::find_if(configs.cbegin(), configs.cend(), [name, rp](const std::shared_ptr<Config::RunePageConfig>& rpc){
			return rpc->name == name && *rp == rpc->runepage;
		});

		if(itFound == configs.cend()) {
			// no duplicate found -> add it
			configs.push_back(std::make_shared<Config::RunePageConfig>(name, *rp));
			changed = true;
		}
	}

	if(changed) {
		config->save();
		ui->listaaRunes->loadRunePages(configs);
	}
}

void RuneManager::reloadAARunes() {
	if(!config) return;

	const auto& pages = config->getConfig().runepagesConfig.runePages;

	// reload runes
	ui->listaaRunes->loadRunePages(pages);
}