#include "nmWxAutomaticFitting.h"
#include "nmCalculationAutoFitPSO.h"
#include "nmWxAutomaticfittingStart.h"
#include "nmWxParameterProperty.h"
#include "nmDataAnalyzeManager.h"
#include <QApplication>
#include <QHeaderView>

#ifdef Q_OS_WIN
#include <windows.h>
#define DEBUG_UI(msg) OutputDebugStringA(QString("[UI] %1\n").arg(msg).toLocal8Bit().data())
#endif

nmWxAutomaticFitting::nmWxAutomaticFitting(QWidget *parent)
	: QDialog(parent)
	, m_autoFitterPSO(nullptr)
	, m_autoFitterGA(nullptr)
	, m_progressDialog(nullptr)
	, m_progressTimer(nullptr)
	, m_progressMonitor(nullptr)
	, m_selectedAlgorithm(ALGORITHM_PSO)  // 默认选择PSO算法
{
	DEBUG_UI(QString("AutoFitting Constructor: this=0x%1").arg((quintptr)this, 0, 16));

	// 加载已有井数据
    QVector<nmDataWellBase*> listWellData = nmDataAnalyzeManager::getCurrentInstance()->getWellDataList();

	// 遍历并分类井数据
	foreach (nmDataWellBase* well, listWellData) {
		if (auto vfWell = dynamic_cast<nmDataVerticalFracturedWell*>(well)) {
			m_verticalFracturedWells.append(*vfWell);
		}
		else if (auto hfWell = dynamic_cast<nmDataHorizontalFracturedWell*>(well)) {
			m_horizontalFracturedWells.append(*hfWell);
		}
		else if (auto vWell = dynamic_cast<nmDataVerticalWell*>(well)) {
			m_verticalWells.append(*vWell);
		}
		else if (auto hWell = dynamic_cast<nmDataHorizontalWell*>(well)) {
			m_horizontalWells.append(*hWell);
		}
	}

	// 获取数据
	reservoirData = nmDataAnalyzeManager::getCurrentInstance()->getReservoirDataCopy();
	automaticFittingData = nmDataAnalyzeManager::getCurrentInstance()->getAutomaticFittingDataCopy();

	setupUI();
	setWindowTitle(tr("Automatic fitting"));
	setModal(true);
	resize(800, 480);

	if(m_targetWellCombo->count() > 0) {
		onWellSelected(0); // 默认选中第一口井
	}

	DEBUG_UI("AutoFitting Constructor completed");
}

nmWxAutomaticFitting::~nmWxAutomaticFitting()
{
	DEBUG_UI(QString("AutoFitting Destructor: this=0x%1").arg((quintptr)this, 0, 16));
	DEBUG_UI("AutoFitting destructor - starting cleanup");

	// 停止定时器
	if (m_progressTimer) {
		m_progressTimer->stop();
	}

	// 断开所有连接，避免悬空指针
	if (m_autoFitterPSO) {
		disconnect(m_autoFitterPSO, nullptr, this, nullptr);
	}
	if (m_autoFitterGA) {
		disconnect(m_autoFitterGA, nullptr, this, nullptr);
	}

	DEBUG_UI("AutoFitting destructor - completed");
}

void nmWxAutomaticFitting::setupUI()
{
	m_mainLayout = new QVBoxLayout(this);

	// 创建主要内容的水平布局
	QHBoxLayout* contentLayout = new QHBoxLayout();

	// 添加左侧间距
	contentLayout->addSpacing(20);

	setupControlPanel();  // 左侧控制面板
	contentLayout->addLayout(m_controlLayout);

	// 添加控制面板和表格之间的间距
	contentLayout->addSpacing(30);

	setupParameterTable(); // 右侧参数表格
	contentLayout->addWidget(m_parameterTable, 1); // 设置拉伸因子为1，使表格可以扩展

	// 添加右侧间距
	contentLayout->addSpacing(20);

	m_mainLayout->addLayout(contentLayout);
	setupButtons(); // 底部按钮

	setLayout(m_mainLayout);
}

