nmWTAI-Platform/Src/nmNum/nmCalculation/nmCalculationUtils.cpp

#include "nmCalculationUtils.h"

#include <QFile>
#include <QFileInfo>
#include <QDir>
#include <QDebug>
#include <QCoreApplication>
#include <QDateTime>
#include <QMutex>
#include <QMutexLocker>
#include <QRegExp>
#include <fstream>
#include <float.h>

#include "pch.h"

#ifdef Q_OS_WIN
#include <windows.h>
#else
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#endif

namespace
{
// HX_NWTM.dll 的配置和结果查询接口使用进程级共享状态，所有入口共用此锁。
QMutex s_oHxNwtmDllMutex;

bool isKrigingCancellationRequested(const QAtomicInt* pCancelRequested)
{
    return pCancelRequested != NULL &&
            static_cast<int>(*pCancelRequested) != 0;
}

class nmKrigingMutexLocker
{
public:
    nmKrigingMutexLocker()
        : m_pMutex(NULL),
          m_bLocked(false)
    {
    }

    ~nmKrigingMutexLocker()
    {
        if(m_bLocked && m_pMutex != NULL) {
            m_pMutex->unlock();
        }
    }

    bool lock(QMutex* pMutex, const QAtomicInt* pCancelRequested)
    {
        if(pMutex == NULL) {
            return false;
        }
        if(pCancelRequested == NULL) {
            pMutex->lock();
        } else {
            // 只改变等待方式，不改变 DLL 全局锁的保护范围和互斥语义。
            while(!pMutex->tryLock(100)) {
                if(isKrigingCancellationRequested(pCancelRequested)) {
                    return false;
                }
            }
        }
        m_pMutex = pMutex;
        m_bLocked = true;
        return true;
    }

private:
    QMutex* m_pMutex;
    bool m_bLocked;
};

QString krigingText(const char* sourceText)
{
    return QCoreApplication::translate("nmCalculationUtils", sourceText);
}

bool isFiniteValue(double value)
{
#ifdef _MSC_VER
    return _finite(value) != 0;
#else
    return std::isfinite(value);
#endif
}

// 从自动拟合运行目录名中解析进程 ID。
bool parseAutoFitRunDirectoryProcessId(const QString& directoryName,
                                       qint64* processId)
{
    // 名称为 <pid>-<yyyyMMdd_hhmmss_zzz>，极端重名时追加 -<counter>。
    QRegExp runDirectoryPattern(
        "^([0-9]+)-[0-9]{8}_[0-9]{6}_[0-9]{3}(-[0-9]+)?$");
    if(!runDirectoryPattern.exactMatch(directoryName)) {
        return false;
    }

    bool conversionSucceeded = false;
    const qint64 parsedProcessId =
        runDirectoryPattern.cap(1).toLongLong(&conversionSucceeded);
    if(!conversionSucceeded || parsedProcessId <= 0) {
        return false;
    }
    if(processId != NULL) {
        *processId = parsedProcessId;
    }
    return true;
}

bool isAutoFitRunProcessActive(const QString& directoryName)
{
    // 判断该运行目录所属的进程是否仍在运行。
    qint64 processId = 0;
    if(!parseAutoFitRunDirectoryProcessId(directoryName, &processId)) {
        return false;
    }
    if(processId == QCoreApplication::applicationPid()) {
        return true;
    }

#ifdef Q_OS_WIN
    if(static_cast<quint64>(processId) > 0xFFFFFFFFULL) {
        return false;
    }

    HANDLE processHandle = OpenProcess(
        SYNCHRONIZE, FALSE, static_cast<DWORD>(processId));
    if(processHandle == NULL) {
        // ERROR_INVALID_PARAMETER 表示 PID 已不存在；其他错误（例如拒绝访问）
        // 无法证明进程已退出，保守地保留目录。
        return GetLastError() != ERROR_INVALID_PARAMETER;
    }

    const DWORD waitResult = WaitForSingleObject(processHandle, 0);
    CloseHandle(processHandle);
    return waitResult == WAIT_TIMEOUT || waitResult == WAIT_FAILED;
#else
    const int result = kill(static_cast<pid_t>(processId), 0);
    return result == 0 || errno == EPERM;
#endif
}

bool isOwnedAutoFitTemporaryDirectory(const QString& directoryPath)
{
    if(directoryPath.trimmed().isEmpty()) {
        return false;
    }

    // 校验路径是否为本程序创建的自动拟合临时目录。
    const QString rootPath = nmCalculationUtils::autoFitTemporaryRootPath();
    const QFileInfo directoryInfo(QDir::cleanPath(
                                      QFileInfo(directoryPath).absoluteFilePath()));
    const QString parentPath = QDir::cleanPath(directoryInfo.absolutePath());
#ifdef Q_OS_WIN
    const Qt::CaseSensitivity pathCaseSensitivity = Qt::CaseInsensitive;
#else
    const Qt::CaseSensitivity pathCaseSensitivity = Qt::CaseSensitive;
#endif
    if(parentPath.compare(rootPath, pathCaseSensitivity) != 0 ||
            directoryInfo.isSymLink()) {
        return false;
    }

    return parseAutoFitRunDirectoryProcessId(directoryInfo.fileName(), NULL);
}

bool removeDirectoryRecursively(const QString& directoryPath)
{
    QDir directory(directoryPath);
    if(!directory.exists()) {
        return true;
    }

    const QFileInfoList entries = directory.entryInfoList(
        QDir::NoDotAndDotDot | QDir::AllEntries | QDir::Hidden | QDir::System);
    bool allRemoved = true;
    for(int i = 0; i < entries.size(); ++i) {
        const QFileInfo& entry = entries[i];
        if(entry.isSymLink()) {
            // 符号链接只删除链接本身。
            if(!QFile::remove(entry.absoluteFilePath())) {
                allRemoved = false;
            }
            continue;
        }
        if(entry.isDir()) {
            if(!removeDirectoryRecursively(entry.absoluteFilePath())) {
                allRemoved = false;
            }
            continue;
        }

        QFile file(entry.absoluteFilePath());
        if(!file.permissions().testFlag(QFile::WriteUser)) {
            file.setPermissions(file.permissions() | QFile::WriteUser);
        }
        if(!file.remove()) {
            allRemoved = false;
        }
    }

    return allRemoved && directory.rmdir(directory.absolutePath());
}

void setKrigingError(QString* errorMessage, const QString& message)
{
    if(errorMessage != NULL) {
        *errorMessage = message;
    }
}
}

