#include "ui/Panel/SurfacePanel.h"
#include "ui/DockWidget.h"
#include "ui/DockTitleBar.h"
#include "common/SpdLogger.h"
#include <QHBoxLayout>
#include <QFileInfo>
#include <QMessageBox>
#include <Q3DCamera>

SurfacePanel::SurfacePanel(int index, const QString& filePath, QWidget* parent)
	: DataPanel(index, FileEntryType::Surface, filePath, parent)
{
	m_iMinX = 0; m_iMaxX = 0;
	m_iMinY = 0; m_iMaxY = 0;
	m_iMinZ = 0; m_iMaxZ = 0;

	LOG_INFO("Created SurfacePanel {} for file: {}", index, filePath.toStdString());
}

SurfacePanel::SurfacePanel(int index, std::shared_ptr<FileEntrySurface> fileEntry, QWidget* parent)
	: DataPanel(index, fileEntry, parent)
{
	m_iMinX = 0; m_iMaxX = 0;
	m_iMinY = 0; m_iMaxY = 0;
	m_iMinZ = 0; m_iMaxZ = 0;

	if (fileEntry) {
		LOG_INFO("Created SurfacePanel {} for chart: {}", index, fileEntry->GetName().toStdString());
		// Override the title with chart name
		title_ = QString("Surface Panel %1 - %2").arg(index).arg(fileEntry->GetName());
	}
	else {
		LOG_WARN("Created SurfacePanel {} with null chart data", index);
	}
}

SurfacePanel::~SurfacePanel()
{
	LOG_INFO("Destroyed SurfacePanel {}", GetIndex());
}

void SurfacePanel::RefreshPanel()
{
	// Implement curve-specific refresh logic here
	DataPanel::RefreshPanel();

	if (auto fileEntry = fileEntry_->AsSurface()) {
		OnDataPanelUpdated(fileEntry);
	}

	LOG_INFO("Refreshed TablePanel {}", GetIndex());
}

void SurfacePanel::InitUI()
{
	m_Surface.setFlags(m_Surface.flags());
	m_Surface.setFlipHorizontalGrid(false);

	m_p3DXAxis = new QValue3DAxis;
	m_p3DXAxis->setSegmentCount(10);
	m_p3DXAxis->setRange(-10, 10);

	m_p3DYAxis = new QValue3DAxis;
	m_p3DYAxis->setSegmentCount(10);
	m_p3DYAxis->setRange(-10, 10);

	m_p3DZAxis = new QValue3DAxis;
	m_p3DZAxis->setSegmentCount(10);
	m_p3DZAxis->setRange(-10, 10);

	m_Surface.setAxisX(m_p3DXAxis);
	m_Surface.setAxisY(m_p3DYAxis);
	m_Surface.setAxisZ(m_p3DZAxis);

	m_Surface.activeTheme()->setType(Q3DTheme::Theme(2));

	m_pSeries = new QSurface3DSeries;
	m_pSeries->setDrawMode(QSurface3DSeries::DrawSurface);
	m_Surface.addSeries(m_pSeries);

	QWidget* containerHandle = QWidget::createWindowContainer(&m_Surface);
	containerHandle->setAutoFillBackground(true);
	containerHandle->setAttribute(Qt::WA_OpaquePaintEvent, true);
	containerHandle->setAttribute(Qt::WA_NoSystemBackground, false);
	containerHandle->setUpdatesEnabled(false);
	containerHandle->setMinimumHeight(100);

	m_pSeries->setBaseColor(Qt::green);
	m_pSeries->setColorStyle(Q3DTheme::ColorStyleUniform);
	m_pSeries->setSingleHighlightColor(Qt::green);

	m_pSeries->setMeshSmooth(false);
	m_pSeries->setFlatShadingEnabled(false);

	m_Surface.scene()->activeCamera()->setCameraPreset(Q3DCamera::CameraPreset(13));

	QHBoxLayout* mainLayout = new QHBoxLayout(this);
	mainLayout->setContentsMargins(0, 0, 0, 0);
	mainLayout->addWidget(containerHandle);
	setLayout(mainLayout);
}