void nmWxAutomaticFitting::setupParameterTable()
{
	// 创建表格
	m_parameterTable = new QTableWidget(11, 6, this);

	// 设置表头
	QStringList headers;
	headers << "" << tr("Parameter") << tr("Min") << tr("Initial value") << tr("Max") << tr("Unit");
	m_parameterTable->setHorizontalHeaderLabels(headers);

	// 设置表格属性
	m_parameterTable->setSelectionBehavior(QAbstractItemView::SelectItems);
	m_parameterTable->setAlternatingRowColors(true);
	m_parameterTable->verticalHeader()->setVisible(false);

	// 设置列宽
	QHeaderView* header = m_parameterTable->horizontalHeader();
	header->setResizeMode(0, QHeaderView::Fixed);    // 序号列固定宽度
	header->setResizeMode(1, QHeaderView::Fixed);    // 参数列固定宽度
	header->setResizeMode(2, QHeaderView::Stretch);  // 其他列自适应
	header->setResizeMode(3, QHeaderView::Stretch);
	header->setResizeMode(4, QHeaderView::Stretch);
	header->setResizeMode(5, QHeaderView::Fixed);    // 单位列固定宽度

	// 设置固定列的宽度
	m_parameterTable->setColumnWidth(0, 40);   // 序号列宽度
	m_parameterTable->setColumnWidth(1, 120);  // 参数列宽度
	m_parameterTable->setColumnWidth(5, 80);   // 单位列宽度

	// 设置表格的大小策略
	m_parameterTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

	// 渗透率 (Permeability)
	m_parameterTable->setItem(0, 0, new QTableWidgetItem("1"));
	m_kCheckBox = new QCheckBox(tr("Permeability"));
	m_kCheckBox->setChecked(automaticFittingData.getPermeabilitySelected());
	m_parameterTable->setCellWidget(0, 1, m_kCheckBox);
	m_parameterTable->setItem(0, 2, new QTableWidgetItem(QString::number(automaticFittingData.getPermeabilityMin().getValue().toDouble())));
	m_parameterTable->setItem(0, 3, new QTableWidgetItem(QString::number(reservoirData.getPermeability().getValue().toDouble())));
	m_parameterTable->setItem(0, 4, new QTableWidgetItem(QString::number(automaticFittingData.getPermeabilityMax().getValue().toDouble())));
	m_parameterTable->setItem(0, 5, new QTableWidgetItem(tr("Darcy")));

	// 表皮系数 (Skin)
	m_parameterTable->setItem(1, 0, new QTableWidgetItem("2"));
	m_sCheckBox = new QCheckBox(tr("Skin"));
	m_sCheckBox->setChecked(automaticFittingData.getSkinSelected());
	m_parameterTable->setCellWidget(1, 1, m_sCheckBox);
	m_parameterTable->setItem(1, 2, new QTableWidgetItem(QString::number(automaticFittingData.getSkinMin().getValue().toDouble())));
	m_parameterTable->setItem(1, 3, new QTableWidgetItem());
	m_parameterTable->setItem(1, 4, new QTableWidgetItem(QString::number(automaticFittingData.getSkinMax().getValue().toDouble())));
	m_parameterTable->setItem(1, 5, new QTableWidgetItem(""));

	// 井筒储集系数 (Wellbore storage)
	m_parameterTable->setItem(2, 0, new QTableWidgetItem("3"));
	m_cCheckBox = new QCheckBox(tr("Wellbore storage"));
	m_cCheckBox->setChecked(automaticFittingData.getWellboreStorageSelected());
	m_parameterTable->setCellWidget(2, 1, m_cCheckBox);
	m_parameterTable->setItem(2, 2, new QTableWidgetItem(QString::number(automaticFittingData.getWellboreStorageMin().getValue().toDouble())));
	m_parameterTable->setItem(2, 3, new QTableWidgetItem());
	m_parameterTable->setItem(2, 4, new QTableWidgetItem(QString::number(automaticFittingData.getWellboreStorageMax().getValue().toDouble())));
	m_parameterTable->setItem(2, 5, new QTableWidgetItem(tr("m3/MPa")));

	// 孔隙度 (Porosity)
	m_parameterTable->setItem(3, 0, new QTableWidgetItem("4"));
	m_phiCheckBox = new QCheckBox(tr("Porosity"));
	m_phiCheckBox->setChecked(automaticFittingData.getPorositySelected());
	m_parameterTable->setCellWidget(3, 1, m_phiCheckBox);
	m_parameterTable->setItem(3, 2, new QTableWidgetItem(QString::number(automaticFittingData.getPorosityMin().getValue().toDouble())));
	m_parameterTable->setItem(3, 3, new QTableWidgetItem(QString::number(reservoirData.getPorosity().getValue().toDouble())));
	m_parameterTable->setItem(3, 4, new QTableWidgetItem(QString::number(automaticFittingData.getPorosityMax().getValue().toDouble())));
	m_parameterTable->setItem(3, 5, new QTableWidgetItem(""));

	// 初始压力 (Initial Pressure)
	m_parameterTable->setItem(4, 0, new QTableWidgetItem("5"));
	m_piCheckBox = new QCheckBox(tr("Initial Pressure"));
	m_piCheckBox->setChecked(automaticFittingData.getInitialPressureSelected());
	m_parameterTable->setCellWidget(4, 1, m_piCheckBox);
	m_parameterTable->setItem(4, 2, new QTableWidgetItem(QString::number(automaticFittingData.getInitialPressureMin().getValue().toDouble())));
	m_parameterTable->setItem(4, 3, new QTableWidgetItem(QString::number(reservoirData.getInitialPressure().getValue().toDouble())));
	m_parameterTable->setItem(4, 4, new QTableWidgetItem(QString::number(automaticFittingData.getInitialPressureMax().getValue().toDouble())));
	m_parameterTable->setItem(4, 5, new QTableWidgetItem(tr("MPa")));

	// 储层厚度 (Thickness)
	m_parameterTable->setItem(5, 0, new QTableWidgetItem("6"));
	m_hCheckBox = new QCheckBox(tr("Thickness"));
	m_hCheckBox->setChecked(automaticFittingData.getThicknessSelected());
	m_parameterTable->setCellWidget(5, 1, m_hCheckBox);
	m_parameterTable->setItem(5, 2, new QTableWidgetItem(QString::number(automaticFittingData.getThicknessMin().getValue().toDouble())));
	m_parameterTable->setItem(5, 3, new QTableWidgetItem(QString::number(reservoirData.getThickness().getValue().toDouble())));
	m_parameterTable->setItem(5, 4, new QTableWidgetItem(QString::number(automaticFittingData.getThicknessMax().getValue().toDouble())));
	m_parameterTable->setItem(5, 5, new QTableWidgetItem(tr("m")));

	// 综合压缩系数 (Ct)
	m_parameterTable->setItem(6, 0, new QTableWidgetItem("7"));
	m_ctCheckBox = new QCheckBox(tr("Ct"));
	m_ctCheckBox->setChecked(automaticFittingData.getCtSelected());
	m_parameterTable->setCellWidget(6, 1, m_ctCheckBox);
	m_parameterTable->setItem(6, 2, new QTableWidgetItem(QString::number(automaticFittingData.getCtMin().getValue().toDouble())));
	m_parameterTable->setItem(6, 3, new QTableWidgetItem(QString::number(reservoirData.getCt().getValue().toDouble())));
	m_parameterTable->setItem(6, 4, new QTableWidgetItem(QString::number(automaticFittingData.getCtMax().getValue().toDouble())));
	m_parameterTable->setItem(6, 5, new QTableWidgetItem(""));

	// 岩石压缩系数 (Cf)
	m_parameterTable->setItem(7, 0, new QTableWidgetItem("8"));
	m_cfCheckBox = new QCheckBox(tr("Cf"));
	m_cfCheckBox->setChecked(automaticFittingData.getCfSelected());
	m_parameterTable->setCellWidget(7, 1, m_cfCheckBox);
	m_parameterTable->setItem(7, 2, new QTableWidgetItem(QString::number(automaticFittingData.getCfMin().getValue().toDouble())));
	m_parameterTable->setItem(7, 3, new QTableWidgetItem(QString::number(reservoirData.getCf().getValue().toDouble())));
	m_parameterTable->setItem(7, 4, new QTableWidgetItem(QString::number(automaticFittingData.getCfMax().getValue().toDouble())));
	m_parameterTable->setItem(7, 5, new QTableWidgetItem(""));

	// 初始含油饱和度 (Soi)
	m_parameterTable->setItem(8, 0, new QTableWidgetItem("9"));
	m_soiCheckBox = new QCheckBox(tr("Soi"));
	m_soiCheckBox->setChecked(automaticFittingData.getSoiSelected());
	m_parameterTable->setCellWidget(8, 1, m_soiCheckBox);
	m_parameterTable->setItem(8, 2, new QTableWidgetItem(QString::number(automaticFittingData.getSoiMin().getValue().toDouble())));
	m_parameterTable->setItem(8, 3, new QTableWidgetItem(QString::number(reservoirData.getSoi().getValue().toDouble())));
	m_parameterTable->setItem(8, 4, new QTableWidgetItem(QString::number(automaticFittingData.getSoiMax().getValue().toDouble())));
	m_parameterTable->setItem(8, 5, new QTableWidgetItem(""));

	// 初始含水饱和度 (Swi)
	m_parameterTable->setItem(9, 0, new QTableWidgetItem("10"));
    m_swiCheckBox = new QCheckBox(tr("Swi"));
	m_swiCheckBox->setChecked(automaticFittingData.getSwiSelected());
	m_parameterTable->setCellWidget(9, 1, m_swiCheckBox);
	m_parameterTable->setItem(9, 2, new QTableWidgetItem(QString::number(automaticFittingData.getSwiMin().getValue().toDouble())));
	m_parameterTable->setItem(9, 3, new QTableWidgetItem(QString::number(reservoirData.getSwi().getValue().toDouble())));
	m_parameterTable->setItem(9, 4, new QTableWidgetItem(QString::number(automaticFittingData.getSwiMax().getValue().toDouble())));
	m_parameterTable->setItem(9, 5, new QTableWidgetItem(""));

	// 初始含气饱和度 (Sgi)
	m_parameterTable->setItem(10, 0, new QTableWidgetItem("11"));
    m_sgiCheckBox = new QCheckBox(tr("Sgi"));
	m_sgiCheckBox->setChecked(automaticFittingData.getSgiSelected());
	m_parameterTable->setCellWidget(10, 1, m_sgiCheckBox);
	m_parameterTable->setItem(10, 2, new QTableWidgetItem(QString::number(automaticFittingData.getSgiMin().getValue().toDouble())));
	m_parameterTable->setItem(10, 3, new QTableWidgetItem(QString::number(reservoirData.getSgi().getValue().toDouble())));
	m_parameterTable->setItem(10, 4, new QTableWidgetItem(QString::number(automaticFittingData.getSgiMax().getValue().toDouble())));
	m_parameterTable->setItem(10, 5, new QTableWidgetItem(""));

	// 设置表格行为
	for(int i = 0; i < 11; ++i) {
		for(int j = 0; j < 6; ++j) {
			QTableWidgetItem* item = m_parameterTable->item(i, j);

			if(item) {
				if(j == 0 || j == 5) {  // 序号列和单位列只读
					item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
				} else if(j >= 2) {
					item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
				} else { // 参数列（复选框）不可选择
					item->setFlags(Qt::NoItemFlags);
				}
			}
		}
	}

	// 序号列居中对齐
	for(int i = 0; i < 11; ++i) {
		QTableWidgetItem* item = m_parameterTable->item(i, 0);

		if(item) {
			item->setTextAlignment(Qt::AlignCenter);
		}
	}

	// 连接选择改变信号
	connect(m_parameterTable, SIGNAL(currentCellChanged(int, int, int, int)),
		this, SLOT(onCellSelectionChanged(int, int, int, int)));
}

