#include "nmDataLayer.h"
//#include "ZxSerializer.h"

    nmDataLayer::nmDataLayer()
{
    m_top = 0.0;
    m_bottom = 0.0;
    m_thickness = 0.0;
    m_isChecked = false;

    //checkXmlTable();
}

nmDataLayer::nmDataLayer(const nmDataLayer &other)
{
    if (this == &other)
    {
        return;
    }
    m_top = other.m_top;
    m_bottom = other.m_bottom;
    m_thickness = other.m_thickness;
    m_isChecked = other.m_isChecked;
	m_color = other.m_color;
}

// 单例模式实现
nmDataLayer* nmDataLayer::s_instance = NULL;

nmDataLayer* nmDataLayer::getInstance()
{
    if (NULL == s_instance) {
        s_instance = new nmDataLayer();
    }
    return s_instance;
}

nmDataLayer::~nmDataLayer()
{
}

nmDataLayer &nmDataLayer::operator = (const nmDataLayer &other)
{
    m_top = other.m_top;
    m_bottom = other.m_bottom;
    m_thickness = other.m_thickness;
    m_isChecked = other.m_isChecked;
	m_color = other.m_color;

    return *this;
}

// 序列化 nmDataLayer 为 RapidJSON Value
rapidjson::Value nmDataLayer::ToJsonValue(rapidjson::Document::AllocatorType& allocator) const
{
	// 创建一个 RapidJSON 对象类型的值
	rapidjson::Value layObject(rapidjson::kObjectType);
	layObject.AddMember("top",       m_top,       allocator);
	layObject.AddMember("bottom",    m_bottom,    allocator);
	layObject.AddMember("thickness", m_thickness, allocator);
	layObject.AddMember("isChecked", m_isChecked, allocator);

	// 颜色序列化为一个子对象，包含 r/g/b/a
	rapidjson::Value colorObject(rapidjson::kObjectType);
	colorObject.AddMember("r", m_color.red(),   allocator);
	colorObject.AddMember("g", m_color.green(), allocator);
	colorObject.AddMember("b", m_color.blue(),  allocator);
	colorObject.AddMember("a", m_color.alpha(), allocator);

	layObject.AddMember("color", colorObject, allocator);

	return layObject; // 返回序列化后的 RapidJSON Value
}

// 从 RapidJSON Value 反序列化数据到 nmDataLayer
void nmDataLayer::FromJsonValue(const rapidjson::Value& jsonValue)
{
	if (jsonValue.HasMember("top") && jsonValue["top"].IsNumber())
	{
		m_top = jsonValue["top"].GetDouble();
	}

	if (jsonValue.HasMember("bottom") && jsonValue["bottom"].IsNumber())
	{	
		m_bottom = jsonValue["bottom"].GetDouble();
	}
	if (jsonValue.HasMember("thickness") && jsonValue["thickness"].IsNumber())
	{
		m_thickness = jsonValue["thickness"].GetDouble();
	}
	if (jsonValue.HasMember("isChecked") && jsonValue["isChecked"].IsBool())
	{
		m_isChecked = jsonValue["isChecked"].GetBool();
	}
	// 反序列化颜色
	if (jsonValue.HasMember("color") && jsonValue["color"].IsObject())
	{
		const rapidjson::Value& colorValue = jsonValue["color"];
		int r = 0, g = 0, b = 0, a = 255;

		if (colorValue.HasMember("r") && colorValue["r"].IsInt())
			r = colorValue["r"].GetInt();
		if (colorValue.HasMember("g") && colorValue["g"].IsInt())
			g = colorValue["g"].GetInt();
		if (colorValue.HasMember("b") && colorValue["b"].IsInt())
			b = colorValue["b"].GetInt();
		if (colorValue.HasMember("a") && colorValue["a"].IsInt())
			a = colorValue["a"].GetInt();

		m_color = QColor(r, g, b, a);
	}
}

//ZxDataObject* nmDataLayer::clone()
//{
//	ensureLoaded();
//
//	return (new nmDataLayer(*this));
//}

QString nmDataLayer::type() const
{
    return nmDataModelType::sTypeNumDataLayer;
}

QString nmDataLayer::getTableName()
{
    return nmDataTableName::sTableNumDataLayer;
}

void nmDataLayer::setTop(double value)
{
    m_top = value;
}

double nmDataLayer::getTop() const
{
    //ensureLoaded();
    return m_top;
}

void nmDataLayer::setBottom(double value)
{
    m_bottom = value;
}

double nmDataLayer::getBottom() const
{
    //ensureLoaded();
    return m_bottom;
}

void nmDataLayer::setThickness(double value)
{
    m_thickness = value;
}

double nmDataLayer::getThickness() const
{
    //ensureLoaded();
    return m_thickness;
}

void nmDataLayer::setIsChecked(bool value)
{
    m_isChecked = value;
}

bool nmDataLayer::getIsChecked() const
{
    return m_isChecked;
}

//bool nmDataLayer::_parseData(VecVariant vec, int& n)
//{
//    m_top = vec.at(n++).toDouble();
//    m_bottom = vec.at(n++).toDouble();
//    m_thickness = vec.at(n++).toDouble();
//    m_isChecked = vec.at(n++).toBool();
//
//    return ZxDataObjectDbl::_parseData(vec, n);
//}
//
//bool nmDataLayer::_sumUpData(VecVariant& vec)
//{
//    ensureLoaded();
//
//    vec.append(m_top);
//    vec.append(m_bottom);
//    vec.append(m_thickness);
//    vec.append(m_isChecked);
//
//    return ZxDataObjectDbl::_sumUpData(vec);
//}
//
//void nmDataLayer::onSerialize(ZxSerializer* ser)
//{
//    ZxDataObjectDbl::onSerialize(ser);
//
//    ser->write("Top", m_top);
//    ser->write("Bottom", m_bottom);
//    ser->write("Thickness", m_thickness);
//    ser->write("IsChecked", m_isChecked);
//}
//
//void nmDataLayer::onDeserialize(ZxSerializer* ser)
//{
//    ZxDataObjectDbl::onDeserialize(ser);
//
//    ser->read("Top", m_top);
//    ser->read("Bottom", m_bottom);
//    ser->read("Thickness", m_thickness);
//    ser->read("IsChecked", m_isChecked);
//}

//QIcon nmDataLayer::getIcon(bool expanded) const
//{
//    return zxLoadIcon("DataLayer");
//}

void nmDataLayer::setColor(const QColor& value)
{
	m_color = value;
}

QColor nmDataLayer::getColor() const
{
	return m_color;
}