#include "nmDataFault.h"

nmDataFault::nmDataFault(){
  m_faultFlowModel = nmDataAttribute("Fault flow model", "Leaky","", UNIT_TYPE_DIMENSIONLESS, QStringList() << "Leaky" << "Composite limit", QStringList());
  m_faultLeakage = nmDataAttribute("Fault leakage", 1.0,"",UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());

  // 图元可见性，默认为true
  m_bPlotVisible = true;
}

nmDataFault::nmDataFault(const nmDataFault& other){
  *this = other;
}

nmDataFault& nmDataFault::operator=(const nmDataFault& other) {
  if (this != &other) {
    m_sFaultName = other.m_sFaultName;
    m_vecPts = other.m_vecPts;
    m_faultFlowModel = other.m_faultFlowModel;
    m_faultLeakage = other.m_faultLeakage;

    m_bPlotVisible = other.m_bPlotVisible;
  }
  return *this;
}

nmDataFault::~nmDataFault()
{
}

// 序列化 nmDataFault 为 RapidJSON Value
rapidjson::Value nmDataFault::ToJsonValue(rapidjson::Document::AllocatorType& allocator) const
{
	// 创建一个 RapidJSON 对象类型的值
	rapidjson::Value faultObject(rapidjson::kObjectType);

	// 序列化断层名称 (m_sFaultName)
	// 将 QString 转换为 UTF-8 编码的 C 字符串，并添加到 JSON 中
	faultObject.AddMember("FaultName", rapidjson::Value(m_sFaultName.toStdString().c_str(), allocator).Move(), allocator);

	// 序列化断层点 (m_vecPts)
	rapidjson::Value pointsArray(rapidjson::kArrayType); // 创建一个 RapidJSON 数组类型的值
	foreach (const QPointF& point , m_vecPts) {
		rapidjson::Value pointObject(rapidjson::kObjectType); // 创建一个点对象
		pointObject.AddMember("x", point.x(), allocator); // 添加x坐标
		pointObject.AddMember("y", point.y(), allocator); // 添加y坐标
		pointsArray.PushBack(pointObject, allocator); // 将点对象推入数组
	}
	faultObject.AddMember("FaultPoints", pointsArray, allocator); // 将点数组添加到JSON对象

	// 序列化 nmDataAttribute 类型的成员 (m_faultFlowModel 和 m_faultLeakage)
	// 调用 nmDataAttribute 自身的 ToJsonValue 方法进行递归序列化
	faultObject.AddMember("FaultFlowModel", m_faultFlowModel.ToJsonValue(allocator), allocator);
	faultObject.AddMember("FaultLeakage", m_faultLeakage.ToJsonValue(allocator), allocator);

	// 序列化图元可见性 (m_bPlotVisible)
	faultObject.AddMember("PlotVisible", m_bPlotVisible, allocator);

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

// 从 RapidJSON Value 反序列化数据到 nmDataFault
void nmDataFault::FromJsonValue(const rapidjson::Value& jsonValue)
{
	// 反序列化断层名称 (m_sFaultName)
	if (jsonValue.HasMember("FaultName") && jsonValue["FaultName"].IsString()) {
		m_sFaultName = QString::fromUtf8(jsonValue["FaultName"].GetString());
	}

	// 反序列化断层点 (m_vecPts)
	if (jsonValue.HasMember("FaultPoints") && jsonValue["FaultPoints"].IsArray()) {
		m_vecPts.clear(); // 清空当前点列表
		const rapidjson::Value& pointsArray = jsonValue["FaultPoints"]; // 获取点数组节点
		// 遍历数组，将每个点对象反序列化到 m_vecPts
		for (rapidjson::SizeType i = 0; i < pointsArray.Size(); ++i) {
			if (pointsArray[i].IsObject() &&
				pointsArray[i].HasMember("x") && pointsArray[i]["x"].IsDouble() &&
				pointsArray[i].HasMember("y") && pointsArray[i]["y"].IsDouble()) {
					m_vecPts.append(QPointF(pointsArray[i]["x"].GetDouble(), pointsArray[i]["y"].GetDouble()));
			}
		}
	}

	// 反序列化 nmDataAttribute 类型的成员 (m_faultFlowModel 和 m_faultLeakage)
	// 调用 nmDataAttribute 自身的 FromJsonValue 方法进行递归反序列化
	if (jsonValue.HasMember("FaultFlowModel") && jsonValue["FaultFlowModel"].IsObject()) {
		m_faultFlowModel.FromJsonValue(jsonValue["FaultFlowModel"]);
	}
	if (jsonValue.HasMember("FaultLeakage") && jsonValue["FaultLeakage"].IsObject()) {
		m_faultLeakage.FromJsonValue(jsonValue["FaultLeakage"]);
	}

	// 反序列化图元可见性 (m_bPlotVisible)
	if (jsonValue.HasMember("PlotVisible") && jsonValue["PlotVisible"].IsBool()) {
		m_bPlotVisible = jsonValue["PlotVisible"].GetBool();
	}
}

/// Getter and Setter for m_faultName
QString nmDataFault::getFaultName() const
{
  return m_sFaultName;
}

void nmDataFault::setFaultName(const QString& faultName)
{
  m_sFaultName = faultName;
}

// Getter and Setter for m_vecPts
QVector<QPointF> nmDataFault::getFaultPoints() const
{
  return m_vecPts;
}

void nmDataFault::setFaultPoints(const QVector<QPointF>& vecPts)
{
  m_vecPts = vecPts;
}

// Getter and Setter for m_faultFlowModel
nmDataAttribute& nmDataFault::getFaultFlowModel()
{
  return m_faultFlowModel;
}

void nmDataFault::setFaultFlowModel(const nmDataAttribute& faultFlowModel)
{
  m_faultFlowModel = faultFlowModel;
}

// Getter and Setter for m_faultLeakage
nmDataAttribute& nmDataFault::getFaultLeakage()
{
  return m_faultLeakage;
}

void nmDataFault::setFaultLeakage(const nmDataAttribute& faultLeakage)
{
  m_faultLeakage = faultLeakage;
}

bool nmDataFault::getPlotVisible() const{
  return m_bPlotVisible;
}

void nmDataFault::setPlotVisible(const bool newState) {
  m_bPlotVisible = newState;
}