#include "pivariant_edit_widgets.h"

#include "pivaluetree.h"
#include "pivariant_edit_enum.h"
#include "pivarianttypes.h"

#include <QEvent>
#include <QMessageBox>
#include <QToolButton>

REGISTER_PIVARIANTEDITOR(bool, PIVariantEditors::Bool);
REGISTER_PIVARIANTEDITOR(short, PIVariantEditors::Int);
REGISTER_PIVARIANTEDITOR(ushort, PIVariantEditors::Int);
REGISTER_PIVARIANTEDITOR(int, PIVariantEditors::Int);
REGISTER_PIVARIANTEDITOR(uint, PIVariantEditors::Int);
REGISTER_PIVARIANTEDITOR(float, PIVariantEditors::Double);
REGISTER_PIVARIANTEDITOR(double, PIVariantEditors::Double);
REGISTER_PIVARIANTEDITOR(PIString, PIVariantEditors::String);
REGISTER_PIVARIANTEDITOR(PITime, PIVariantEditors::Time);
REGISTER_PIVARIANTEDITOR(PIDate, PIVariantEditors::Date);
REGISTER_PIVARIANTEDITOR(PIDateTime, PIVariantEditors::DateTime);
REGISTER_PIVARIANTEDITOR(PIVariantTypes::Color, PIVariantEditors::Color);
REGISTER_PIVARIANTEDITOR(PIVariantTypes::Enum, PIVariantEditors::Enum);

using Attribute = PIValueTree::Attribute;

// PIVariantEditors::Int

PIVariantMap PIVariantEditors::Int::attributes() const {
	return {
		{Attribute::minimum,    widget->minimum()   },
		{Attribute::maximum,    widget->maximum()   },
		{Attribute::singleStep, widget->singleStep()},
		{Attribute::prefix,     prefix              },
		{Attribute::suffix,     suffix              },
	};
}


PIVariantMap PIVariantEditors::Int::defaultAttributes() {
	return {
		{Attribute::minimum,    -std::numeric_limits<int>::max()},
		{Attribute::maximum,    std::numeric_limits<int>::max() },
		{Attribute::singleStep, 1.                              },
		{Attribute::prefix,     ""							  },
		{Attribute::suffix,     ""							  },
	};
}


void PIVariantEditors::Int::applyAttributes(const PIVariantMap & a) {
	prefix = a.value(Attribute::prefix).toString();
	suffix = a.value(Attribute::suffix).toString();
	widget->setPrefix(PIVariantEditorBase::vtTr(prefix));
	widget->setSuffix(PIVariantEditorBase::vtTr(suffix));
	widget->setRange(a.value(Attribute::minimum, widget->minimum()).toInt(), a.value(Attribute::maximum, widget->maximum()).toInt());
	widget->setSingleStep(a.value(Attribute::singleStep, widget->singleStep()).toInt());
	widget->setReadOnly(a.value(Attribute::readOnly, widget->isReadOnly()).toBool());
}


// PIVariantEditors::Double

PIVariantMap PIVariantEditors::Double::attributes() const {
	return {
		{Attribute::minimum,    widget->minimum()   },
		{Attribute::maximum,    widget->maximum()   },
		{Attribute::singleStep, widget->singleStep()},
		{Attribute::decimals,   widget->decimals()  },
		{Attribute::prefix,     prefix              },
		{Attribute::suffix,     suffix              },
	};
}


PIVariantMap PIVariantEditors::Double::defaultAttributes() {
	return {
		{Attribute::minimum,    -std::numeric_limits<double>::max()},
		{Attribute::maximum,    std::numeric_limits<double>::max() },
		{Attribute::singleStep, 1.                                 },
		{Attribute::decimals,   3								  },
		{Attribute::prefix,     ""								 },
		{Attribute::suffix,     ""								 },
	};
}