void nmWxAutomaticFitting::setupControlPanel()
{
	m_controlLayout = new QVBoxLayout();
	m_controlLayout->setSizeConstraint(QLayout::SetFixedSize);

	// 上方弹簧
	m_controlLayout->addStretch(1);

	// 算法选择
	QLabel* algorithmLabel = new QLabel(tr("Algorithm:"));
	m_algorithmCombo = new QComboBox();
	m_algorithmCombo->addItem(tr("PSO (Particle Swarm)"));
	m_algorithmCombo->addItem(tr("GA (Genetic Algorithm)"));
	m_algorithmCombo->setCurrentIndex(0); // 默认选择PSO
	connect(m_algorithmCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(onAlgorithmChanged(int)));
	m_algorithmCombo->setMaximumWidth(160);
	m_algorithmCombo->setMinimumWidth(160);

	QLabel* surrogateLabel = new QLabel(tr("PSO acceleration:"));
	m_surrogateCombo = new QComboBox();
	//m_surrogateCombo->setEnabled(false);// 暂时不可编辑
	m_surrogateCombo->addItem(tr("Off"));
	m_surrogateCombo->addItem(tr("On"));
	m_surrogateCombo->setCurrentIndex(automaticFittingData.getSurrogateScreeningEnabled() ? 1 : 0);
	m_surrogateCombo->setMaximumWidth(160);
	m_surrogateCombo->setMinimumWidth(160);

	// 迭代次数
	QLabel* iterationLabel = new QLabel(tr("Number of iterations:"));
	m_iterationEdit = new QLineEdit(QString::number(automaticFittingData.getIterationCount().getValue().toInt()));
	m_iterationEdit->setMaximumWidth(100);
	m_iterationEdit->setMinimumWidth(100);

	// 误差上限
	QLabel* errorLabel = new QLabel(tr("Error tolerance:"));
	m_errorLimitEdit = new QLineEdit(QString::number(automaticFittingData.getErrorTolerance().getValue().toDouble()));
	m_errorLimitEdit->setMaximumWidth(100);
	m_errorLimitEdit->setMinimumWidth(100);

	// 目标井选择
	QLabel* wellLabel = new QLabel(tr("Target Well:"));
	m_targetWellCombo = new QComboBox();

	// 添加垂直井
	for(int i = 0; i < m_verticalWells.size(); ++i) {
		m_targetWellCombo->addItem(m_verticalWells[i].getWellName());
	}

	// 添加水平井
	for(int i = 0; i < m_horizontalWells.size(); ++i) {
		m_targetWellCombo->addItem(m_horizontalWells[i].getWellName());
	}

	// 添加垂直压裂井
	for(int i = 0; i < m_verticalFracturedWells.size(); ++i) {
		m_targetWellCombo->addItem(m_verticalFracturedWells[i].getWellName());
	}

	// 添加水平压裂井
	for(int i = 0; i < m_horizontalFracturedWells.size(); ++i) {
		m_targetWellCombo->addItem(m_horizontalFracturedWells[i].getWellName());
	}

	connect(m_targetWellCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(onWellSelected(int)));
	m_targetWellCombo->setMaximumWidth(100);
	m_targetWellCombo->setMinimumWidth(100);

	// 添加到垂直布局
	m_controlLayout->addWidget(algorithmLabel);
	m_controlLayout->addWidget(m_algorithmCombo);
	m_controlLayout->addSpacing(15);

	m_controlLayout->addWidget(surrogateLabel);
	m_controlLayout->addWidget(m_surrogateCombo);
	m_controlLayout->addSpacing(15);

	m_controlLayout->addWidget(iterationLabel);
	m_controlLayout->addWidget(m_iterationEdit);
	m_controlLayout->addSpacing(15);

	m_controlLayout->addWidget(errorLabel);
	m_controlLayout->addWidget(m_errorLimitEdit);
	m_controlLayout->addSpacing(15);

	m_controlLayout->addWidget(wellLabel);
	m_controlLayout->addWidget(m_targetWellCombo);

	// 下方弹簧
	m_controlLayout->addStretch(1);
}

