#include "runeeditor.h"
#include "ui_runeeditor.h"

#include <QByteArray>
#include <QDebug>
#include <QGridLayout>
#include <QPixmap>
#include <QPushButton>

#include "clientapi.h"
#include "runeaspektbutton.h"
#include "runeaspektbuttongroup.h"

RuneEditor::RuneEditor(QWidget* parent) : QDialog(parent), ui(new Ui::RuneEditor), groups(8, nullptr) {
	ui->setupUi(this);

	QObject::connect(ui->buttonBox, &QDialogButtonBox::accepted, this, &RuneEditor::accept);
	QObject::connect(ui->buttonBox, &QDialogButtonBox::rejected, this, &RuneEditor::reject);
}

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

void RuneEditor::setClient(ClientAPI& client) {
	this->client = &client;

	if(!this->client) return;

	try {
		// build ui
		aspekts = client.getAllRuneAspekts();
		styles = client.getAllRuneStyles();

		for(const RuneStyle& rs : styles) {
			RuneAspektButton* runeStyleBtn = createStyleButton(rs, rs.id == runepage.primaryStyle);

			if(!runeStyleBtn) continue;

			QObject::connect(runeStyleBtn, &QPushButton::pressed, [this, id = rs.id](){
				selectStyle(id);
			});
			QObject::connect(this, &RuneEditor::selectPrimary, runeStyleBtn, &RuneAspektButton::checkSelection);

			ui->style->addWidget(runeStyleBtn);
		}
	} catch(RestClient::WebException& e) {
		qCritical() << "webexception: " << e.curlresponse;

		if(e.curlresponse == CURLE_COULDNT_CONNECT) {
			this->client = nullptr;
		}
	}
}

void RuneEditor::setRunepage(const ::RunePage& rp) {
	qInfo() << "runepage: " << rp.selectedAspects.size();

	selectStyle(rp.primaryStyle);
	selectSubStyle(rp.secondaryStyle);

	runepage = rp;
	uint32_t offset = 0;
	for(RuneAspektButtonGroup* group : groups) {
		if(!group) continue;

		QVector<int> selected(group->getSize(), 0);
		for(uint32_t i = 0; i < group->getSize(); ++i) {
			selected.replace(i, rp.selectedAspects.at(offset));
			offset++;
		}
		group->setSelectedRunes(selected);
	}

	emit selectionChanged();
}

void RuneEditor::selectStyle(uint32_t id) {
	if(runepage.primaryStyle == id) return;

	const RuneStyle* style = getRuneStyle(id);

	if(style) {
		runepage.primaryStyle = id;
		runepage.secondaryStyle = 0;
		runepage.selectedAspects.clear();
		runepage.selectedAspects.resize(9, 0);

		emit selectPrimary(id);

		clearLayout(ui->substyle);
		clearLayout(ui->stylePerks);
		clearLayout(ui->substylePerks);

		// populate substyles
		for(int subStyleId : style->allowedSubStyles) {
			const RuneStyle* substyle = getRuneStyle(subStyleId);
			RuneAspektButton* subStyleBtn = createStyleButton(*substyle, false);

			if(!subStyleBtn) continue;

			QObject::connect(subStyleBtn, &QPushButton::pressed, [this, subStyleId](){
				selectSubStyle(subStyleId);
			});

			QObject::connect(this, &RuneEditor::selectSecondary, subStyleBtn, &RuneAspektButton::checkSelection);

			ui->substyle->addWidget(subStyleBtn);
		}

		// populate perks
		fillRuneStyle(ui->stylePerks, *style);
	}
}