nmCalculationUtils::nmCalculationUtils() {
}

QString nmCalculationUtils::autoFitTemporaryRootPath()
{
    // 返回系统临时目录下的自动拟合根目录。
    return QDir::cleanPath(
        QDir(QDir::tempPath()).absoluteFilePath("WTAI/AutoFit"));
}

QString nmCalculationUtils::createAutoFitTemporaryDirectory()
{
    const QString rootPath = autoFitTemporaryRootPath();
    if(!QDir().mkpath(rootPath)) {
        qWarning() << "Cannot create auto-fit temporary root:" << rootPath;
        return QString();
    }

    QDir rootDirectory(rootPath);
    // 使用进程 ID 和时间戳创建本次拟合的独立目录。
    const QString baseName = QString("%1-%2")
        .arg(QString::number(QCoreApplication::applicationPid()))
        .arg(QDateTime::currentDateTime().toString("yyyyMMdd_hhmmss_zzz"));
    for(int counter = 0; counter < 1000; ++counter) {
        const QString directoryName = counter == 0
            ? baseName
            : QString("%1-%2").arg(baseName).arg(counter);
        if(rootDirectory.mkdir(directoryName)) {
            return QDir::cleanPath(rootDirectory.absoluteFilePath(directoryName));
        }
    }

    qWarning() << "Cannot create unique auto-fit temporary directory in:" << rootPath;
    return QString();
}

bool nmCalculationUtils::removeAutoFitTemporaryDirectory(
        const QString& directoryPath)
{
    if(!isOwnedAutoFitTemporaryDirectory(directoryPath)) {
        qWarning() << "Refusing to remove non auto-fit directory:" << directoryPath;
        return false;
    }
    return removeDirectoryRecursively(QDir::cleanPath(directoryPath));
}