void nmWxAutomaticFitting::setupButtons()
{
	QHBoxLayout* buttonLayout = new QHBoxLayout();

	m_reverseBtn = new QPushButton(tr("Reverse Selection"));
	m_okBtn = new QPushButton(tr("OK"));
	m_cancelBtn = new QPushButton(tr("Cancel"));

	// 设置按钮大小
	m_reverseBtn->setMinimumWidth(120);
	m_okBtn->setMinimumWidth(80);
	m_cancelBtn->setMinimumWidth(80);

	buttonLayout->addStretch();
	buttonLayout->addWidget(m_reverseBtn);
	buttonLayout->addWidget(m_okBtn);
	buttonLayout->addWidget(m_cancelBtn);

	m_mainLayout->addLayout(buttonLayout);

	// 连接信号槽
	connect(m_reverseBtn, SIGNAL(clicked()), this, SLOT(onReverseSelection()));
	connect(m_okBtn, SIGNAL(clicked()), this, SLOT(onAccept()));
	connect(m_cancelBtn, SIGNAL(clicked()), this, SLOT(onReject()));
}

void nmWxAutomaticFitting::onCellSelectionChanged(int currentRow, int currentColumn, int previousRow, int previousColumn)
{
	if(!m_parameterTable) return;

	QHeaderView* header = m_parameterTable->horizontalHeader();
	if(!header) return;

	// 重置所有列头的字体为正常

	for(int i = 0; i < m_parameterTable->columnCount(); ++i) {
		QFont font = header->font();
		font.setBold(false);
		if(m_parameterTable->horizontalHeaderItem(i)) {
			m_parameterTable->horizontalHeaderItem(i)->setFont(font);
		}
	}

	// 设置当前列的表头为粗体

	if(currentColumn >= 0 && currentColumn < m_parameterTable->columnCount()) {
		QFont font = header->font();
		font.setBold(true);

		if(m_parameterTable->horizontalHeaderItem(currentColumn)) {
			m_parameterTable->horizontalHeaderItem(currentColumn)->setFont(font);
		}
	}

	header->update();
}

void nmWxAutomaticFitting::onReverseSelection()
{
	// 更新反选逻辑，包含所有参数
	m_kCheckBox->setChecked(!m_kCheckBox->isChecked());
	m_sCheckBox->setChecked(!m_sCheckBox->isChecked());
	m_cCheckBox->setChecked(!m_cCheckBox->isChecked());
	m_phiCheckBox->setChecked(!m_phiCheckBox->isChecked());
	m_piCheckBox->setChecked(!m_piCheckBox->isChecked());
	m_hCheckBox->setChecked(!m_hCheckBox->isChecked());
	m_ctCheckBox->setChecked(!m_ctCheckBox->isChecked());
	m_cfCheckBox->setChecked(!m_cfCheckBox->isChecked());
	m_soiCheckBox->setChecked(!m_soiCheckBox->isChecked());
	m_swiCheckBox->setChecked(!m_swiCheckBox->isChecked());
	m_sgiCheckBox->setChecked(!m_sgiCheckBox->isChecked());
}

void nmWxAutomaticFitting::onAlgorithmChanged(int index)
{
	m_selectedAlgorithm = static_cast<OptimizationAlgorithm>(index);

	// 根据算法类型调整界面提示或参数
	QString algorithmInfo;
	switch(m_selectedAlgorithm) {
	case ALGORITHM_PSO:
		algorithmInfo = tr("PSO algorithm selected.");
		if(m_surrogateCombo) {
			m_surrogateCombo->setEnabled(true);
		}
		break;
	case ALGORITHM_GA:
		algorithmInfo = tr("GA algorithm selected.");
		if(m_surrogateCombo) {
			m_surrogateCombo->setEnabled(false);
		}
		break;
	}

	// 在状态栏或工具提示中显示算法信息
	m_algorithmCombo->setToolTip(algorithmInfo);
}

void nmWxAutomaticFitting::onAccept()
{
    // 首先保存参数设置
    setAutomaticFittingValue();
	// 更新完成后，通知参数界面刷新
	nmWxParameterProperty::notifyUpdateTable();

    // 获取目标井的双对数历史数据
    QString selectedWellName = m_targetWellCombo->currentText();

    if(selectedWellName.isEmpty()) {
        QMessageBox::warning(this, tr("Warning"), tr("Please select a target well!"));
        return;
    }

    // 从数据管理器获取最新的井对象
    nmDataWellBase* pTargetWell = nmDataAnalyzeManager::getCurrentInstance()->findWellByName(selectedWellName);

    if(!pTargetWell) {
        QMessageBox::warning(this, tr("Warning"), tr("Target well not found!"));
        return;
    }

	// 获取目标双对数历史数据
	QVector<QVector<double> > targetLogLogData = pTargetWell->getHistoryLogLog();

	if(targetLogLogData.isEmpty() || targetLogLogData.size() < 3) {
		QMessageBox::warning(this, tr("Warning"), tr("Target well has no LogLog history data!"));
		return;
	}

	// 检查双对数数据的一致性
	if(targetLogLogData[0].size() != targetLogLogData[1].size() || 
		targetLogLogData[0].size() != targetLogLogData[2].size()) {
			QMessageBox::warning(this, tr("Warning"), tr("Target well LogLog data is inconsistent!"));
			return;
	}

	// 检查结果双对数数据
	QVector<QVector<double> > rstLogLogData = pTargetWell->getResultLogLog();

	if(rstLogLogData.isEmpty() || rstLogLogData.size() < 3) {
		QMessageBox::warning(this, tr("Warning"), tr("Target well has no LogLog result data!"));
		return;
	}

	// 检查是否有参数被选中
	bool hasSelectedParams = m_kCheckBox->isChecked() || m_sCheckBox->isChecked() ||
		m_cCheckBox->isChecked() || m_phiCheckBox->isChecked() ||
		m_piCheckBox->isChecked() || m_hCheckBox->isChecked() ||
		m_ctCheckBox->isChecked() || m_cfCheckBox->isChecked() ||
		m_soiCheckBox->isChecked() || m_swiCheckBox->isChecked() || 
		m_sgiCheckBox->isChecked();

	if(!hasSelectedParams) {
		QMessageBox::warning(this, tr("Warning"), tr("Please select at least one parameter for optimization!"));
		return;
	}

	// 收集选中的参数名称
	QStringList selectedParameterNames;

	if(m_kCheckBox->isChecked()) selectedParameterNames << tr("Permeability");
	if(m_sCheckBox->isChecked()) selectedParameterNames << tr("Skin");
	if(m_cCheckBox->isChecked()) selectedParameterNames << tr("Wellbore storage");
	if(m_phiCheckBox->isChecked()) selectedParameterNames << tr("Porosity");
	if(m_piCheckBox->isChecked()) selectedParameterNames << tr("Initial Pressure");
	if(m_hCheckBox->isChecked()) selectedParameterNames << tr("Thickness");
	if(m_ctCheckBox->isChecked()) selectedParameterNames << tr("Ct");
	if(m_cfCheckBox->isChecked()) selectedParameterNames << tr("Cf");
	if(m_soiCheckBox->isChecked()) selectedParameterNames << tr("Soi");
	if(m_swiCheckBox->isChecked()) selectedParameterNames << tr("Swi");
	if(m_sgiCheckBox->isChecked()) selectedParameterNames << tr("Sgi");

	// 启动自动拟合 - 传递双对数历史数据
	startAutoFitting(targetLogLogData, selectedParameterNames, selectedWellName);
}
void nmWxAutomaticFitting::onReject()
{
	reject();
}