QString SurfacePanel::GetTypeDisplayName() const
{
	return "Surface";
}

void SurfacePanel::OnDataPanelUpdated(FileEntrySurface* fileEntry)
{
	QString strName = fileEntry->GetName();
	updateTitle(strName);

	FileEntrySurface::ChartProperties propChart = fileEntry->GetChartProperties();

	updateTitleAxis(propChart.xTitle, propChart.yTitle, propChart.zTitle);
	updateMinMaxX(propChart.xMin, propChart.xMax, propChart.xCount);
	updateMinMaxY(propChart.yMin, propChart.yMax, propChart.yCount);
	updateMinMaxZ(propChart.zMin, propChart.zMax, propChart.zCount);

	QString strFile = fileEntry->GetPath() + "/" + fileEntry->GetFileName();
	FileEntrySurface::SurfaceProperties listCurve = fileEntry->GetSurfaceProperties();
	updateParseFile(strFile, propChart.timeParam, listCurve);
}

void SurfacePanel::OnTimeChanged(double time)
{
	if (m_data.size() > 0)
	{
		m_pSeries->dataProxy()->resetArray(nullptr);

		QMap< double, QMap< int, QVector< QVector<QVector3D> > > >::const_iterator ite = m_data.lowerBound(time);
		if (ite == m_data.end())
		{
			ite--;
		}

		QMap< int, QVector< QVector<QVector3D> > > mapData = ite.value();
		for (QMap< int, QVector< QVector<QVector3D> > >::Iterator it = mapData.begin(); it != mapData.end(); it++)
		{
			int nIndex = it.key();
			QVector< QVector<QVector3D> > listRowData = it.value();

			QSurfaceDataArray* data = new QSurfaceDataArray;

			for (int nI = 0; nI < listRowData.size(); nI++)
			{
				QSurfaceDataRow* dataRow = new QSurfaceDataRow;

				QVector<QVector3D> listColData = listRowData[nI];
				for (int nJ = 0; nJ < listColData.size(); nJ++)
				{
					QVector3D v3d = listColData[nJ];
					*dataRow << v3d;
				}

				*data << dataRow;
			}

			m_pSeries->dataProxy()->resetArray(data);
		}
	}

	m_Surface.setShadowQuality(QAbstract3DGraph::ShadowQuality::ShadowQualityNone);
}

void SurfacePanel::updateTitle(const QString & title)
{
	if (nullptr != dockWidget_)
	{
		dockWidget_->setWindowTitle(title);
	}
}

void SurfacePanel::updateTitleAxis(const QString & xTitle, const QString & yTitle, const QString & zTitle)
{
	m_p3DXAxis->setTitle(xTitle);
	m_p3DXAxis->setTitleVisible(true);
	m_p3DYAxis->setTitle(yTitle);
	m_p3DYAxis->setTitleVisible(true);
	m_p3DZAxis->setTitle(zTitle);
	m_p3DZAxis->setTitleVisible(true);
}

void SurfacePanel::updateMinMaxX(float min, float max, int count)
{
	if (max > min)
	{
		m_iMinX = min;
		m_iMaxX = max;

		if (count > 0)
		{
			m_p3DXAxis->setSegmentCount(count);
		}
		m_p3DXAxis->setRange(min, max);
	}
}

void SurfacePanel::updateMinMaxY(float min, float max, int count)
{
	if (max > min)
	{
		m_iMinY = min;
		m_iMaxY = max;

		if (count > 0)
		{
			m_p3DYAxis->setSegmentCount(count);
		}
		m_p3DYAxis->setRange(min, max);
	}
}

void SurfacePanel::updateMinMaxZ(float min, float max, int count)
{
	if (max > min)
	{
		m_iMinZ = min;
		m_iMaxZ = max;

		if (count > 0)
		{
			m_p3DZAxis->setSegmentCount(count);
		}
		m_p3DZAxis->setRange(min, max);
	}
}

