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

#include <QDebug>
#include <QListWidgetItem>

#include "clientapi.h"

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

	ui->listClientRunes->setClient(true);
	ui->listaaRunes->setClient(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);

	loadRunes();
}

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::loadRunes() {
	this->ui->btnRetry->setEnabled(false);
	QCoreApplication::processEvents();

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

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

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

		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);

		// check if autosync is enabled
		if(config && config->getConfig().runepagesConfig.autoSync) {
			syncRunes();
		}
	}

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


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

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

		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
			}
		}
	}
}

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) {
		if(!client->deleteRunePage(id)) {
			// TODO: some error occured
		}
	}
}

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);
	}
}