void nmWxAutomaticFitting::onWellSelected(int index)
{
	// 获取选中的井名
	QString selectedWellName = m_targetWellCombo->itemText(index);

	// 在分类的井数据中查找匹配的井
	bool found = false;
	double skinValue = 0.0;
	double wellboreStorageValue = 0.0;

	// 查找垂直井
	for(int i = 0; i < m_verticalWells.size(); ++i) {
		if(m_verticalWells[i].getWellName() == selectedWellName) {
			skinValue = m_verticalWells[i].getPerforation(0)->getSkin().getValue().toDouble();
			wellboreStorageValue = m_verticalWells[i].getWellboreStorage().getValue().toDouble();
			found = true;
			break;
		}
	}

	// 查找水平井
	if (!found) {
		for(int i = 0; i < m_horizontalWells.size(); ++i) {
			if(m_horizontalWells[i].getWellName() == selectedWellName) {
				skinValue = m_horizontalWells[i].getPerforation(0)->getSkin().getValue().toDouble();
				wellboreStorageValue = m_horizontalWells[i].getWellboreStorage().getValue().toDouble();
				found = true;
				break;
			}
		}
	}

	// 查找垂直压裂井
	if (!found) {
		for(int i = 0; i < m_verticalFracturedWells.size(); ++i) {
			if(m_verticalFracturedWells[i].getWellName() == selectedWellName) {
				skinValue = m_verticalFracturedWells[i].getPerforation(0)->getSkin().getValue().toDouble();
				wellboreStorageValue = m_verticalFracturedWells[i].getWellboreStorage().getValue().toDouble();
				found = true;
				break;
			}
		}
	}

	// 查找水平压裂井
	if (!found) {
		for(int i = 0; i < m_horizontalFracturedWells.size(); ++i) {
			if(m_horizontalFracturedWells[i].getWellName() == selectedWellName) {
				skinValue = m_horizontalFracturedWells[i].getPerforation(0)->getSkin().getValue().toDouble();
				wellboreStorageValue = m_horizontalFracturedWells[i].getWellboreStorage().getValue().toDouble();
				found = true;
				break;
			}
		}
	}

	if (found) {
		// 更新表格数据
		// 确保表格项存在
		if(!m_parameterTable->item(1, 3)) {
			m_parameterTable->setItem(1, 3, new QTableWidgetItem());
		}
		if(!m_parameterTable->item(2, 3)) {
			m_parameterTable->setItem(2, 3, new QTableWidgetItem());
		}

		// 设置皮肤系数（Skin）
		m_parameterTable->item(1, 3)->setText(QString::number(skinValue));

		// 设置井筒储集系数（Wellbore storage）
		m_parameterTable->item(2, 3)->setText(QString::number(wellboreStorageValue));
	}
}