void SurfacePanel::updateParseFile(const QString & strFile, int nT, FileEntrySurface::SurfaceProperties listCurve)
{
	if (strFile.isEmpty())
	{
		QMessageBox::information(nullptr, QString::fromLocal8Bit("提示"), QString::fromLocal8Bit("请检查数据文件路径！"));
		return;
	}

	m_data.clear();
	m_pSeries->dataProxy()->resetArray(nullptr);

	QFile file(strFile);
	if (file.open(QIODevice::ReadOnly))
	{
		for (int nI = 0; nI < listCurve.size(); nI++)
		{
			FileEntrySurface::SurfaceProperty surface = listCurve.at(nI);

			QLinearGradient gr;
			gr.setColorAt(0.0, surface.color);
			gr.setColorAt(0.5, Qt::yellow);
			gr.setColorAt(0.8, Qt::red);
			gr.setColorAt(1.0, Qt::darkRed);

			m_pSeries->setBaseGradient(gr);
			m_pSeries->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
			//m_pSeries->setSingleHighlightColor(Qt::green);
		}

		bool bResetAxisX = false;
		if (m_iMaxX == m_iMinX)
		{
			bResetAxisX = true;
		}
		bool bResetAxisY = false;
		if (m_iMaxZ == m_iMinZ)
		{
			bResetAxisY = true;
		}
		bool bResetAxisZ = false;
		if (m_iMaxY == m_iMinY)
		{
			bResetAxisZ = true;
		}

		while (!file.atEnd())
		{
			QString strLine = file.readLine().simplified();
			if (!strLine.isEmpty())
			{
				QStringList listLine = strLine.split(" ");
				double t = listLine.at(nT).toDouble();

				QMap< int, QVector< QVector<QVector3D> > > mapData;
				for (int nI = 0; nI < listCurve.size(); nI++)
				{
					FileEntrySurface::SurfaceProperty surface = listCurve.at(nI);
					int nStart = surface.start;
					int nStop = surface.stop;
					if (nStart == 0)
					{
						nStart = 1;
					}
					if (nStop == 0)
					{
						nStop = listLine.size();
					}
					QString strX = surface.x;
					QString strY = surface.y;
					QString strZ = surface.z;

					double xInput = 0;
					double yInput = 0;
					double zInput = 0.0;
					QVector< QVector<QVector3D> > listRowData;
					int nRow = 0;
					int nCol = 0;
					for (int nJ = nStart; nJ < nStop; nJ += 3)
					{
						int x = listLine.at(nJ).toDouble();
						int y = listLine.at(nJ + 1).toDouble();
						double z = listLine.at(nJ + 2).toDouble();

						if (strX == "x")
						{
							xInput = x;
						}
						else if (strX == "y")
						{
							xInput = y;
						}
						else if (strX == "z")
						{
							xInput = z;
						}

						if (strY == "x")
						{
							yInput = x;
						}
						else if (strY == "y")
						{
							yInput = y;
						}
						else if (strY == "z")
						{
							yInput = z;
						}

						if (strZ == "x")
						{
							zInput = x;
						}
						else if (strZ == "y")
						{
							zInput = y;
						}
						else if (strZ == "z")
						{
							zInput = z;
						}

						QVector3D v3d = QVector3D(xInput, yInput, zInput);
						if (nRow == x)
						{
							int nIndex = listRowData.size() - 1;
							QVector<QVector3D> listColData = listRowData[nIndex];
							listColData.push_back(v3d);
							listRowData.replace(nIndex, listColData);
						}
						else
						{
							QVector<QVector3D> listColData;
							listColData.push_back(v3d);
							listRowData.push_back(listColData);
						}

						nRow = x;
						nCol = y;
					}
					mapData.insert(nI, listRowData);
				}
				m_data.insert(t, mapData);
			}
		}

		if (m_iMaxX == m_iMinX)
		{
			m_p3DXAxis->setAutoAdjustRange(true);
		}
		if (m_iMaxZ == m_iMinZ)
		{
			m_p3DZAxis->setAutoAdjustRange(true);
		}
		if (m_iMaxY == m_iMinY)
		{
			m_p3DYAxis->setAutoAdjustRange(true);
		}

		m_Surface.setHorizontalAspectRatio(1.0);

		file.close();
	}
}