void nmCalculationUtils::cleanupStaleAutoFitTemporaryDirectories(
        int maximumAgeHours)
{
    // 清理超过保留时间且所属进程已经退出的残留目录。
    if(maximumAgeHours <= 0) {
        return;
    }

    const QString rootPath = autoFitTemporaryRootPath();
    QDir rootDirectory(rootPath);
    if(!rootDirectory.exists()) {
        return;
    }

    const qint64 maximumAgeSeconds =
        static_cast<qint64>(maximumAgeHours) * 60 * 60;
    const QDateTime now = QDateTime::currentDateTime();
    const QFileInfoList directories = rootDirectory.entryInfoList(
        QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);
    for(int i = 0; i < directories.size(); ++i) {
        const QFileInfo& directoryInfo = directories[i];
        if(!isOwnedAutoFitTemporaryDirectory(directoryInfo.absoluteFilePath())) {
            continue;
        }
        if(directoryInfo.lastModified().secsTo(now) < maximumAgeSeconds) {
            continue;
        }
        if(isAutoFitRunProcessActive(directoryInfo.fileName())) {
            continue;
        }
        if(!removeAutoFitTemporaryDirectory(directoryInfo.absoluteFilePath())) {
            qWarning() << "Failed to remove stale auto-fit directory:"
                       << directoryInfo.absoluteFilePath();
        }
    }
}

QMutex* nmCalculationUtils::getHxNwtmDllMutex()
{
    return &s_oHxNwtmDllMutex;
}

void nmCalculationUtils::cleanupPebiGridDebugFiles()
{
    const QDir workingDirectory(QDir::currentPath());
    QStringList fileNames;
    fileNames << "TRI_cell.csv" << "PEBI_cell.csv";

    for(int i = 0; i < fileNames.size(); ++i) {
        const QString filePath = workingDirectory.absoluteFilePath(fileNames[i]);
        if(QFile::exists(filePath) && !QFile::remove(filePath)) {
            qWarning() << "Failed to remove PEBI grid debug file:" << filePath;
        }
    }
}

double nmCalculationUtils::milliDarcyToDarcy(double dPermeabilityMilliDarcy)
{
    // PEBI输入结构使用D，数据层统一使用mD，因此仅在求解器边界换算。
    return dPermeabilityMilliDarcy / 1000.0;
}

bool nmCalculationUtils::copyFileToDir(QString filePath, QString destDir) {
    // 如果文件不存在，则退出
    if(!QFile::exists(filePath)) {
        return false;
    }

    // 如果目标目录不存在，则创建
    if(!QDir(destDir).exists()) {
        if(!QDir().mkdir(destDir)) {
            qWarning() << "cannot mkdir:" << destDir;
            return false;
        }
    }

    // 获取源文件的文件名
    QString fileName = QFileInfo(filePath).fileName();
    // 构造目标文件的完整路径
    QString destinationFilePath = QDir(destDir).filePath(fileName);

    // 如果目标文件已存在，则删除
    if(QFile::exists(destinationFilePath)) {
        QFile destinationFile(destinationFilePath);

        if(!destinationFile.remove()) {
            qWarning() << "cannot delete file:" << destinationFilePath;
            return false;
        }
    }

    // 拷贝文件
    if(QFile::copy(filePath, destinationFilePath)) {
        qDebug() << "file copy success:" << destinationFilePath;
        return true;
    } else {
        qWarning() << "file copy failed:" << destinationFilePath;
        return false;
    }

    return true;
}

bool nmCalculationUtils::createDirectoryIfNotExists(QString directoryPath) {
    QDir dir(directoryPath);

    // 检查目录是否存在
    if(dir.exists()) {
        // 目录已存在
        return true;
    }

    // 尝试创建目录
    if(dir.mkpath(directoryPath)) {
        // 创建成功
        return true;
    }

    // 创建失败
    qDebug() << "创建目录失败，错误代码。";
    return false;
}

bool nmCalculationUtils::copyFile(const std::string& sourcePath, const std::string& destinationPath) {
    std::ifstream src(sourcePath, std::ios::binary); // 以二进制模式打开源文件
    std::ofstream dst(destinationPath, std::ios::binary); // 以二进制模式打开目标文件

    if(!src || !dst) {
        std::cerr << "文件打开失败" << std::endl;
        return false;
    }

    dst << src.rdbuf(); // 拷贝文件内容
    return true;
}