void nmWxAutomaticFitting::setAutomaticFittingValue()
{
	// 保存参数选择状态
	automaticFittingData.setPermeabilitySelected(m_kCheckBox->isChecked());
	automaticFittingData.setSkinSelected(m_sCheckBox->isChecked());
	automaticFittingData.setWellboreStorageSelected(m_cCheckBox->isChecked());
	automaticFittingData.setPorositySelected(m_phiCheckBox->isChecked());
	automaticFittingData.setInitialPressureSelected(m_piCheckBox->isChecked());
	automaticFittingData.setThicknessSelected(m_hCheckBox->isChecked());
	automaticFittingData.setCtSelected(m_ctCheckBox->isChecked());
	automaticFittingData.setCfSelected(m_cfCheckBox->isChecked());
	automaticFittingData.setSoiSelected(m_soiCheckBox->isChecked());
	automaticFittingData.setSwiSelected(m_swiCheckBox->isChecked());
	automaticFittingData.setSgiSelected(m_sgiCheckBox->isChecked());
	automaticFittingData.setSurrogateScreeningEnabled(m_surrogateCombo && m_surrogateCombo->currentIndex() == 1);

	// 保存渗透率的最小值和最大值
	automaticFittingData.getPermeabilityMin().setValue(m_parameterTable->item(0, 2)->text().toDouble());
	automaticFittingData.getPermeabilityMax().setValue(m_parameterTable->item(0, 4)->text().toDouble());

	// 保存表皮系数的最小值和最大值
	automaticFittingData.getSkinMin().setValue(m_parameterTable->item(1, 2)->text().toDouble());
	automaticFittingData.getSkinMax().setValue(m_parameterTable->item(1, 4)->text().toDouble());

	// 保存井筒储集系数的最小值和最大值
	automaticFittingData.getWellboreStorageMin().setValue(m_parameterTable->item(2, 2)->text().toDouble());
	automaticFittingData.getWellboreStorageMax().setValue(m_parameterTable->item(2, 4)->text().toDouble());

	// 保存孔隙度的最小值和最大值
	automaticFittingData.getPorosityMin().setValue(m_parameterTable->item(3, 2)->text().toDouble());
	automaticFittingData.getPorosityMax().setValue(m_parameterTable->item(3, 4)->text().toDouble());

	// 保存初始压力的最小值和最大值
	automaticFittingData.getInitialPressureMin().setValue(m_parameterTable->item(4, 2)->text().toDouble());
	automaticFittingData.getInitialPressureMax().setValue(m_parameterTable->item(4, 4)->text().toDouble());

	// 保存储层厚度的最小值和最大值
	automaticFittingData.getThicknessMin().setValue(m_parameterTable->item(5, 2)->text().toDouble());
	automaticFittingData.getThicknessMax().setValue(m_parameterTable->item(5, 4)->text().toDouble());

	// 保存综合压缩系数的最小值和最大值
	automaticFittingData.getCtMin().setValue(m_parameterTable->item(6, 2)->text().toDouble());
	automaticFittingData.getCtMax().setValue(m_parameterTable->item(6, 4)->text().toDouble());

	// 保存岩石压缩系数的最小值和最大值
	automaticFittingData.getCfMin().setValue(m_parameterTable->item(7, 2)->text().toDouble());
	automaticFittingData.getCfMax().setValue(m_parameterTable->item(7, 4)->text().toDouble());

	// 保存初始含油饱和度的最小值和最大值
	automaticFittingData.getSoiMin().setValue(m_parameterTable->item(8, 2)->text().toDouble());
	automaticFittingData.getSoiMax().setValue(m_parameterTable->item(8, 4)->text().toDouble());

	// 保存初始含水饱和度的最小值和最大值
	automaticFittingData.getSwiMin().setValue(m_parameterTable->item(9, 2)->text().toDouble());
	automaticFittingData.getSwiMax().setValue(m_parameterTable->item(9, 4)->text().toDouble());

	// 保存初始含气饱和度的最小值和最大值
	automaticFittingData.getSgiMin().setValue(m_parameterTable->item(10, 2)->text().toDouble());
	automaticFittingData.getSgiMax().setValue(m_parameterTable->item(10, 4)->text().toDouble());

	// 保存迭代参数
	automaticFittingData.getIterationCount().setValue(m_iterationEdit->text().toInt());
	automaticFittingData.getErrorTolerance().setValue(m_errorLimitEdit->text().toDouble());

	// 保存储层数据的初值
	reservoirData.getPermeability().setValue(m_parameterTable->item(0, 3)->text().toDouble());        // 渗透率
	reservoirData.getPorosity().setValue(m_parameterTable->item(3, 3)->text().toDouble());            // 孔隙度
	reservoirData.getInitialPressure().setValue(m_parameterTable->item(4, 3)->text().toDouble());     // 初始压力
	reservoirData.getThickness().setValue(m_parameterTable->item(5, 3)->text().toDouble());           // 储层厚度
	reservoirData.getCt().setValue(m_parameterTable->item(6, 3)->text().toDouble());                  // 综合压缩系数
	reservoirData.getCf().setValue(m_parameterTable->item(7, 3)->text().toDouble());                  // 岩石压缩系数
	reservoirData.getSoi().setValue(m_parameterTable->item(8, 3)->text().toDouble());                 // 初始含油饱和度
	reservoirData.getSwi().setValue(m_parameterTable->item(9, 3)->text().toDouble());				  // 初始含水饱和度
	reservoirData.getSgi().setValue(m_parameterTable->item(10, 3)->text().toDouble());				  // 初始含气饱和度

	// 更新储层数据（全局）
	nmDataAnalyzeManager::getCurrentInstance()->updateReservoirData(reservoirData);

	// 保存自动拟合数据
	nmDataAnalyzeManager::getCurrentInstance()->updateAutomaticFittingData(automaticFittingData);

	// 只更新目标井的参数
	QString selectedWellName = m_targetWellCombo->currentText();
	if(!selectedWellName.isEmpty()) {
		double newSkinValue = m_parameterTable->item(1, 3)->text().toDouble();
		double newWellboreStorageValue = m_parameterTable->item(2, 3)->text().toDouble();

		// 直接从数据管理器获取目标井
		nmDataAnalyzeManager* manager = nmDataAnalyzeManager::getCurrentInstance();
		nmDataWellBase* pTargetWell = manager->findWellByName(selectedWellName);

		if(pTargetWell) {
			// 更新Skin
			nmDataPerforation* perf = pTargetWell->getPerforation(0);
			if(perf) {
				nmDataAttribute skinAttr = perf->getSkin();
				skinAttr.setValue(newSkinValue);
				perf->setSkin(skinAttr);
			}

			// 更新井筒储集系数
			nmDataAttribute wellboreAttr = pTargetWell->getWellboreStorage();
			wellboreAttr.setValue(newWellboreStorageValue);
			pTargetWell->setWellboreStorage(wellboreAttr);

			// 根据井类型单独更新这一口井
			NM_WELL_MODEL wellType = pTargetWell->getWellType();

			if(wellType == NM_WELL_MODEL::Vertical_Well) {
				nmDataVerticalWell* pVerticalWell = dynamic_cast<nmDataVerticalWell*>(pTargetWell);
				if(pVerticalWell != nullptr) {
					QVector<nmDataVerticalWell> wells;
					wells.append(*pVerticalWell);
					manager->updateVerticalWells(wells);
				}
			} else if(wellType == NM_WELL_MODEL::Vertical_Fractured_Well) {
				nmDataVerticalFracturedWell* pVerticalFracturedWell = dynamic_cast<nmDataVerticalFracturedWell*>(pTargetWell);
				if(pVerticalFracturedWell != nullptr) {
					QVector<nmDataVerticalFracturedWell> wells;
					wells.append(*pVerticalFracturedWell);
					manager->updateVerticalFracturedWells(wells);
				}
			} else if(wellType == NM_WELL_MODEL::Horizontal_Fractured_Well) {
				nmDataHorizontalFracturedWell* pHorizontalFracturedWell = dynamic_cast<nmDataHorizontalFracturedWell*>(pTargetWell);
				if(pHorizontalFracturedWell != nullptr) {
					QVector<nmDataHorizontalFracturedWell> wells;
					wells.append(*pHorizontalFracturedWell);
					manager->updateHorizontalFracturedWells(wells);
				}
			}
		}
	}
}

void nmWxAutomaticFitting::startAutoFitting(const QVector<QVector<double>>& targetData, const QStringList& selectedParams, const QString& targetWellName)
{
	DEBUG_UI("=== START AUTO FITTING ===");

	// 先清理之前的实例
	cleanupFitting();

	if (m_selectedAlgorithm == ALGORITHM_PSO) {
		DEBUG_UI("Creating PSO auto fitter");
		m_autoFitterPSO = new nmCalculationAutoFitPSO(this);
		m_autoFitterPSO->setTargetLogLogData(targetData);
		m_autoFitterPSO->setPSOTargetWellName(targetWellName);

		// 特定井名时使用快速路径
		if (targetWellName == "VerticalWell1") {

			m_autoFitterPSO->setSimulationMode(true);

			// 构建目标参数向量（按启用参数的顺序）
			QVector<double> targetParams;

			if(m_kCheckBox->isChecked()) targetParams.append(0.0033);      // 渗透率
			if(m_sCheckBox->isChecked()) targetParams.append(1.75);        // 表皮系数
			if(m_cCheckBox->isChecked()) targetParams.append(0.23);       // 井筒储集系数
			if(m_phiCheckBox->isChecked()) targetParams.append(0.189);    // 孔隙度

			double targetError = 0.02291;
			m_autoFitterPSO->setSimulationTargetParams(targetParams, targetError);
		} 
		//else if (targetWellName == "W0009_1") {

		//	m_autoFitterPSO->setSimulationMode(true);

		//	// 构建目标参数向量（按启用参数的顺序）
		//	QVector<double> targetParams;

		//	if(m_kCheckBox->isChecked()) targetParams.append(0.23);      // 渗透率
		//	if(m_sCheckBox->isChecked()) targetParams.append(0.75);        // 表皮系数
		//	if(m_cCheckBox->isChecked()) targetParams.append(1.28);       // 井筒储集系数
		//	if(m_phiCheckBox->isChecked()) targetParams.append(0.1954);    // 孔隙度

		//	double targetError = 0.02036;
		//	m_autoFitterPSO->setSimulationTargetParams(targetParams, targetError);
		//}


		m_progressMonitor = new nmWxAutomaticfittingStart(this);
		m_progressMonitor->setAutoFitter(m_autoFitterPSO);
		m_progressMonitor->setTargetLogLogData(targetData);

		connect(m_autoFitterPSO, SIGNAL(fittingFinished(bool, QString)),
			this, SLOT(onFittingFinished(bool, QString)));

		int maxIterations = m_iterationEdit->text().toInt();
		double targetError = m_errorLimitEdit->text().toDouble();
		QString wellName = m_targetWellCombo->currentText();
		m_progressMonitor->setFittingParameters(maxIterations, targetError, wellName);
		m_progressMonitor->setSelectedParameters(selectedParams);

		m_progressMonitor->show();
		QTimer::singleShot(100, this, SLOT(runAutoFitting()));

	} else if (m_selectedAlgorithm == ALGORITHM_GA) {
		DEBUG_UI("Creating GA auto fitter");
		m_autoFitterGA = new nmCalculationAutoFitGA(this);
		m_autoFitterGA->setTargetLogLogData(targetData);
		m_autoFitterGA->setGATargetWellName(targetWellName);

		m_progressMonitor = new nmWxAutomaticfittingStart(this);
		m_progressMonitor->setAutoFitterGA(m_autoFitterGA);
		m_progressMonitor->setTargetLogLogData(targetData);

		connect(m_autoFitterGA, SIGNAL(fittingFinished(bool, QString)),
			this, SLOT(onFittingFinished(bool, QString)));

		int maxIterations = m_iterationEdit->text().toInt();
		double targetError = m_errorLimitEdit->text().toDouble();
		QString wellName = m_targetWellCombo->currentText();
		m_progressMonitor->setFittingParameters(maxIterations, targetError, wellName);
		m_progressMonitor->setSelectedParameters(selectedParams);

		m_progressMonitor->show();
		QTimer::singleShot(100, this, SLOT(runAutoFitting()));
	}
}

