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

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

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

RuneEditor::RuneEditor(QWidget* parent) : QDialog(parent), ui(new Ui::RuneEditor) {
	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) {
			QPushButton* runeStyleBtn = createStyleButton(rs, rs.id == runepage.primaryStyle);

			if(!runeStyleBtn) continue;

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

			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;

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

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

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

			if(!subStyleBtn) continue;

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

			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;

		clearLayout(ui->substylePerks);

		// populate perks
		fillRuneStyle(ui->substylePerks, *substyle, true);
	}
}

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

void RuneEditor::aspectCliecked() {
	// do something?
}

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

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

	return styleBtn;
}

RuneAspektButton* RuneEditor::createAspektButton(const RuneAspekt& ra) {
	RuneAspektButton* aspektBtn = createButtonFromResource(ra.iconPath);

	if(!aspektBtn) return nullptr;

	aspektBtn->setText(ra.name);
	aspektBtn->setToolTip(ra.tooltip);

	aspektBtn->setAspektsVector(runepage.selectedAspects);
	aspektBtn->setAspektId(ra.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);

	QObject::connect(this, &RuneEditor::selectionChanged, rab, &RuneAspektButton::dataChanged);
	QObject::connect(rab, &RuneAspektButton::aspektToggled, this, &RuneEditor::aspectCliecked);
	QObject::connect(rab, &RuneAspektButton::aspektToggled, this, &RuneEditor::selectionChanged);

	return rab;
}

void RuneEditor::fillRuneStyle(QGridLayout* target, const RuneStyle& rs, bool subRunes) {
	int row = 0;
	for(size_t idx = 0; idx < rs.runeSlots.size(); ++idx) {
		const RuneStyleSlot& rss = rs.runeSlots.at(idx);

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

		int rowOffset = 0;
		if(subRunes) {
			rowOffset = 4;
			if(row > 0) {
				rowOffset = 3;
			}
		} else {
			if(row >= 4) {
				rowOffset = 2;
			}
		}

		for(int perkNr = 0; perkNr < (int) rss.perks.size(); ++perkNr) {
			uint32_t perk = rss.perks.at(perkNr);
			auto itFound = std::find_if(aspekts.cbegin(), aspekts.cend(), [perk](const RuneAspekt& ra) {
				return ra.id == perk;
			});

			if(itFound == aspekts.cend()) {
				continue;
			}

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

			aspektBtn->setAspketSlot(row + rowOffset);

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

		++ row;
	}
}

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