void PIVariantEditors::Double::applyAttributes(const PIVariantMap & a) {
	prefix = a.value(Attribute::prefix).toString();
	suffix = a.value(Attribute::suffix).toString();
	widget->setPrefix(PIVariantEditorBase::vtTr(prefix));
	widget->setSuffix(PIVariantEditorBase::vtTr(suffix));
	widget->setRange(a.value(Attribute::minimum, widget->minimum()).toDouble(), a.value(Attribute::maximum, widget->maximum()).toDouble());
	widget->setSingleStep(a.value(Attribute::singleStep, widget->singleStep()).toDouble());
	widget->setDecimals(a.value(Attribute::decimals, widget->decimals()).toInt());
	widget->setReadOnly(a.value(Attribute::readOnly, widget->isReadOnly()).toBool());
}


// PIVariantEditors::String

PIVariantMap PIVariantEditors::String::attributes() const {
	return {};
}


PIVariantMap PIVariantEditors::String::defaultAttributes() {
	return {};
}


void PIVariantEditors::String::applyAttributes(const PIVariantMap & a) {
	widget->setReadOnly(a.value(Attribute::readOnly, widget->isReadOnly()).toBool());
}


// PIVariantEditors::Color

PIVariantMap PIVariantEditors::Color::attributes() const {
	return {
		{"useAlpha", widget->useAlphaChannel()},
	};
}


PIVariantMap PIVariantEditors::Color::defaultAttributes() {
	return {
		{"useAlpha", true},
	};
}


void PIVariantEditors::Color::applyAttributes(const PIVariantMap & a) {
	widget->setUseAlphaChannel(a.value("useAlpha", widget->useAlphaChannel()).toBool());
	widget->setEnabled(!a.value(Attribute::readOnly, !widget->isEnabled()).toBool());
}


// PIVariantEditors::Time

void PIVariantEditors::Time::applyAttributes(const PIVariantMap & a) {
	widget->setReadOnly(a.value(Attribute::readOnly, widget->isReadOnly()).toBool());
}


// PIVariantEditors::Date

void PIVariantEditors::Date::applyAttributes(const PIVariantMap & a) {
	widget->setReadOnly(a.value(Attribute::readOnly, widget->isReadOnly()).toBool());
}


// PIVariantEditors::DateTime

void PIVariantEditors::DateTime::applyAttributes(const PIVariantMap & a) {
	widget->setReadOnly(a.value(Attribute::readOnly, widget->isReadOnly()).toBool());
}


// PIVariantEditors::Enum

PIVariantEditors::Enum::Enum() {
	widget = new QComboBox();
	layout()->addWidget(widget);
	edit_widget = new QWidget();
	edit_widget->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
	edit_widget->setLayout(new QBoxLayout(QBoxLayout::LeftToRight));
	QMargins m = edit_widget->layout()->contentsMargins();
	m.setTop(0);
	m.setBottom(0);
	m.setRight(0);
	edit_widget->layout()->setContentsMargins(m);
	auto * b = new QToolButton();
	b->setIcon(QIcon(":/icons/document-edit.png"));
	connect(b, &QToolButton::clicked, this, [this]() {
		PIValueTreeEditEnum dlg;
		if (!dlg.showFor(src)) return;
		setValue(PIVariant(dlg.ret));
	});
	edit_widget->layout()->addWidget(b);
	layout()->setSpacing(0);
	layout()->addWidget(edit_widget);
	setFullEditMode(false);
}


void PIVariantEditors::Enum::setValue(const PIVariant & v) {
	src    = v.toEnum();
	int sv = src.selectedValue();
	widget->clear();
	for (const auto & e: src.enum_list) {
		widget->addItem(PI2QString(e.name), e.value);
		if (e.value == sv) widget->setCurrentIndex(widget->count() - 1);
	}
}


PIVariant PIVariantEditors::Enum::value() const {
	src.selectValue(widget->currentData().toInt());
	return src;
}


void PIVariantEditors::Enum::applyAttributes(const PIVariantMap & a) {
	widget->setEnabled(!a.value(Attribute::readOnly, !widget->isEnabled()).toBool());
}


void PIVariantEditors::Enum::setFullEditMode(bool on) {
	edit_widget->setVisible(on);
}