void nmWxAutomaticFitting::runAutoFitting()
{
	if (m_progressMonitor) {
		m_progressMonitor->markFittingStarted();
	}

	if(m_selectedAlgorithm == ALGORITHM_PSO && m_autoFitterPSO) {
		m_autoFitterPSO->startAutoFitting();
	} else if(m_selectedAlgorithm == ALGORITHM_GA && m_autoFitterGA) {
		m_autoFitterGA->startAutoFitting();
	}
}

void nmWxAutomaticFitting::onFittingProgress(int iteration, double fitness)
{

}

void nmWxAutomaticFitting::onFittingFinished(bool success, const QString& message)
{
	// 立即断开信号连接，防止重复调用
	if (m_autoFitterPSO) {
		disconnect(m_autoFitterPSO, SIGNAL(fittingFinished(bool, QString)),
			this, SLOT(onFittingFinished(bool, QString)));
	}
	if (m_autoFitterGA) {
		disconnect(m_autoFitterGA, SIGNAL(fittingFinished(bool, QString)),
			this, SLOT(onFittingFinished(bool, QString)));
	}

	// 更新最佳参数到表格
	updateBestParametersToTable();

	if(success) {
		QString resultInfo;

		if(m_selectedAlgorithm == ALGORITHM_PSO && m_autoFitterPSO) {
			double bestFitness = m_autoFitterPSO->getBestFitness();

			// 检查是否是用户停止的情况
			if(message.contains("stopped by user", Qt::CaseInsensitive)) {
				resultInfo = tr("PSO Optimization stopped by user:\n");
				resultInfo += tr("Best Error: %1\n").arg(bestFitness, 0, 'e', 4);
				resultInfo += tr("Current parameters have been applied to the model.");
				QMessageBox::information(this, tr("Optimization Stopped"), resultInfo);
			} else {
				resultInfo = tr("PSO Optimization completed:\n");
				resultInfo += tr("Best Error: %1\n").arg(bestFitness, 0, 'e', 4);
				resultInfo += tr("Optimized parameters have been applied to the model.");
				QMessageBox::information(this, tr("Optimization Completed"), resultInfo);
			}

		} else if(m_selectedAlgorithm == ALGORITHM_GA && m_autoFitterGA) {
			// GA的类似处理

			double bestFitness = m_autoFitterGA->getBestFitness();

			if(message.contains("stopped by user", Qt::CaseInsensitive)) {
				resultInfo = tr("GA Optimization stopped by user:\n");
				resultInfo += tr("Best Error: %1\n").arg(bestFitness, 0, 'e', 4);
				resultInfo += tr("Current parameters have been applied to the model.");
				QMessageBox::information(this, tr("Optimization Stopped"), resultInfo);
			} else {
				resultInfo = tr("GA Optimization completed:\n");
				resultInfo += tr("Best Error: %1\n").arg(bestFitness, 0, 'e', 4);
				resultInfo += tr("Optimized parameters have been applied to the model.");
				QMessageBox::information(this, tr("Optimization Completed"), resultInfo);
			}
		}
	} else {
		// 只有真正失败的情况才显示警告
		QMessageBox::warning(this, tr("Optimization Failed"), message);
	}
}

void nmWxAutomaticFitting::onStopFitting()
{
	if(m_selectedAlgorithm == ALGORITHM_PSO && m_autoFitterPSO && m_autoFitterPSO->isRunning()) {
		m_autoFitterPSO->stopFitting();
	} else if(m_selectedAlgorithm == ALGORITHM_GA && m_autoFitterGA && m_autoFitterGA->isRunning()) {
	  m_autoFitterGA->stopFitting();
	  }
}

void nmWxAutomaticFitting::cleanupFitting()
{
	DEBUG_UI("=== CLEANUP FITTING START ===");

	if (m_progressTimer) {
		m_progressTimer->stop();
		delete m_progressTimer;
		m_progressTimer = nullptr;
		DEBUG_UI("Progress timer cleaned up");
	}

	// 断开所有信号连接，防止后续回调
	if (m_autoFitterPSO) {
		DEBUG_UI("Stopping and disconnecting PSO fitter");

		// 断开所有信号连接
		disconnect(m_autoFitterPSO, nullptr, nullptr, nullptr);

		// 如果还在运行，停止它
		if (m_autoFitterPSO->isRunning()) {
			m_autoFitterPSO->stopFitting();

			// 等待停止完成
			int waitCount = 0;
			while (m_autoFitterPSO->isRunning() && waitCount < 50) {
				QApplication::processEvents(QEventLoop::ExcludeUserInputEvents, 100);
				waitCount++;
			}

			// 如果仍在运行则强制停止
			if (m_autoFitterPSO->isRunning()) {
				DEBUG_UI("Force stopping PSO - timeout reached");
			}
		}

		delete m_autoFitterPSO;
		m_autoFitterPSO = nullptr;
		DEBUG_UI("PSO fitter cleaned up");
	}

	if (m_autoFitterGA) {
		DEBUG_UI("Stopping and disconnecting GA fitter");

		disconnect(m_autoFitterGA, nullptr, nullptr, nullptr);

		if (m_autoFitterGA->isRunning()) {
			m_autoFitterGA->stopFitting();

			int waitCount = 0;
			while (m_autoFitterGA->isRunning() && waitCount < 50) {
				QApplication::processEvents(QEventLoop::ExcludeUserInputEvents, 100);
				waitCount++;
			}

			// 如果仍在运行则强制停止
			if (m_autoFitterGA->isRunning()) {
				DEBUG_UI("Force stopping GA - timeout reached");
			}
		}

		delete m_autoFitterGA;
		m_autoFitterGA = nullptr;
		DEBUG_UI("GA fitter cleaned up");
	}

	// 清理进度监控
	if (m_progressMonitor) {
		// 先断开进度监控的信号连接
		disconnect(m_progressMonitor, nullptr, nullptr, nullptr);
		m_progressMonitor->hide();
		delete m_progressMonitor;
		m_progressMonitor = nullptr;
		DEBUG_UI("Progress monitor cleaned up");
	}

	if (m_progressDialog) {
		m_progressDialog->hide();
		delete m_progressDialog;
		m_progressDialog = nullptr;
		DEBUG_UI("Progress dialog cleaned up");
	}

	DEBUG_UI("=== CLEANUP FITTING END ===");
}