bool nmCalculationUtils::removeDirectory(const QString &dirPath) {
    QDir dir(dirPath);

    if(!dir.exists()) {
        qDebug() << "Directory does not exist.";
        return true;
    }

    // 获取目录中的所有文件和目录
    QFileInfoList fileList = dir.entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden);

    foreach(QFileInfo fileInfo, fileList) {
        if(fileInfo.isDir()) {
            // 递归删除子目录
            if(!removeDirectory(fileInfo.absoluteFilePath())) {
                return false;
            }
        } else {
            // 删除文件
            if(!QFile::remove(fileInfo.absoluteFilePath())) {
                qDebug() << "Failed to remove file:" << fileInfo.absoluteFilePath();
                return false;
            }
        }
    }

    // 删除目录自身
    if(!dir.rmdir(dirPath)) {
        qDebug() << "Failed to remove directory:" << dirPath;
        return false;
    }

    return true;
}

bool nmCalculationUtils::writeFile(const QStringList& content, const QString &filePath) {
    QFile file(filePath);

    //检查
    if(!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        qWarning("Cannot open file for writing: %s", qPrintable(file.errorString()));
        return false;
    }

    QTextStream out(&file);
    out << content.join("\n");
    file.close();
    return true;
}

QStringList nmCalculationUtils::readFile(const QString &filePath) {
    QStringList content;
    // 打开文件
    QFile file(filePath);

    if(!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        qDebug() << "Failed to open file:" << filePath;
        return content;
    }

    // 使用QTextStream读取文件
    QTextStream in(&file);

    while(!in.atEnd()) {
        // 读取一行
        QString line = in.readLine();
        // 将行内容放入QStringList
        content.append(line);
    }

    // 关闭文件
    file.close();

    return content;
}

