#include "nmDataFault.h"

nmDataFault::nmDataFault()
  : m_bSyncingEndPoints(false) {
  QStringList lengthUnits;
  lengthUnits << "m" << "cm" << "mm" << "in" << "0.1 in" << "ft" << "mile" << "km";
  m_startX = nmDataAttribute("Fault start X", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), lengthUnits);
  m_startY = nmDataAttribute("Fault start Y", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), lengthUnits);
  m_endX = nmDataAttribute("Fault end X", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), lengthUnits);
  m_endY = nmDataAttribute("Fault end Y", 0.0, "m", UNIT_TYPE_LENGTH, QStringList(), lengthUnits);
  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;

  this->connectAttributeSignals();
}

nmDataFault::nmDataFault(const nmDataFault& other)
  : m_bSyncingEndPoints(false) {
  *this = other;
  this->connectAttributeSignals();
}

nmDataFault& nmDataFault::operator=(const nmDataFault& other) {
  if (this != &other) {
    m_sFaultName = other.m_sFaultName;
    m_vecPts = other.m_vecPts;
    m_startX = other.m_startX;
    m_startY = other.m_startY;
    m_endX = other.m_endX;
    m_endY = other.m_endY;
    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();
	}

	syncEndPointAttributes();
}

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

nmDataAttribute& nmDataFault::getStartX()
{
  return m_startX;
}

nmDataAttribute& nmDataFault::getStartY()
{
  return m_startY;
}

nmDataAttribute& nmDataFault::getEndX()
{
  return m_endX;
}

nmDataAttribute& nmDataFault::getEndY()
{
  return m_endY;
}

// 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;
}

// 批量赋值不会触发属性信号，通过对象级信号统一刷新关联视图。
void nmDataFault::notifyDataChanged()
{
  emit sigFaultDataChanged();
}

// 端点属性负责坐标回写，其余属性直接转发为断层数据变化信号。
void nmDataFault::connectAttributeSignals()
{
  connect(&m_startX, SIGNAL(sigValueChanged()), this, SLOT(onEndPointAttributeChanged()), Qt::UniqueConnection);
  connect(&m_startY, SIGNAL(sigValueChanged()), this, SLOT(onEndPointAttributeChanged()), Qt::UniqueConnection);
  connect(&m_endX, SIGNAL(sigValueChanged()), this, SLOT(onEndPointAttributeChanged()), Qt::UniqueConnection);
  connect(&m_endY, SIGNAL(sigValueChanged()), this, SLOT(onEndPointAttributeChanged()), Qt::UniqueConnection);

  connect(&m_faultFlowModel, SIGNAL(sigValueChanged()), this, SIGNAL(sigFaultDataChanged()), Qt::UniqueConnection);
  connect(&m_faultLeakage, SIGNAL(sigValueChanged()), this, SIGNAL(sigFaultDataChanged()), Qt::UniqueConnection);
}

// 图元或文件数据变化后，将点集首尾坐标同步到面板绑定属性。
void nmDataFault::syncEndPointAttributes()
{
  if (m_vecPts.size() < 2) {
    return;
  }

  m_bSyncingEndPoints = true;
  const QPointF& start = m_vecPts.first();
  const QPointF& end = m_vecPts.last();
  if (m_startX.getValue().toDouble() != start.x()) m_startX.setValue(start.x());
  if (m_startY.getValue().toDouble() != start.y()) m_startY.setValue(start.y());
  if (m_endX.getValue().toDouble() != end.x()) m_endX.setValue(end.x());
  if (m_endY.getValue().toDouble() != end.y()) m_endY.setValue(end.y());
  m_bSyncingEndPoints = false;
}

// 参数面板修改端点坐标后，回写真实点集并通知 Binder 更新图元。
void nmDataFault::onEndPointAttributeChanged()
{
  if (m_bSyncingEndPoints || m_vecPts.size() < 2) {
    return;
  }

  m_vecPts.first().setX(m_startX.getValue().toDouble());
  m_vecPts.first().setY(m_startY.getValue().toDouble());
  m_vecPts.last().setX(m_endX.getValue().toDouble());
  m_vecPts.last().setY(m_endY.getValue().toDouble());

  emit sigFaultDataChanged();
}