#include "pivariant_edit_widgets.h"

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

#include <QEvent>
#include <QMessageBox>

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,     Q2PIString(widget->prefix())},
		{Attribute::suffix,     Q2PIString(widget->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) {
	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->setPrefix(PI2QString(a.value(Attribute::prefix, Q2PIString(widget->prefix())).toString()));
	widget->setSuffix(PI2QString(a.value(Attribute::suffix, Q2PIString(widget->suffix())).toString()));
	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,     Q2PIString(widget->prefix())},
		{Attribute::suffix,     Q2PIString(widget->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) {
	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->setPrefix(PI2QString(a.value(Attribute::prefix, Q2PIString(widget->prefix())).toString()));
	widget->setSuffix(PI2QString(a.value(Attribute::suffix, Q2PIString(widget->suffix())).toString()));
	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

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