bool nmCalculationUtils::calculateKriging(
        const QVector<QPointF>& targetPoints,
        const QVector<QPointF>& measurementPoints,
        const QVector<double>& measurementValues,
        double nugget,
        double sill,
        double range,
        int model,
        const QString& licensePath,
        QVector<double>& outputValues,
        QString* errorMessage,
        const QAtomicInt* pCancelRequested)
{
    outputValues.clear();
    setKrigingError(errorMessage, QString());

    if(isKrigingCancellationRequested(pCancelRequested)) {
        setKrigingError(errorMessage, krigingText("Kriging calculation was cancelled."));
        return false;
    }

    if(targetPoints.isEmpty()) {
        setKrigingError(errorMessage, krigingText("No interpolation points are available."));
        return false;
    }

    if(measurementPoints.size() < 2) {
        setKrigingError(errorMessage,
                        krigingText("At least two measurement points are required."));
        return false;
    }

    if(measurementPoints.size() != measurementValues.size()) {
        setKrigingError(errorMessage,
                        krigingText("Measurement point coordinates and values do not match."));
        return false;
    }

    if(!isFiniteValue(nugget) || !isFiniteValue(sill) ||
            !isFiniteValue(range) || nugget < 0.0 || sill <= 0.0 || range <= 0.0) {
        setKrigingError(errorMessage, krigingText("Kriging parameters are invalid."));
        return false;
    }

    if(model < 0 || model > 2) {
        setKrigingError(errorMessage, krigingText("The Kriging model is invalid."));
        return false;
    }

    for(int i = 0; i < targetPoints.size(); ++i) {
        if((i % 256) == 0 &&
           isKrigingCancellationRequested(pCancelRequested)) {
            setKrigingError(errorMessage, krigingText("Kriging calculation was cancelled."));
            return false;
        }
        if(!isFiniteValue(targetPoints[i].x()) || !isFiniteValue(targetPoints[i].y())) {
            setKrigingError(errorMessage,
                            krigingText("An interpolation point contains an invalid coordinate."));
            return false;
        }
    }

    for(int i = 0; i < measurementPoints.size(); ++i) {
        if(isKrigingCancellationRequested(pCancelRequested)) {
            setKrigingError(errorMessage, krigingText("Kriging calculation was cancelled."));
            return false;
        }
        if(!isFiniteValue(measurementPoints[i].x()) ||
                !isFiniteValue(measurementPoints[i].y()) ||
                !isFiniteValue(measurementValues[i])) {
            setKrigingError(errorMessage,
                            krigingText("A measurement point contains invalid data."));
            return false;
        }

        for(int j = 0; j < i; ++j) {
            if(measurementPoints[i] == measurementPoints[j]) {
                setKrigingError(errorMessage,
                                krigingText("Measurement point coordinates cannot be duplicated."));
                return false;
            }
        }
    }

    if(licensePath.isEmpty() || !QFileInfo(licensePath).exists()) {
        setKrigingError(errorMessage, krigingText("The solver license file was not found."));
        return false;
    }

    // Kriging 与建网、模型求解来自同一个 DLL，不能在不同线程中并发进入。
    nmKrigingMutexLocker oDllLocker;
    if(!oDllLocker.lock(getHxNwtmDllMutex(), pCancelRequested)) {
        setKrigingError(errorMessage, krigingText("Kriging calculation was cancelled."));
        return false;
    }
    HMODULE dll = LoadLibrary(L"HX_NWTM.dll");
    if(dll == NULL) {
        setKrigingError(errorMessage, krigingText("Failed to load HX_NWTM.dll."));
        return false;
    }

    typedef void (*HX_NWTM_KRINGING_Func)(HX_KRING_OUTPUT&,
                                          const HX_KRING_INPUT,
                                          std::string);
    HX_NWTM_KRINGING_Func krigingFunction =
            (HX_NWTM_KRINGING_Func)GetProcAddress(dll, "HX_NWTM_KRINGING");
    if(krigingFunction == NULL) {
        FreeLibrary(dll);
        setKrigingError(errorMessage,
                        krigingText("The Kriging interface was not found in HX_NWTM.dll."));
        return false;
    }

    // 求解器p参数每行保存{x, y}，并保持targetPoints的原始顺序.
    dVec2 targetData;
    targetData.reserve(targetPoints.size());
    for(int i = 0; i < targetPoints.size(); ++i) {
        dVec1 point(2, 0.0);
        point[0] = targetPoints[i].x();
        point[1] = targetPoints[i].y();
        targetData.push_back(point);
    }

    // 求解器v参数每行保存{x, y, value}，坐标和值按相同下标配对.
    dVec2 measurementData;
    measurementData.reserve(measurementPoints.size());
    for(int i = 0; i < measurementPoints.size(); ++i) {
        dVec1 point(3, 0.0);
        point[0] = measurementPoints[i].x();
        point[1] = measurementPoints[i].y();
        point[2] = measurementValues[i];
        measurementData.push_back(point);
    }

    bool calculationSucceeded = true;
    QString calculationError;

    // 局部作用域保证求解器输入、输出对象在FreeLibrary前析构.
    {
        HX_KRING_INPUT input(nugget, sill, range, model,
                             targetData, measurementData);
        HX_KRING_OUTPUT output;

        try {
            krigingFunction(output, input, licensePath.toStdString());
        } catch(const std::exception& exception) {
            calculationSucceeded = false;
            calculationError = krigingText("Kriging calculation failed: %1")
                    .arg(QString::fromLocal8Bit(exception.what()));
        } catch(...) {
            calculationSucceeded = false;
            calculationError = krigingText("Kriging calculation failed.");
        }

        // DLL 无取消入口；调用期间收到停止请求时只丢弃返回值，不提交插值结果。
        if(calculationSucceeded &&
           isKrigingCancellationRequested(pCancelRequested)) {
            calculationSucceeded = false;
            calculationError = krigingText("Kriging calculation was cancelled.");
        }

        if(calculationSucceeded &&
                output.v.size() != static_cast<size_t>(targetPoints.size())) {
            calculationSucceeded = false;
            calculationError = krigingText(
                        "The Kriging result count does not match the interpolation points.");
        }

        if(calculationSucceeded) {
            outputValues.reserve(targetPoints.size());
            for(size_t i = 0; i < output.v.size(); ++i) {
                if((i % 256) == 0 &&
                   isKrigingCancellationRequested(pCancelRequested)) {
                    calculationSucceeded = false;
                    calculationError = krigingText("Kriging calculation was cancelled.");
                    break;
                }
                if(!isFiniteValue(output.v[i])) {
                    calculationSucceeded = false;
                    calculationError = krigingText(
                                "The Kriging result contains an invalid value.");
                    break;
                }
                outputValues.append(output.v[i]);
            }
        }
    }

    FreeLibrary(dll);
    if(!calculationSucceeded) {
        outputValues.clear();
        setKrigingError(errorMessage, calculationError);
    }
    return calculationSucceeded;
}