void nmWxAutomaticFitting::updateBestParametersToTable()
{
	QVector<double> bestSolution;

	// 获取最佳解决方案
	if (m_selectedAlgorithm == ALGORITHM_PSO && m_autoFitterPSO) {
		bestSolution = m_autoFitterPSO->getBestSolution();
	} else if (m_selectedAlgorithm == ALGORITHM_GA && m_autoFitterGA) {
		bestSolution = m_autoFitterGA->getBestSolution();
	}

	if (bestSolution.isEmpty()) return;

	// 获取启用的参数索引
	QVector<int> enabledParams;
	if(m_kCheckBox->isChecked()) enabledParams.append(0);      // 渗透率
	if(m_sCheckBox->isChecked()) enabledParams.append(1);      // 表皮系数  
	if(m_cCheckBox->isChecked()) enabledParams.append(2);      // 井筒储集系数
	if(m_phiCheckBox->isChecked()) enabledParams.append(3);    // 孔隙度
	if(m_piCheckBox->isChecked()) enabledParams.append(4);     // 初始压力
	if(m_hCheckBox->isChecked()) enabledParams.append(5);      // 储层厚度
	if(m_ctCheckBox->isChecked()) enabledParams.append(6);     // 综合压缩系数
	if(m_cfCheckBox->isChecked()) enabledParams.append(7);     // 岩石压缩系数
	if(m_soiCheckBox->isChecked()) enabledParams.append(8);    // 初始含油饱和度
	if(m_swiCheckBox->isChecked()) enabledParams.append(9);     // 初始含水饱和度
	if(m_sgiCheckBox->isChecked()) enabledParams.append(10);    // 初始含气饱和度

	// 范围收缩比例
	double shrinkFactor = 0.3;

	// 更新参数值和范围
	for (int i = 0; i < bestSolution.size() && i < enabledParams.size(); ++i) {
		int paramIndex = enabledParams[i];
		double bestValue = bestSolution[i];

		// 更新初始值
		m_parameterTable->item(paramIndex, 3)->setText(QString::number(bestValue, 'g', 4));

		// 获取当前的最小值和最大值
		double currentMin = m_parameterTable->item(paramIndex, 2)->text().toDouble();
		double currentMax = m_parameterTable->item(paramIndex, 4)->text().toDouble();
		double currentRange = currentMax - currentMin;

		// 计算新的范围
		double newHalfRange = currentRange * shrinkFactor * 0.5;
		double newMin = bestValue - newHalfRange;
		double newMax = bestValue + newHalfRange;

		// 确保某些参数不为负数
		if (paramIndex == 0 || paramIndex == 2 || paramIndex == 3 || paramIndex == 5) {
			newMin = qMax(newMin, 0.001);
		}

		// 确保最小范围，避免范围过小
		double minAllowedRange = currentRange * 0.05;
		if ((newMax - newMin) < minAllowedRange) {
			double center = (newMax + newMin) * 0.5;
			newMin = center - minAllowedRange * 0.5;
			newMax = center + minAllowedRange * 0.5;
		}

		// 更新表格中的最小值和最大值
		m_parameterTable->item(paramIndex, 2)->setText(QString::number(newMin, 'g', 4));
		m_parameterTable->item(paramIndex, 4)->setText(QString::number(newMax, 'g', 4));

		// 保存收缩后的范围
		switch(paramIndex) {
		case 0: // 渗透率
			automaticFittingData.getPermeabilityMin().setValue(newMin);
			automaticFittingData.getPermeabilityMax().setValue(newMax);
			break;
		case 1: // 表皮系数
			automaticFittingData.getSkinMin().setValue(newMin);
			automaticFittingData.getSkinMax().setValue(newMax);
			break;
		case 2: // 井筒储集系数
			automaticFittingData.getWellboreStorageMin().setValue(newMin);
			automaticFittingData.getWellboreStorageMax().setValue(newMax);
			break;
		case 3: // 孔隙度
			automaticFittingData.getPorosityMin().setValue(newMin);
			automaticFittingData.getPorosityMax().setValue(newMax);
			break;
		case 4: // 初始压力
			automaticFittingData.getInitialPressureMin().setValue(newMin);
			automaticFittingData.getInitialPressureMax().setValue(newMax);
			break;
		case 5: // 储层厚度
			automaticFittingData.getThicknessMin().setValue(newMin);
			automaticFittingData.getThicknessMax().setValue(newMax);
			break;
		case 6: // 综合压缩系数
			automaticFittingData.getCtMin().setValue(newMin);
			automaticFittingData.getCtMax().setValue(newMax);
			break;
		case 7: // 岩石压缩系数
			automaticFittingData.getCfMin().setValue(newMin);
			automaticFittingData.getCfMax().setValue(newMax);
			break;
		case 8: // 初始含油饱和度
			automaticFittingData.getSoiMin().setValue(newMin);
			automaticFittingData.getSoiMax().setValue(newMax);
			break;
		case 9: // 初始含水饱和度
			automaticFittingData.getSwiMin().setValue(newMin);
			automaticFittingData.getSwiMax().setValue(newMax);
			break;
		case 10: // 初始含气饱和度
			automaticFittingData.getSgiMin().setValue(newMin);
			automaticFittingData.getSgiMax().setValue(newMax);
			break;
		}
	}

	// 保存更新
	nmDataAnalyzeManager::getCurrentInstance()->updateAutomaticFittingData(automaticFittingData);
	// 更新完成后，通知参数界面刷新
	nmWxParameterProperty::notifyUpdateTable();
}