void RuneEditor::selectSubStyle(uint32_t id) {
	if(runepage.secondaryStyle == id) return;

	const RuneStyle* substyle = getRuneStyle(id);

	if(substyle) {
		runepage.secondaryStyle = id;

		emit selectSecondary(id);

		clearLayout(ui->substylePerks);
		delete groups.at(4);

		QVector<QVector<int>> subgroups;
		subgroups.reserve(substyle->runeSlots.size());

		// populate perks
		RuneAspektButtonGroup* group = new RuneAspektButtonGroup(this, 2);
		for(size_t idx = 0; idx < substyle->runeSlots.size(); ++idx) {
			const RuneStyleSlot& rss = substyle->runeSlots.at(idx);
			QVector<int> subgroup;
			subgroup.reserve(rss.perks.size());

			if(rss.type != "kMixedRegularSplashable") continue;

			for(int perkNr = 0; perkNr < (int) rss.perks.size(); ++perkNr) {
				uint32_t perk = rss.perks.at(perkNr);
				subgroup.append((int) perk);

				RuneAspektButton* aspektBtn = createAspektButton(perk);
				if(!aspektBtn) continue;

				group->addButton(aspektBtn);

				ui->substylePerks->addWidget(aspektBtn, idx, perkNr);
			}

			subgroups.append(subgroup);
		}
		group->setSubgroups(subgroups);
		groups.replace(4, group);
	}
}

void RuneEditor::clearLayout(QLayout* layout) {
	while(layout->count()) {
		QLayoutItem* item = layout->takeAt(0);
		delete item->widget();
		delete item;
	}
}

void RuneEditor::setName(QString text) {
	ui->runepageName->setText(text);
}

QString RuneEditor::getName() const {
	return ui->runepageName->text();
}

const RunePage& RuneEditor::getRunepage() {
	runepage.selectedAspects.clear();
	runepage.selectedAspects.resize(9, 0);

	for(const RuneAspektButtonGroup* group : groups) {
		if(!group) continue;

		const QVector<int>& selected = group->getSelectedRunes();
		for(uint32_t i = 0; i < group->getSize(); ++i) {
			runepage.selectedAspects.push_back(selected.at(i));
		}
	}

	return runepage;
}

const RuneStyle* RuneEditor::getRuneStyle(uint32_t id) const {
	auto it = std::find_if(styles.cbegin(), styles.cend(), [id](const RuneStyle& rs) {
		return rs.id == id;
	});

	return it == styles.cend() ? nullptr : &*it;
}

RuneAspektButton* RuneEditor::createStyleButton(const RuneStyle& rs, bool selected) {
	RuneAspektButton* styleBtn = createButtonFromResource(rs.iconPath);

	if(!styleBtn) return nullptr;

	styleBtn->setText(rs.name);
	styleBtn->setToolTip(rs.tooltip);

	styleBtn->setAspektId(rs.id);

	if(selected) {
		styleBtn->setStyleSheet("border: 1px solid red;");
	}

	return styleBtn;
}

RuneAspektButton* RuneEditor::createAspektButton(uint32_t perk) {
	auto itFound = std::find_if(aspekts.cbegin(), aspekts.cend(), [perk](const RuneAspekt& ra) {
		return ra.id == perk;
	});

	if(itFound == aspekts.cend()) {
		return nullptr;
	}
	RuneAspektButton* aspektBtn = createButtonFromResource(itFound->iconPath);

	aspektBtn->setText(itFound->name);
	aspektBtn->setToolTip(itFound->tooltip);

	aspektBtn->setAspektId(itFound->id);

	return aspektBtn;
}

RuneAspektButton* RuneEditor::createButtonFromResource(QString resource) {
	if(!client) {
		return nullptr;
	}

	QPixmap icon;
	try {
		icon = client->getImageResource(resource.remove(0, 1));
	} catch(RestClient::WebException& e) {
		qCritical() << "webexception: " << e.curlresponse;

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

	RuneAspektButton* rab = new RuneAspektButton(this);
	rab->setIcon(icon);

	return rab;
}

void RuneEditor::fillRuneStyle(QGridLayout* target, const RuneStyle& rs) {
	for(size_t idx = 0; idx < rs.runeSlots.size(); ++idx) {
		const RuneStyleSlot& rss = rs.runeSlots.at(idx);
		RuneAspektButtonGroup* group = new RuneAspektButtonGroup(this, 1);

		for(int perkNr = 0; perkNr < (int) rss.perks.size(); ++perkNr) {
			uint32_t perk = rss.perks.at(perkNr);

			RuneAspektButton* aspektBtn = createAspektButton(perk);
			if(!aspektBtn) continue;

			group->addButton(aspektBtn);

			target->addWidget(aspektBtn, idx, perkNr);
		}

		groups.replace(idx + (idx > 3), group);
	}
}

QString RuneEditor::fixString(QString text) {
	return text.replace("&nbsp;", "").replace("</?.*?>", "");
}