#include "nmDataFracture.h"

#include <QVariant>
#include <QVector>
#include "nmDataJsonTools.h"

#include <QPointF> // 确保 QPointF 被包含
#include <QVariantMap> // 确保 QVariantMap 被包含
#include <QVariantList> // 确保 QVariantList 被包含

nmDataFracture::nmDataFracture() {
  m_fractureFlowModel = nmDataAttribute("Fracture flow model", "Finite Conductivity","",UNIT_TYPE_DIMENSIONLESS, QStringList() << "Infinite Conductivity" << "Finite Conductivity", QStringList());
  m_fractureDfc = nmDataAttribute("Fracture dFc", 1, "md.m", UNIT_TYPE_CONDUCTIVITY, QStringList(), QStringList() << "md.ft" << "md.m" << "m^3");
  m_fractureDw = nmDataAttribute("Fracture dW", 1, "", UNIT_TYPE_DIMENSIONLESS, QStringList(), QStringList());
  // 默认裂缝类型是普通裂缝
  m_fractureType = nmDataAttribute("Fracture type", "Normal","", UNIT_TYPE_DIMENSIONLESS, QStringList() << "Normal" << "DFN", QStringList());

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

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

nmDataFracture& nmDataFracture::operator=(const nmDataFracture& other) {
  if (this != &other) {
    m_sFractureName = other.m_sFractureName;
    m_vecPts = other.m_vecPts;
    m_fractureFlowModel = other.m_fractureFlowModel;
    m_fractureDfc = other.m_fractureDfc;
    m_fractureDw = other.m_fractureDw;
    m_fractureType = other.m_fractureType;

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

nmDataFracture::~nmDataFracture() {
}


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

	// 序列化裂缝名称 (m_sFractureName)
	// 将 QString 转换为 UTF-8 编码的 C 字符串，并添加到 JSON 中
        fractureObject.AddMember("FractureName", rapidjson::Value(m_sFractureName.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);     // 将点对象推入数组
	}
	fractureObject.AddMember("FracturePoints", pointsArray, allocator); // 将点数组添加到JSON对象

	// 序列化 nmDataAttribute 类型的成员 (m_fractureFlowModel, m_fractureDfc, m_fractureDw, m_fractureType)
	// 调用 nmDataAttribute 自身的 ToJsonValue 方法进行递归序列化
	fractureObject.AddMember("FractureFlowModel", m_fractureFlowModel.ToJsonValue(allocator), allocator);
	fractureObject.AddMember("FractureDfc", m_fractureDfc.ToJsonValue(allocator), allocator);
	fractureObject.AddMember("FractureDw", m_fractureDw.ToJsonValue(allocator), allocator);
	fractureObject.AddMember("FractureType", m_fractureType.ToJsonValue(allocator), allocator);

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

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

// 从 RapidJSON Value 反序列化数据到 nmDataFracture
void nmDataFracture::FromJsonValue(const rapidjson::Value& jsonValue)
{
	// 反序列化裂缝名称 (m_sFractureName)
	if (jsonValue.HasMember("FractureName") && jsonValue["FractureName"].IsString()) {
		m_sFractureName = QString::fromUtf8(jsonValue["FractureName"].GetString());
	}

	// 反序列化裂缝点 (m_vecPts)
	if (jsonValue.HasMember("FracturePoints") && jsonValue["FracturePoints"].IsArray()) {
		m_vecPts.clear(); // 清空当前点列表，使用m_vecPts
		const rapidjson::Value& pointsArray = jsonValue["FracturePoints"]; // 获取点数组节点
		// 遍历数组，将每个点对象反序列化到 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_fractureFlowModel, m_fractureDfc, m_fractureDw, m_fractureType)
	// 调用 nmDataAttribute 自身的 FromJsonValue 方法进行递归反序列化
	if (jsonValue.HasMember("FractureFlowModel") && jsonValue["FractureFlowModel"].IsObject()) {
		m_fractureFlowModel.FromJsonValue(jsonValue["FractureFlowModel"]);
	}
	if (jsonValue.HasMember("FractureDfc") && jsonValue["FractureDfc"].IsObject()) {
		m_fractureDfc.FromJsonValue(jsonValue["FractureDfc"]);
	}
	if (jsonValue.HasMember("FractureDw") && jsonValue["FractureDw"].IsObject()) {
		m_fractureDw.FromJsonValue(jsonValue["FractureDw"]);
	}
	if (jsonValue.HasMember("FractureType") && jsonValue["FractureType"].IsObject()) {
		m_fractureType.FromJsonValue(jsonValue["FractureType"]);
	}

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

// Getter and Setter for m_sFractureName
QString nmDataFracture::getFractureName() const
{
  return m_sFractureName;
}

void nmDataFracture::setFractureName(const QString& sFractureName)
{
  m_sFractureName = sFractureName;
}

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

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

// Getter and Setter for m_fractureFlowModel
nmDataAttribute& nmDataFracture::getFractureFlowModel()
{
  return m_fractureFlowModel;
}

void nmDataFracture::setFractureFlowModel(const nmDataAttribute& fractureFlowModel)
{
  m_fractureFlowModel = fractureFlowModel;
}

// Getter and Setter for m_fractureDfc
nmDataAttribute& nmDataFracture::getFractureDfc()
{
  return m_fractureDfc;
}

void nmDataFracture::setFractureDfc(const nmDataAttribute& fractureDfc)
{
  m_fractureDfc = fractureDfc;
}

// Getter and Setter for m_fractureDw
nmDataAttribute& nmDataFracture::getFractureDw()
{
  return m_fractureDw;
}

void nmDataFracture::setFractureDw(const nmDataAttribute& fractureDw)
{
  m_fractureDw = fractureDw;
}

nmDataAttribute& nmDataFracture::getFractureType()
{
  return m_fractureType;
}

void nmDataFracture::setFractureType(const nmDataAttribute& fractureType)
{
  m_fractureType = fractureType;
}

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

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