#include "nmPebiResultSnapshotSerializer.h"

#include "nmDataJsonTools.h"
#include "nmPebiCellMapping.h"
#include "nmPebiResultPropertyCatalog.h"
#include "nmPebiResultSnapshot.h"
#include "nmPebiResultSnapshotBuilder.h"

#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QMap>
#include <QSet>
#include <QUuid>
#include <QtGlobal>

#include <float.h>
#include <limits.h>
#include <math.h>
#include <new>

#include <vtkCellData.h>
#include <vtkDoubleArray.h>
#include <vtkUnstructuredGrid.h>

#include <rapidjson/document.h>

namespace {

const char g_aPressureMagic[8] = { 'N', 'M', 'P', 'R', 'E', 'S', '3', 0 };
const char g_aCurvesMagic[8] = { 'N', 'M', 'C', 'U', 'R', 'V', '3', 0 };
const char g_aStaticMagic[8] = { 'N', 'M', 'S', 'T', 'A', 'T', '5', 0 };
const quint32 g_nBinaryFormatVersion = 1;
const int g_nSnapshotFormatVersion = 5;
const quint32 g_nEndianMarker = 0x01020304u;
const quint64 g_nMaximumCellCount = 50000000ull;
const quint32 g_nMaximumFrameCount = 10000u;
const quint32 g_nMaximumWellCount = 10000u;
const quint32 g_nMaximumCurveSeries = 64u;
const quint64 g_nMaximumCurvePoints = 50000000ull;
const quint32 g_nMaximumUuidBytes = 128u;
const quint32 g_nMaximumPropertyIdBytes = 64u;
const quint32 g_nStaticPropertyCount = 3u;
const quint64 g_nMaximumSnapshotJsonBytes = 64ull * 1024ull * 1024ull;
const qint64 g_nStreamChunkBytes = 4 * 1024 * 1024;
const int g_nCurveValidationBufferValues = 4096;

bool setError(QString* pError, const QString& sError)
{
    if(pError != NULL)
    {
        *pError = sError;
    }
    return false;
}

bool isFiniteValue(double dValue)
{
#if defined(_MSC_VER)
    return _finite(dValue) != 0;
#else
    return qIsFinite(dValue);
#endif
}

bool safeMultiply(quint64 nLeft, quint64 nRight, quint64& nProduct)
{
    if(nLeft != 0 && nRight > (~static_cast<quint64>(0)) / nLeft)
    {
        return false;
    }
    nProduct = nLeft * nRight;
    return true;
}

bool safeAdd(quint64 nLeft, quint64 nRight, quint64& nSum)
{
    if(nRight > (~static_cast<quint64>(0)) - nLeft)
    {
        return false;
    }
    nSum = nLeft + nRight;
    return true;
}

bool writeAll(QFile& oFile, const char* pData, quint64 nBytes)
{
    quint64 nWritten = 0;
    while(nWritten < nBytes)
    {
        const qint64 nChunk = static_cast<qint64>(qMin(
                static_cast<quint64>(g_nStreamChunkBytes),
                nBytes - nWritten));
        if(oFile.write(pData + static_cast<size_t>(nWritten), nChunk) != nChunk)
        {
            return false;
        }
        nWritten += static_cast<quint64>(nChunk);
    }
    return true;
}

bool readAll(QFile& oFile, char* pData, quint64 nBytes)
{
    quint64 nRead = 0;
    while(nRead < nBytes)
    {
        const qint64 nChunk = static_cast<qint64>(qMin(
                static_cast<quint64>(g_nStreamChunkBytes),
                nBytes - nRead));
        if(oFile.read(pData + static_cast<size_t>(nRead), nChunk) != nChunk)
        {
            return false;
        }
        nRead += static_cast<quint64>(nChunk);
    }
    return true;
}

template<typename T>
bool writePod(QFile& oFile, const T& oValue)
{
    return writeAll(oFile, reinterpret_cast<const char*>(&oValue),
                    static_cast<quint64>(sizeof(T)));
}

template<typename T>
bool readPod(QFile& oFile, T& oValue)
{
    return readAll(oFile, reinterpret_cast<char*>(&oValue),
                   static_cast<quint64>(sizeof(T)));
}

bool hasMagic(const char* pActual, const char* pExpected)
{
    for(int nIndex = 0; nIndex < 8; ++nIndex)
    {
        if(pActual[nIndex] != pExpected[nIndex])
        {
            return false;
        }
    }
    return true;
}

rapidjson::Value toJsonString(const QString& sValue,
                              rapidjson::Document::AllocatorType& oAllocator)
{
    const QByteArray baValue = sValue.toUtf8();
    return rapidjson::Value(baValue.constData(),
                            static_cast<rapidjson::SizeType>(baValue.size()),
                            oAllocator);
}

QString propertyTimeTypeText(NM_PEBI_RESULT_PROPERTY_TIME_TYPE eType)
{
    return eType == NM_PebiResultProperty_Dynamic
            ? QString::fromLatin1("dynamic")
            : QString::fromLatin1("static");
}

QString propertySourceText(NM_PEBI_RESULT_PROPERTY_SOURCE eSource)
{
    return eSource == NM_PebiResultPropertySource_SolverOutput
            ? QString::fromLatin1("solver-output")
            : QString::fromLatin1("static-calculation");
}

QString propertyAssociationText(
        NM_PEBI_RESULT_PROPERTY_ASSOCIATION eAssociation)
{
    Q_UNUSED(eAssociation);
    return QString::fromLatin1("cell-data");
}

QString propertyRangePolicyText(
        NM_PEBI_RESULT_PROPERTY_RANGE_POLICY ePolicy)
{
    return ePolicy == NM_PebiResultPropertyRange_AllFrames
            ? QString::fromLatin1("all-frames")
            : QString::fromLatin1("current-array");
}

bool readRequiredString(const rapidjson::Value& oParent,
                        const char* pName,
                        QString& sValue)
{
    if(!oParent.IsObject() || !oParent.HasMember(pName) ||
       !oParent[pName].IsString())
    {
        return false;
    }
    sValue = QString::fromUtf8(oParent[pName].GetString(),
            static_cast<int>(oParent[pName].GetStringLength()));
    return true;
}

void addPropertyCatalog(
        rapidjson::Value& oParent,
        rapidjson::Document::AllocatorType& oAllocator)
{
    rapidjson::Value oProperties(rapidjson::kArrayType);
    const QList<nmPebiResultPropertyDescriptor> listDescriptors =
            nmPebiResultPropertyCatalog::descriptors();
    for(int nIndex = 0; nIndex < listDescriptors.size(); ++nIndex)
    {
        const nmPebiResultPropertyDescriptor& oDescriptor =
                listDescriptors[nIndex];
        rapidjson::Value oProperty(rapidjson::kObjectType);
        oProperty.AddMember("Id", toJsonString(
                oDescriptor.m_sPropertyId, oAllocator), oAllocator);
        oProperty.AddMember("DisplayNameSourceText", toJsonString(
                oDescriptor.m_sDisplayNameSourceText, oAllocator), oAllocator);
        oProperty.AddMember("BaseUnit", toJsonString(
                oDescriptor.m_sBaseUnit, oAllocator), oAllocator);
        oProperty.AddMember("DefaultDisplayUnit", toJsonString(
                oDescriptor.m_sDefaultDisplayUnit, oAllocator), oAllocator);
        oProperty.AddMember("TimeType", toJsonString(
                propertyTimeTypeText(oDescriptor.m_eTimeType),
                oAllocator), oAllocator);
        oProperty.AddMember("Source", toJsonString(
                propertySourceText(oDescriptor.m_eSource),
                oAllocator), oAllocator);
        oProperty.AddMember("Association", toJsonString(
                propertyAssociationText(oDescriptor.m_eAssociation),
                oAllocator), oAllocator);
        oProperty.AddMember("RangePolicy", toJsonString(
                propertyRangePolicyText(oDescriptor.m_eRangePolicy),
                oAllocator), oAllocator);
        oProperties.PushBack(oProperty, oAllocator);
    }
    oParent.AddMember("Properties", oProperties, oAllocator);
}

bool validatePropertyCatalog(const rapidjson::Value& oDocument,
                             QString* pError)
{
    if(!oDocument.IsObject() || !oDocument.HasMember("Properties") ||
       !oDocument["Properties"].IsArray())
    {
        return setError(pError, "PEBI snapshot property catalog is missing.");
    }
    const QList<nmPebiResultPropertyDescriptor> listDescriptors =
            nmPebiResultPropertyCatalog::descriptors();
    const rapidjson::Value& oProperties = oDocument["Properties"];
    if(oProperties.Size() !=
       static_cast<rapidjson::SizeType>(listDescriptors.size()))
    {
        return setError(pError, "PEBI snapshot property catalog is incomplete.");
    }
    QSet<QString> setPropertyIds;
    for(rapidjson::SizeType nIndex = 0;
        nIndex < oProperties.Size(); ++nIndex)
    {
        const rapidjson::Value& oProperty = oProperties[nIndex];
        QString sPropertyId;
        QString sDisplayName;
        QString sBaseUnit;
        QString sDisplayUnit;
        QString sTimeType;
        QString sSource;
        QString sAssociation;
        QString sRangePolicy;
        if(!readRequiredString(oProperty, "Id", sPropertyId) ||
           !readRequiredString(oProperty, "DisplayNameSourceText",
                               sDisplayName) ||
           !readRequiredString(oProperty, "BaseUnit", sBaseUnit) ||
           !readRequiredString(oProperty, "DefaultDisplayUnit",
                               sDisplayUnit) ||
           !readRequiredString(oProperty, "TimeType", sTimeType) ||
           !readRequiredString(oProperty, "Source", sSource) ||
           !readRequiredString(oProperty, "Association", sAssociation) ||
           !readRequiredString(oProperty, "RangePolicy", sRangePolicy) ||
           setPropertyIds.contains(sPropertyId))
        {
            return setError(pError,
                    "PEBI snapshot property descriptor is invalid.");
        }
        nmPebiResultPropertyDescriptor oExpected;
        if(!nmPebiResultPropertyCatalog::findDescriptor(
                sPropertyId, oExpected) ||
           sDisplayName != oExpected.m_sDisplayNameSourceText ||
           sBaseUnit != oExpected.m_sBaseUnit ||
           sDisplayUnit != oExpected.m_sDefaultDisplayUnit ||
           sTimeType != propertyTimeTypeText(oExpected.m_eTimeType) ||
           sSource != propertySourceText(oExpected.m_eSource) ||
           sAssociation != propertyAssociationText(
                oExpected.m_eAssociation) ||
           sRangePolicy != propertyRangePolicyText(
                oExpected.m_eRangePolicy))
        {
            return setError(pError,
                    "PEBI snapshot property catalog does not match V5.");
        }
        setPropertyIds.insert(sPropertyId);
    }
    return setPropertyIds.size() == listDescriptors.size();
}

void addFileReference(rapidjson::Value& oParent,
                      const char* pName,
                      const nmNumericalFileReference& oReference,
                      rapidjson::Document::AllocatorType& oAllocator)
{
    rapidjson::Value oJson(rapidjson::kObjectType);
    oJson.AddMember("Path", toJsonString(oReference.m_sRelativePath,
                                          oAllocator), oAllocator);
    oJson.AddMember("Length", oReference.m_nLength, oAllocator);
    oJson.AddMember("Sha1", toJsonString(oReference.m_sSha1,
                                          oAllocator), oAllocator);
    oParent.AddMember(rapidjson::Value(pName, oAllocator).Move(),
                      oJson, oAllocator);
}

bool readFileReference(const rapidjson::Value& oParent,
                       const char* pName,
                       nmNumericalFileReference& oReference)
{
    if(!oParent.IsObject() || !oParent.HasMember(pName) ||
       !oParent[pName].IsObject())
    {
        return false;
    }
    const rapidjson::Value& oJson = oParent[pName];
    if(!oJson.HasMember("Path") || !oJson["Path"].IsString() ||
       !oJson.HasMember("Length") || !oJson["Length"].IsUint64() ||
       !oJson.HasMember("Sha1") || !oJson["Sha1"].IsString() ||
       oJson["Sha1"].GetStringLength() != 40u)
    {
        return false;
    }
    oReference.m_sRelativePath = QString::fromUtf8(
            oJson["Path"].GetString(),
            static_cast<int>(oJson["Path"].GetStringLength()));
    oReference.m_nLength = oJson["Length"].GetUint64();
    oReference.m_sSha1 = QString::fromLatin1(
            oJson["Sha1"].GetString(),
            static_cast<int>(oJson["Sha1"].GetStringLength()));
    return oReference.isValid();
}

void addDoubleVector(rapidjson::Value& oParent,
                     const char* pName,
                     const QVector<double>& vecValues,
                     rapidjson::Document::AllocatorType& oAllocator)
{
    rapidjson::Value oArray(rapidjson::kArrayType);
    for(int nIndex = 0; nIndex < vecValues.size(); ++nIndex)
    {
        oArray.PushBack(vecValues[nIndex], oAllocator);
    }
    oParent.AddMember(rapidjson::Value(pName, oAllocator).Move(),
                      oArray, oAllocator);
}

bool readDoubleVector(const rapidjson::Value& oParent,
                      const char* pName,
                      QVector<double>& vecValues)
{
    if(!oParent.IsObject() || !oParent.HasMember(pName) ||
       !oParent[pName].IsArray() ||
       oParent[pName].Size() > static_cast<rapidjson::SizeType>(10000000))
    {
        return false;
    }
    const rapidjson::Value& oArray = oParent[pName];
    QVector<double> vecLoaded;
    vecLoaded.reserve(static_cast<int>(oArray.Size()));
    for(rapidjson::SizeType nIndex = 0; nIndex < oArray.Size(); ++nIndex)
    {
        if(!oArray[nIndex].IsNumber() ||
           !isFiniteValue(oArray[nIndex].GetDouble()))
        {
            return false;
        }
        vecLoaded.append(oArray[nIndex].GetDouble());
    }
    vecValues.swap(vecLoaded);
    return true;
}

bool writeCurve(QFile& oFile, const QVector<QVector<double> >& vecCurve)
{
    const quint32 nSeriesCount = static_cast<quint32>(vecCurve.size());
    if(!writePod(oFile, nSeriesCount))
    {
        return false;
    }
    for(int nSeries = 0; nSeries < vecCurve.size(); ++nSeries)
    {
        const QVector<double>& vecValues = vecCurve[nSeries];
        const quint64 nPointCount = static_cast<quint64>(vecValues.size());
        quint64 nBytes = 0;
        if(!safeMultiply(nPointCount, sizeof(double), nBytes) ||
           !writePod(oFile, nPointCount) ||
           (nBytes > 0 && !writeAll(oFile,
                reinterpret_cast<const char*>(vecValues.constData()), nBytes)))
        {
            return false;
        }
    }
    return true;
}

bool readCurve(QFile& oFile,
               QVector<QVector<double> >* pCurve,
               quint64& nTotalPoints)
{
    quint32 nSeriesCount = 0;
    if(!readPod(oFile, nSeriesCount) || nSeriesCount > g_nMaximumCurveSeries)
    {
        return false;
    }
    QVector<QVector<double> > vecLoaded;
    if(pCurve != NULL)
    {
        vecLoaded.resize(static_cast<int>(nSeriesCount));
    }
    for(quint32 nSeries = 0; nSeries < nSeriesCount; ++nSeries)
    {
        quint64 nPointCount = 0;
        quint64 nBytes = 0;
        if(!readPod(oFile, nPointCount) ||
           nPointCount > g_nMaximumCurvePoints ||
           nTotalPoints > g_nMaximumCurvePoints - nPointCount ||
           !safeMultiply(nPointCount, sizeof(double), nBytes) ||
           nBytes > static_cast<quint64>(oFile.bytesAvailable()) ||
           nPointCount > static_cast<quint64>(INT_MAX))
        {
            return false;
        }
        nTotalPoints += nPointCount;
        if(pCurve == NULL)
        {
            // validate() 不构造完整曲线，但仍必须真实读取并检查所有数值。
            // 固定大小缓冲避免损坏文件利用声明长度造成额外大块分配。
            double aBuffer[g_nCurveValidationBufferValues];
            quint64 nRemaining = nPointCount;
            while(nRemaining > 0)
            {
                const int nChunk = static_cast<int>(qMin(
                        nRemaining,
                        static_cast<quint64>(
                            g_nCurveValidationBufferValues)));
                const quint64 nChunkBytes =
                        static_cast<quint64>(nChunk) * sizeof(double);
                if(!readAll(oFile, reinterpret_cast<char*>(aBuffer),
                            nChunkBytes))
                {
                    return false;
                }
                for(int nIndex = 0; nIndex < nChunk; ++nIndex)
                {
                    if(!isFiniteValue(aBuffer[nIndex]))
                    {
                        return false;
                    }
                }
                nRemaining -= static_cast<quint64>(nChunk);
            }
        }
        else
        {
            QVector<double>& vecValues = vecLoaded[static_cast<int>(nSeries)];
            vecValues.resize(static_cast<int>(nPointCount));
            if(nBytes > 0 && !readAll(oFile,
                    reinterpret_cast<char*>(vecValues.data()), nBytes))
            {
                return false;
            }
            for(int nIndex = 0; nIndex < vecValues.size(); ++nIndex)
            {
                if(!isFiniteValue(vecValues[nIndex]))
                {
                    return false;
                }
            }
        }
    }
    if(pCurve != NULL)
    {
        pCurve->swap(vecLoaded);
    }
    return true;
}

bool readPressureFrames(const QString& sFilePath,
                        quint64 nExpectedCellCount,
                        quint32 nExpectedFrameCount,
                        nmPebiResultSnapshotBuilder* pBuilder,
                        QString* pError,
                        double* pActualMinimum = NULL,
                        double* pActualMaximum = NULL)
{
    const QFileInfo oInfo(sFilePath);
    if(!oInfo.isFile() || oInfo.size() < 0 ||
       static_cast<quint64>(oInfo.size()) >
            nmNumericalResultPersistence::maximumBinaryPayloadBytes())
    {
        return setError(pError, "PEBI pressure payload is missing or too large.");
    }
    QFile oFile(sFilePath);
    if(!oFile.open(QIODevice::ReadOnly))
    {
        return setError(pError, "Cannot open PEBI pressure frame file.");
    }
    char aMagic[8] = { 0 };
    quint32 nVersion = 0;
    quint32 nEndian = 0;
    quint64 nCellCount = 0;
    quint32 nFrameCount = 0;
    quint64 nFrameBytes = 0;
    quint64 nPerFrameBytes = 0;
    quint64 nPayloadBytes = 0;
    quint64 nExpectedBytes = 0;
    const quint64 nHeaderBytes = 8 + sizeof(quint32) + sizeof(quint32) +
            sizeof(quint64) + sizeof(quint32);
    bool bOk = readAll(oFile, aMagic, 8) &&
            hasMagic(aMagic, g_aPressureMagic) &&
            readPod(oFile, nVersion) && nVersion == g_nBinaryFormatVersion &&
            readPod(oFile, nEndian) && nEndian == g_nEndianMarker &&
            readPod(oFile, nCellCount) && nCellCount > 0 &&
            nCellCount <= g_nMaximumCellCount &&
            readPod(oFile, nFrameCount) && nFrameCount > 0 &&
            nFrameCount <= g_nMaximumFrameCount &&
            nCellCount == nExpectedCellCount &&
            nFrameCount == nExpectedFrameCount &&
            safeMultiply(nCellCount, sizeof(double), nFrameBytes) &&
            safeAdd(sizeof(double), nFrameBytes, nPerFrameBytes) &&
            safeMultiply(nPerFrameBytes, nFrameCount, nPayloadBytes) &&
            safeAdd(nHeaderBytes, nPayloadBytes, nExpectedBytes) &&
            nExpectedBytes == static_cast<quint64>(oInfo.size());
    double dPreviousTime = 0.0;
    double dActualMinimum = DBL_MAX;
    double dActualMaximum = -DBL_MAX;
    for(quint32 nFrame = 0; bOk && nFrame < nFrameCount; ++nFrame)
    {
        double dTime = 0.0;
        bOk = readPod(oFile, dTime) && isFiniteValue(dTime) &&
                (nFrame == 0 || dTime > dPreviousTime);
        if(!bOk)
        {
            break;
        }
        if(pBuilder == NULL)
        {
            // 发布前验证必须真正读取压力值，不能通过 seek 跳过损坏或非有限数据。
            double aBuffer[1024];
            quint64 nRemaining = nCellCount;
            while(bOk && nRemaining > 0)
            {
                const quint64 nChunkValues = qMin(
                        static_cast<quint64>(1024), nRemaining);
                const quint64 nChunkBytes =
                        nChunkValues * sizeof(double);
                bOk = readAll(oFile,
                        reinterpret_cast<char*>(aBuffer), nChunkBytes);
                for(quint64 nCell = 0;
                    bOk && nCell < nChunkValues; ++nCell)
                {
                    bOk = isFiniteValue(aBuffer[nCell]);
                    dActualMinimum = qMin(dActualMinimum, aBuffer[nCell]);
                    dActualMaximum = qMax(dActualMaximum, aBuffer[nCell]);
                }
                nRemaining -= nChunkValues;
            }
        }
        else
        {
            vtkSmartPointer<vtkDoubleArray> pPressure =
                    vtkSmartPointer<vtkDoubleArray>::New();
            pPressure->SetName("p");
            pPressure->SetNumberOfComponents(1);
            pPressure->SetNumberOfTuples(static_cast<vtkIdType>(nCellCount));
            double* pValues = pPressure->GetPointer(0);
            bOk = pValues != NULL &&
                    pPressure->GetNumberOfTuples() ==
                        static_cast<vtkIdType>(nCellCount) &&
                    readAll(oFile, reinterpret_cast<char*>(pValues),
                            nFrameBytes);
            for(quint64 nCell = 0; bOk && nCell < nCellCount; ++nCell)
            {
                bOk = isFiniteValue(pValues[nCell]);
                dActualMinimum = qMin(dActualMinimum, pValues[nCell]);
                dActualMaximum = qMax(dActualMaximum, pValues[nCell]);
            }
            bOk = bOk && pBuilder->addPressureFrame(dTime, pPressure) &&
                    pPressure == NULL;
        }
        dPreviousTime = dTime;
    }
    bOk = bOk && oFile.atEnd();
    oFile.close();
    if(!bOk || dActualMinimum == DBL_MAX || dActualMaximum == -DBL_MAX)
    {
        return setError(pError, "PEBI pressure frame file is damaged.");
    }
    if(pActualMinimum != NULL)
    {
        *pActualMinimum = dActualMinimum;
    }
    if(pActualMaximum != NULL)
    {
        *pActualMaximum = dActualMaximum;
    }
    return true;
}

bool readStaticArrayValues(QFile& oFile,
                           quint64 nValueCount,
                           QVector<double>* pValues)
{
    quint64 nBytes = 0;
    if(!safeMultiply(nValueCount, sizeof(double), nBytes))
    {
        return false;
    }
    if(pValues != NULL)
    {
        pValues->resize(static_cast<int>(nValueCount));
        if(nBytes > 0 && !readAll(oFile,
                reinterpret_cast<char*>(pValues->data()), nBytes))
        {
            return false;
        }
        for(int nIndex = 0; nIndex < pValues->size(); ++nIndex)
        {
            if(!isFiniteValue((*pValues)[nIndex]))
            {
                return false;
            }
        }
        return true;
    }

    double aBuffer[1024];
    quint64 nRemaining = nValueCount;
    while(nRemaining > 0)
    {
        const quint64 nChunkValues = qMin(
                static_cast<quint64>(1024), nRemaining);
        const quint64 nChunkBytes = nChunkValues * sizeof(double);
        if(!readAll(oFile, reinterpret_cast<char*>(aBuffer), nChunkBytes))
        {
            return false;
        }
        for(quint64 nIndex = 0; nIndex < nChunkValues; ++nIndex)
        {
            if(!isFiniteValue(aBuffer[nIndex]))
            {
                return false;
            }
        }
        nRemaining -= nChunkValues;
    }
    return true;
}

bool readStaticProperties(
        const QString& sFilePath,
        quint64 nExpectedOriginalCellCount,
        nmPebiStaticPropertyValues* pValues,
        QString* pError)
{
    if(pValues != NULL)
    {
        pValues->clear();
    }
    const QFileInfo oInfo(sFilePath);
    if(!oInfo.isFile() || oInfo.size() <= 0 ||
       static_cast<quint64>(oInfo.size()) >
            nmNumericalResultPersistence::maximumBinaryPayloadBytes())
    {
        return setError(pError,
                "PEBI static property payload is missing or too large.");
    }
    QFile oFile(sFilePath);
    if(!oFile.open(QIODevice::ReadOnly))
    {
        return setError(pError,
                "Cannot open PEBI static property file.");
    }

    char aMagic[8] = { 0 };
    quint32 nVersion = 0;
    quint32 nEndian = 0;
    quint64 nOriginalCellCount = 0;
    quint32 nPropertyCount = 0;
    if(!readAll(oFile, aMagic, 8) ||
       !hasMagic(aMagic, g_aStaticMagic) ||
       !readPod(oFile, nVersion) || nVersion != g_nBinaryFormatVersion ||
       !readPod(oFile, nEndian) || nEndian != g_nEndianMarker ||
       !readPod(oFile, nOriginalCellCount) ||
       nOriginalCellCount == 0 ||
       nOriginalCellCount > g_nMaximumCellCount ||
       nOriginalCellCount > static_cast<quint64>(INT_MAX) ||
       nOriginalCellCount != nExpectedOriginalCellCount ||
       !readPod(oFile, nPropertyCount) ||
       nPropertyCount != g_nStaticPropertyCount)
    {
        return setError(pError,
                "PEBI static property header is invalid.");
    }

    nmPebiStaticPropertyValues oLoadedValues;
    QSet<QString> setPropertyIds;
    for(quint32 nPropertyIndex = 0;
        nPropertyIndex < nPropertyCount; ++nPropertyIndex)
    {
        quint32 nPropertyIdBytes = 0;
        if(!readPod(oFile, nPropertyIdBytes) || nPropertyIdBytes == 0 ||
           nPropertyIdBytes > g_nMaximumPropertyIdBytes)
        {
            return setError(pError,
                    "PEBI static property ID is invalid.");
        }
        QByteArray baPropertyId;
        baPropertyId.resize(static_cast<int>(nPropertyIdBytes));
        if(!readAll(oFile, baPropertyId.data(), nPropertyIdBytes))
        {
            return setError(pError,
                    "PEBI static property ID is incomplete.");
        }
        const QString sPropertyId = QString::fromLatin1(
                baPropertyId.constData(), baPropertyId.size());
        quint64 nElementCount = 0;
        if(setPropertyIds.contains(sPropertyId) ||
           !readPod(oFile, nElementCount) ||
           nElementCount != nOriginalCellCount)
        {
            return setError(pError,
                    "PEBI static property dimensions are invalid.");
        }

        QVector<double>* pTargetValues = NULL;
        if(sPropertyId == QString::fromLatin1("permeability"))
        {
            pTargetValues = pValues == NULL ? NULL :
                    &oLoadedValues.m_vecPermeabilityMilliDarcy;
        }
        else if(sPropertyId == QString::fromLatin1("porosity"))
        {
            pTargetValues = pValues == NULL ? NULL :
                    &oLoadedValues.m_vecPorosity;
        }
        else if(sPropertyId == QString::fromLatin1("thickness"))
        {
            pTargetValues = pValues == NULL ? NULL :
                    &oLoadedValues.m_vecThicknessMeters;
        }
        else
        {
            return setError(pError,
                    "PEBI static property file contains an unknown ID.");
        }
        quint64 nValueBytes = 0;
        quint64 nValueEnd = 0;
        if(!safeMultiply(nElementCount, sizeof(double), nValueBytes) ||
           oFile.pos() < 0 ||
           !safeAdd(static_cast<quint64>(oFile.pos()),
                    nValueBytes, nValueEnd) ||
           nValueEnd > static_cast<quint64>(oInfo.size()) ||
           !readStaticArrayValues(oFile, nElementCount, pTargetValues))
        {
            return setError(pError,
                    "PEBI static property values are invalid.");
        }
        setPropertyIds.insert(sPropertyId);
    }

    if(setPropertyIds.size() != static_cast<int>(g_nStaticPropertyCount) ||
       !setPropertyIds.contains(QString::fromLatin1("permeability")) ||
       !setPropertyIds.contains(QString::fromLatin1("porosity")) ||
       !setPropertyIds.contains(QString::fromLatin1("thickness")) ||
       oFile.pos() != oInfo.size() ||
       (pValues != NULL && !oLoadedValues.isValidForCellCount(
            static_cast<int>(nOriginalCellCount))))
    {
        return setError(pError,
                "PEBI static property payload is inconsistent.");
    }
    if(pValues != NULL)
    {
        qSwap(pValues->m_vecPermeabilityMilliDarcy,
              oLoadedValues.m_vecPermeabilityMilliDarcy);
        qSwap(pValues->m_vecPorosity, oLoadedValues.m_vecPorosity);
        qSwap(pValues->m_vecThicknessMeters,
              oLoadedValues.m_vecThicknessMeters);
    }
    return true;
}

bool writeStaticPropertyArray(QFile& oFile,
                              const char* pPropertyId,
                              const QVector<double>& vecValues,
                              quint64 nExpectedCount)
{
    if(pPropertyId == NULL ||
       static_cast<quint64>(vecValues.size()) != nExpectedCount)
    {
        return false;
    }
    const QByteArray baPropertyId(pPropertyId);
    const quint32 nPropertyIdBytes =
            static_cast<quint32>(baPropertyId.size());
    quint64 nValueBytes = 0;
    if(nPropertyIdBytes == 0 ||
       nPropertyIdBytes > g_nMaximumPropertyIdBytes ||
       !safeMultiply(nExpectedCount, sizeof(double), nValueBytes))
    {
        return false;
    }
    for(int nIndex = 0; nIndex < vecValues.size(); ++nIndex)
    {
        if(!isFiniteValue(vecValues[nIndex]))
        {
            return false;
        }
    }
    return writePod(oFile, nPropertyIdBytes) &&
            writeAll(oFile, baPropertyId.constData(), nPropertyIdBytes) &&
            writePod(oFile, nExpectedCount) &&
            writeAll(oFile,
                reinterpret_cast<const char*>(vecValues.constData()),
                nValueBytes);
}

bool readWellCurves(const QString& sFilePath,
                    quint32 nExpectedWellCount,
                    QMap<QString, nmPebiResultWellCurves>* pCurves,
                    QSet<QString>* pWellIds,
                    QString* pError)
{
    if(pWellIds != NULL)
    {
        pWellIds->clear();
    }
    const QFileInfo oInfo(sFilePath);
    if(!oInfo.isFile() || oInfo.size() < 0 ||
       static_cast<quint64>(oInfo.size()) >
            nmNumericalResultPersistence::maximumBinaryPayloadBytes())
    {
        return setError(pError, "PEBI well curve payload is missing or too large.");
    }
    QFile oFile(sFilePath);
    if(!oFile.open(QIODevice::ReadOnly))
    {
        return setError(pError, "Cannot open PEBI well curve file.");
    }
    char aMagic[8] = { 0 };
    quint32 nVersion = 0;
    quint32 nEndian = 0;
    quint32 nWellCount = 0;
    QMap<QString, nmPebiResultWellCurves> mapLoaded;
    QSet<QString> setWellIds;
    quint64 nTotalPoints = 0;
    bool bOk = readAll(oFile, aMagic, 8) &&
            hasMagic(aMagic, g_aCurvesMagic) &&
            readPod(oFile, nVersion) && nVersion == g_nBinaryFormatVersion &&
            readPod(oFile, nEndian) && nEndian == g_nEndianMarker &&
            readPod(oFile, nWellCount) && nWellCount <= g_nMaximumWellCount &&
            nWellCount == nExpectedWellCount;
    for(quint32 nWell = 0; bOk && nWell < nWellCount; ++nWell)
    {
        quint32 nUuidBytes = 0;
        bOk = readPod(oFile, nUuidBytes) && nUuidBytes > 0 &&
                nUuidBytes <= g_nMaximumUuidBytes &&
                nUuidBytes <= static_cast<quint32>(oFile.bytesAvailable());
        QByteArray baUuid;
        if(bOk)
        {
            baUuid.resize(static_cast<int>(nUuidBytes));
            bOk = readAll(oFile, baUuid.data(), nUuidBytes);
        }
        const QString sUuid = QString::fromUtf8(
                baUuid.constData(), baUuid.size());
        bOk = bOk && !sUuid.isEmpty() && !QUuid(sUuid).isNull() &&
                !setWellIds.contains(sUuid);
        nmPebiResultWellCurves oCurves;
        bOk = bOk && readCurve(oFile,
                    pCurves == NULL ? NULL : &oCurves.m_vecHistoryPressure,
                    nTotalPoints) &&
                readCurve(oFile,
                    pCurves == NULL ? NULL : &oCurves.m_vecHistoryLogLog,
                    nTotalPoints) &&
                readCurve(oFile,
                    pCurves == NULL ? NULL : &oCurves.m_vecHistorySemiLog,
                    nTotalPoints) &&
                readCurve(oFile,
                    pCurves == NULL ? NULL : &oCurves.m_vecResultPressure,
                    nTotalPoints) &&
                readCurve(oFile,
                    pCurves == NULL ? NULL : &oCurves.m_vecResultLogLog,
                    nTotalPoints) &&
                readCurve(oFile,
                    pCurves == NULL ? NULL : &oCurves.m_vecResultSemiLog,
                    nTotalPoints);
        if(bOk)
        {
            setWellIds.insert(sUuid);
            if(pCurves != NULL)
            {
                mapLoaded.insert(sUuid, oCurves);
            }
        }
    }
    bOk = bOk && oFile.atEnd() && setWellIds.size() == nExpectedWellCount;
    oFile.close();
    if(!bOk)
    {
        return setError(pError, "PEBI well curve file is damaged.");
    }
    if(pCurves != NULL)
    {
        pCurves->swap(mapLoaded);
    }
    if(pWellIds != NULL)
    {
        *pWellIds = setWellIds;
    }
    return true;
}

bool readRequiredInt(const rapidjson::Value& oParent,
                     const char* pName,
                     int& nValue)
{
    if(!oParent.IsObject() || !oParent.HasMember(pName) ||
       !oParent[pName].IsInt())
    {
        return false;
    }
    nValue = oParent[pName].GetInt();
    return true;
}

bool readRequiredDouble(const rapidjson::Value& oParent,
                        const char* pName,
                        double& dValue)
{
    if(!oParent.IsObject() || !oParent.HasMember(pName) ||
       !oParent[pName].IsNumber() ||
       !isFiniteValue(oParent[pName].GetDouble()))
    {
        return false;
    }
    dValue = oParent[pName].GetDouble();
    return true;
}

bool readRequiredBool(const rapidjson::Value& oParent,
                      const char* pName,
                      bool& bValue)
{
    if(!oParent.IsObject() || !oParent.HasMember(pName) ||
       !oParent[pName].IsBool())
    {
        return false;
    }
    bValue = oParent[pName].GetBool();
    return true;
}

bool readJsonWellIds(const rapidjson::Document& oDocument,
                     quint32 nExpectedWellCount,
                     QSet<QString>& setWellIds)
{
    setWellIds.clear();
    if(!oDocument.IsObject() || !oDocument.HasMember("Wells") ||
       !oDocument["Wells"].IsArray() ||
       oDocument["Wells"].Size() != nExpectedWellCount)
    {
        return false;
    }

    QSet<QString> setLoaded;
    const rapidjson::Value& oWells = oDocument["Wells"];
    for(rapidjson::SizeType nIndex = 0; nIndex < oWells.Size(); ++nIndex)
    {
        const rapidjson::Value& oWell = oWells[nIndex];
        if(!oWell.IsObject() || !oWell.HasMember("WellInstanceId") ||
           !oWell["WellInstanceId"].IsString())
        {
            return false;
        }
        const rapidjson::Value& oId = oWell["WellInstanceId"];
        const QString sWellId = QString::fromUtf8(
                oId.GetString(), static_cast<int>(oId.GetStringLength()));
        if(sWellId.isEmpty() || QUuid(sWellId).isNull() ||
           setLoaded.contains(sWellId))
        {
            return false;
        }
        setLoaded.insert(sWellId);
    }
    setWellIds = setLoaded;
    return true;
}

bool parseSnapshotJson(
        const QString& sSnapshotJsonPath,
        rapidjson::Document& oDocument,
        nmNumericalFileReference& oGridReference,
        nmNumericalFileReference& oStaticReference,
        nmNumericalFileReference& oPressureReference,
        nmNumericalFileReference& oCurvesReference,
        quint64& nCellCount,
        quint64& nOriginalCellCount,
        quint32& nFrameCount,
        quint32& nWellCount,
        QString* pError)
{
    const QFileInfo oInfo(sSnapshotJsonPath);
    if(!oInfo.isFile() || oInfo.size() <= 0 ||
       static_cast<quint64>(oInfo.size()) > g_nMaximumSnapshotJsonBytes ||
       !nmDataJsonTools::ReadDomFromFile(sSnapshotJsonPath, oDocument))
    {
        return setError(pError, "Snapshot.json is missing, too large or invalid.");
    }
    if(!oDocument.IsObject() ||
       !oDocument.HasMember("SnapshotFormatVersion") ||
       !oDocument["SnapshotFormatVersion"].IsInt())
    {
        return setError(pError,
                "Snapshot.json format version is missing or invalid.");
    }
    const int nSnapshotVersion =
            oDocument["SnapshotFormatVersion"].GetInt();
    if(nSnapshotVersion != g_nSnapshotFormatVersion)
    {
        return setError(pError, QString::fromLatin1(
                "Unsupported snapshot format version %1.")
                .arg(nSnapshotVersion));
    }
    if(!oDocument.HasMember("OriginalCellCount") ||
       !oDocument["OriginalCellCount"].IsUint64() ||
       !oDocument.HasMember("ResultCellCount") ||
       !oDocument["ResultCellCount"].IsUint64() ||
       !oDocument.HasMember("PressureFrameCount") ||
       !oDocument["PressureFrameCount"].IsUint() ||
       !oDocument.HasMember("WellCount") ||
       !oDocument["WellCount"].IsUint() ||
       !readFileReference(oDocument, "ResultGrid", oGridReference) ||
       !readFileReference(oDocument, "StaticProperties", oStaticReference) ||
       !readFileReference(oDocument, "PressureFrames", oPressureReference) ||
       !readFileReference(oDocument, "WellCurves", oCurvesReference))
    {
        return setError(pError, "Snapshot.json header or file references are invalid.");
    }
    if(!validatePropertyCatalog(oDocument, pError))
    {
        return false;
    }
    nCellCount = oDocument["ResultCellCount"].GetUint64();
    nOriginalCellCount = oDocument["OriginalCellCount"].GetUint64();
    nFrameCount = oDocument["PressureFrameCount"].GetUint();
    nWellCount = oDocument["WellCount"].GetUint();
    if(nCellCount == 0 || nCellCount > g_nMaximumCellCount ||
       nOriginalCellCount == 0 ||
       nOriginalCellCount > g_nMaximumCellCount ||
       nOriginalCellCount > static_cast<quint64>(INT_MAX) ||
       nOriginalCellCount < nCellCount ||
       nFrameCount == 0 || nFrameCount > g_nMaximumFrameCount ||
       nWellCount > g_nMaximumWellCount)
    {
        return setError(pError, "Snapshot.json declares invalid or duplicate payloads.");
    }
    QSet<QString> setPayloadPaths;
    setPayloadPaths.insert(oGridReference.m_sRelativePath.toLower());
    setPayloadPaths.insert(oStaticReference.m_sRelativePath.toLower());
    setPayloadPaths.insert(oPressureReference.m_sRelativePath.toLower());
    setPayloadPaths.insert(oCurvesReference.m_sRelativePath.toLower());
    if(setPayloadPaths.size() != 4)
    {
        return setError(pError,
                "Snapshot.json declares invalid or duplicate payloads.");
    }
    return true;
}

}

bool nmPebiResultSnapshotSerializer::writeStaticProperties(
        const nmPebiResultSnapshot& oSnapshot,
        const QString& sFilePath,
        QString* pError)
{
    const int nOriginalCellCount =
            oSnapshot.m_oStaticProperties.m_vecPermeabilityMilliDarcy.size();
    if(nOriginalCellCount <= 0 ||
       nOriginalCellCount > static_cast<int>(g_nMaximumCellCount) ||
       !oSnapshot.m_oStaticProperties.isValidForCellCount(
            nOriginalCellCount))
    {
        return setError(pError,
                "Cannot save invalid PEBI static properties.");
    }

    const char* aPropertyIds[3] = {
        "permeability", "porosity", "thickness"
    };
    quint64 nValueBytes = 0;
    quint64 nExpectedBytes = 8 + sizeof(quint32) + sizeof(quint32) +
            sizeof(quint64) + sizeof(quint32);
    if(!safeMultiply(static_cast<quint64>(nOriginalCellCount),
                     sizeof(double), nValueBytes))
    {
        return setError(pError,
                "PEBI static property payload size overflows.");
    }
    for(int nIndex = 0; nIndex < 3; ++nIndex)
    {
        quint64 nArrayBytes = 0;
        quint64 nNextBytes = 0;
        const quint64 nIdBytes = static_cast<quint64>(
                QByteArray(aPropertyIds[nIndex]).size());
        if(!safeAdd(sizeof(quint32), nIdBytes, nArrayBytes) ||
           !safeAdd(nArrayBytes, sizeof(quint64), nArrayBytes) ||
           !safeAdd(nArrayBytes, nValueBytes, nArrayBytes) ||
           !safeAdd(nExpectedBytes, nArrayBytes, nNextBytes))
        {
            return setError(pError,
                    "PEBI static property payload size overflows.");
        }
        nExpectedBytes = nNextBytes;
    }
    if(nExpectedBytes >
       nmNumericalResultPersistence::maximumBinaryPayloadBytes())
    {
        return setError(pError,
                "PEBI static property payload is too large.");
    }

    QFile oFile(sFilePath);
    if(!oFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        return setError(pError,
                "Cannot create PEBI static property file.");
    }
    const quint64 nCount = static_cast<quint64>(nOriginalCellCount);
    bool bOk = writeAll(oFile, g_aStaticMagic, 8) &&
            writePod(oFile, g_nBinaryFormatVersion) &&
            writePod(oFile, g_nEndianMarker) &&
            writePod(oFile, nCount) &&
            writePod(oFile, g_nStaticPropertyCount) &&
            writeStaticPropertyArray(oFile, aPropertyIds[0],
                oSnapshot.m_oStaticProperties.
                    m_vecPermeabilityMilliDarcy, nCount) &&
            writeStaticPropertyArray(oFile, aPropertyIds[1],
                oSnapshot.m_oStaticProperties.m_vecPorosity, nCount) &&
            writeStaticPropertyArray(oFile, aPropertyIds[2],
                oSnapshot.m_oStaticProperties.m_vecThicknessMeters, nCount) &&
            oFile.flush() &&
            static_cast<quint64>(oFile.size()) == nExpectedBytes;
    oFile.close();
    if(!bOk)
    {
        QFile::remove(sFilePath);
        return setError(pError,
                "Cannot write complete PEBI static property file.");
    }
    return true;
}

bool nmPebiResultSnapshotSerializer::writePressureFrames(
        const nmPebiResultSnapshot& oSnapshot,
        const QString& sFilePath,
        QString* pError)
{
    QFile oFile(sFilePath);
    if(!oFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        return setError(pError, "Cannot create PEBI pressure frame file.");
    }
    const quint64 nCellCount = static_cast<quint64>(
            oSnapshot.m_pResultGrid->GetNumberOfCells());
    const quint32 nFrameCount = static_cast<quint32>(
            oSnapshot.m_vecPressureFrames.size());
    bool bOk = writeAll(oFile, g_aPressureMagic, 8) &&
            writePod(oFile, g_nBinaryFormatVersion) &&
            writePod(oFile, g_nEndianMarker) &&
            writePod(oFile, nCellCount) && writePod(oFile, nFrameCount);
    quint64 nFrameBytes = 0;
    bOk = bOk && safeMultiply(nCellCount, sizeof(double), nFrameBytes);
    for(int nIndex = 0; bOk && nIndex < oSnapshot.m_vecPressureFrames.size();
        ++nIndex)
    {
        const nmPebiResultSnapshot::PressureFrame& oFrame =
                oSnapshot.m_vecPressureFrames[nIndex];
        double* pValues = oFrame.m_pPressure == NULL ? NULL :
                oFrame.m_pPressure->GetPointer(0);
        bOk = pValues != NULL && writePod(oFile, oFrame.m_dTime) &&
                writeAll(oFile, reinterpret_cast<const char*>(pValues),
                         nFrameBytes);
    }
    bOk = bOk && oFile.flush();
    oFile.close();
    if(!bOk)
    {
        QFile::remove(sFilePath);
        return setError(pError, "Cannot write complete PEBI pressure frame file.");
    }
    return true;
}

bool nmPebiResultSnapshotSerializer::writeWellCurves(
        const nmPebiResultSnapshot& oSnapshot,
        const QString& sFilePath,
        QString* pError)
{
    QFile oFile(sFilePath);
    if(!oFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
    {
        return setError(pError, "Cannot create PEBI well curve file.");
    }
    const quint32 nWellCount = static_cast<quint32>(oSnapshot.m_vecWells.size());
    bool bOk = writeAll(oFile, g_aCurvesMagic, 8) &&
            writePod(oFile, g_nBinaryFormatVersion) &&
            writePod(oFile, g_nEndianMarker) && writePod(oFile, nWellCount);
    for(int nIndex = 0; bOk && nIndex < oSnapshot.m_vecWells.size(); ++nIndex)
    {
        const nmPebiResultWellSnapshot& oWell = oSnapshot.m_vecWells[nIndex];
        const QByteArray baUuid = oWell.m_sWellInstanceId.toUtf8();
        const quint32 nUuidBytes = static_cast<quint32>(baUuid.size());
        bOk = nUuidBytes > 0 && nUuidBytes <= g_nMaximumUuidBytes &&
                writePod(oFile, nUuidBytes) &&
                writeAll(oFile, baUuid.constData(), nUuidBytes) &&
                writeCurve(oFile, oWell.m_oCurves.m_vecHistoryPressure) &&
                writeCurve(oFile, oWell.m_oCurves.m_vecHistoryLogLog) &&
                writeCurve(oFile, oWell.m_oCurves.m_vecHistorySemiLog) &&
                writeCurve(oFile, oWell.m_oCurves.m_vecResultPressure) &&
                writeCurve(oFile, oWell.m_oCurves.m_vecResultLogLog) &&
                writeCurve(oFile, oWell.m_oCurves.m_vecResultSemiLog);
    }
    bOk = bOk && oFile.flush();
    oFile.close();
    if(!bOk)
    {
        QFile::remove(sFilePath);
        return setError(pError, "Cannot write complete PEBI well curve file.");
    }
    return true;
}

bool nmPebiResultSnapshotSerializer::save(
        const QSharedPointer<const nmPebiResultSnapshot>& pSnapshot,
        const QString& sWindowDirectory,
        nmNumericalFileReference& oSnapshotJsonReference,
        QString* pError)
{
    if(pError != NULL)
    {
        pError->clear();
    }
    if(pSnapshot.isNull() || !pSnapshot->m_bComplete ||
       pSnapshot->m_pResultGrid == NULL)
    {
        return setError(pError, "Cannot save an incomplete PEBI result snapshot.");
    }

    try
    {
        const QString sSnapshotDirectory = QDir(sWindowDirectory).filePath("Snapshot");
        if(!QDir().mkpath(sSnapshotDirectory))
        {
            return setError(pError, "Cannot create PEBI snapshot directory.");
        }
        const QString sGridPath = QDir(sWindowDirectory).filePath(
                "Snapshot/ResultGrid.vtu");
        const QString sStaticPath = QDir(sWindowDirectory).filePath(
                "Snapshot/StaticProperties.bin");
        const QString sPressurePath = QDir(sWindowDirectory).filePath(
                "Snapshot/PressureFrames.bin");
        const QString sCurvesPath = QDir(sWindowDirectory).filePath(
                "Snapshot/WellCurves.bin");
        const QString sJsonPath = QDir(sWindowDirectory).filePath(
                "Snapshot/Snapshot.json");

        nmNumericalFileReference oGridReference;
        nmNumericalFileReference oStaticReference;
        nmNumericalFileReference oPressureReference;
        nmNumericalFileReference oCurvesReference;
        if(!nmNumericalResultPersistence::writeGrid(
                    pSnapshot->m_pResultGrid, sGridPath, pError) ||
           !nmNumericalResultPersistence::buildFileReference(
                    sGridPath, "Snapshot/ResultGrid.vtu", oGridReference) ||
           !writeStaticProperties(*pSnapshot, sStaticPath, pError) ||
           !nmNumericalResultPersistence::buildFileReference(
                    sStaticPath, "Snapshot/StaticProperties.bin",
                    oStaticReference) ||
           !writePressureFrames(*pSnapshot, sPressurePath, pError) ||
           !nmNumericalResultPersistence::buildFileReference(
                    sPressurePath, "Snapshot/PressureFrames.bin",
                    oPressureReference) ||
           !writeWellCurves(*pSnapshot, sCurvesPath, pError) ||
           !nmNumericalResultPersistence::buildFileReference(
                    sCurvesPath, "Snapshot/WellCurves.bin", oCurvesReference))
        {
            return false;
        }

        rapidjson::Document oDocument;
        oDocument.SetObject();
        rapidjson::Document::AllocatorType& oAllocator =
                oDocument.GetAllocator();
        // V5 冻结原始单元顺序的静态属性及稳定属性目录，不兼容旧快照。
        oDocument.AddMember("SnapshotFormatVersion",
                g_nSnapshotFormatVersion, oAllocator);
        oDocument.AddMember("SnapshotId",
                toJsonString(pSnapshot->m_sSnapshotId, oAllocator), oAllocator);
        oDocument.AddMember("GridInputRevision",
                pSnapshot->m_nGridInputRevision, oAllocator);
        oDocument.AddMember("ResultInputRevision",
                pSnapshot->m_nResultInputRevision, oAllocator);
        oDocument.AddMember("ResultCellCount",
                static_cast<quint64>(pSnapshot->m_pResultGrid->GetNumberOfCells()),
                oAllocator);
        oDocument.AddMember("OriginalCellCount", static_cast<quint64>(
                pSnapshot->m_oStaticProperties.
                    m_vecPermeabilityMilliDarcy.size()), oAllocator);
        oDocument.AddMember("PressureFrameCount",
                static_cast<unsigned>(pSnapshot->m_vecPressureFrames.size()),
                oAllocator);
        oDocument.AddMember("WellCount",
                static_cast<unsigned>(pSnapshot->m_vecWells.size()), oAllocator);
        oDocument.AddMember("ScalarMinimum", pSnapshot->m_dScalarMin, oAllocator);
        oDocument.AddMember("ScalarMaximum", pSnapshot->m_dScalarMax, oAllocator);
        addFileReference(oDocument, "ResultGrid", oGridReference, oAllocator);
        addFileReference(oDocument, "StaticProperties",
                         oStaticReference, oAllocator);
        addFileReference(oDocument, "PressureFrames", oPressureReference, oAllocator);
        addFileReference(oDocument, "WellCurves", oCurvesReference, oAllocator);
        addPropertyCatalog(oDocument, oAllocator);

        rapidjson::Value oSlots(rapidjson::kArrayType);
        for(int nIndex = 0; nIndex < pSnapshot->m_vecSolverSlots.size(); ++nIndex)
        {
            const nmPebiResultSolverSlot& oSlot =
                    pSnapshot->m_vecSolverSlots[nIndex];
            rapidjson::Value oJson(rapidjson::kObjectType);
            oJson.AddMember("SolverIndex", oSlot.m_nSolverIndex, oAllocator);
            oJson.AddMember("EntryKind", static_cast<int>(oSlot.m_eEntryKind), oAllocator);
            oJson.AddMember("WellInstanceId",
                    toJsonString(oSlot.m_sWellInstanceId, oAllocator), oAllocator);
            oJson.AddMember("WellCode",
                    toJsonString(oSlot.m_sWellCode, oAllocator), oAllocator);
            oJson.AddMember("WellType", static_cast<int>(oSlot.m_eWellType), oAllocator);
            oJson.AddMember("WellCategory", static_cast<int>(
                    oSlot.m_eWellCategory), oAllocator);
            oSlots.PushBack(oJson, oAllocator);
        }
        oDocument.AddMember("SolverSlots", oSlots, oAllocator);

        rapidjson::Value oWells(rapidjson::kArrayType);
        for(int nIndex = 0; nIndex < pSnapshot->m_vecWells.size(); ++nIndex)
        {
            const nmPebiResultWellSnapshot& oWell = pSnapshot->m_vecWells[nIndex];
            rapidjson::Value oJson(rapidjson::kObjectType);
            oJson.AddMember("WellInstanceId", toJsonString(
                    oWell.m_sWellInstanceId, oAllocator), oAllocator);
            oJson.AddMember("WellCode", toJsonString(
                    oWell.m_sWellCode, oAllocator), oAllocator);
            oJson.AddMember("WellName", toJsonString(
                    oWell.m_sWellName, oAllocator), oAllocator);
            oJson.AddMember("WellType", static_cast<int>(oWell.m_eWellType), oAllocator);
            oJson.AddMember("WellCategory", static_cast<int>(
                    oWell.m_eWellCategory), oAllocator);
            oJson.AddMember("WellMode", static_cast<int>(oWell.m_eWellMode), oAllocator);
            oJson.AddMember("GaugeInputSha1", toJsonString(
                    oWell.m_sGaugeInputSha1, oAllocator), oAllocator);
            oJson.AddMember("FlowSchedulePhase", static_cast<int>(
                    oWell.m_eFlowSchedulePhase), oAllocator);
            oJson.AddMember("FlowSectionIndex",
                    oWell.m_nFlowSectionIndex, oAllocator);
            oJson.AddMember("UseOilRate", oWell.m_bUseOilRate, oAllocator);
            oJson.AddMember("UseGasRate", oWell.m_bUseGasRate, oAllocator);
            oJson.AddMember("UseWaterRate", oWell.m_bUseWaterRate, oAllocator);
            addDoubleVector(oJson, "FlowDurations",
                    oWell.m_vecFlowDurations, oAllocator);
            addDoubleVector(oJson, "OilRates",
                    oWell.m_vecOilRates, oAllocator);
            addDoubleVector(oJson, "GasRates",
                    oWell.m_vecGasRates, oAllocator);
            addDoubleVector(oJson, "WaterRates",
                    oWell.m_vecWaterRates, oAllocator);
            oJson.AddMember("X", oWell.m_oLocation.x(), oAllocator);
            oJson.AddMember("Y", oWell.m_oLocation.y(), oAllocator);
            oJson.AddMember("HasPerforation", oWell.m_bHasPerforation, oAllocator);
            oJson.AddMember("HasSkin", oWell.m_bHasSkin, oAllocator);
            oJson.AddMember("HasDfc", oWell.m_bHasDfc, oAllocator);
            oJson.AddMember("Radius", oWell.m_dRadius, oAllocator);
            oJson.AddMember("WellboreStorage", oWell.m_dWellboreStorage, oAllocator);
            oJson.AddMember("Skin", oWell.m_dSkin, oAllocator);
            oJson.AddMember("Dfc", oWell.m_dDfc, oAllocator);
            oWells.PushBack(oJson, oAllocator);
        }
        oDocument.AddMember("Wells", oWells, oAllocator);

        rapidjson::Value oDisplayWells(rapidjson::kArrayType);
        for(int nIndex = 0;
            nIndex < pSnapshot->m_listDisplayWellInstanceIds.size(); ++nIndex)
        {
            oDisplayWells.PushBack(toJsonString(
                    pSnapshot->m_listDisplayWellInstanceIds[nIndex], oAllocator),
                    oAllocator);
        }
        oDocument.AddMember("DisplayWellInstanceIds", oDisplayWells, oAllocator);

        const nmPebiResultReservoirParameters& oReservoir =
                pSnapshot->m_oReservoirParameters;
        rapidjson::Value oReservoirJson(rapidjson::kObjectType);
        oReservoirJson.AddMember("Pi", oReservoir.m_dInitialPressure, oAllocator);
        oReservoirJson.AddMember("K", oReservoir.m_dPermeability, oAllocator);
        oReservoirJson.AddMember("h", oReservoir.m_dThickness, oAllocator);
        oReservoirJson.AddMember("phi", oReservoir.m_dPorosity, oAllocator);
        oReservoirJson.AddMember("Cti", oReservoir.m_dTotalCompressibility, oAllocator);
        oReservoirJson.AddMember("Cf", oReservoir.m_dRockCompressibility, oAllocator);
        oReservoirJson.AddMember("Soi", oReservoir.m_dOilSaturation, oAllocator);
        oReservoirJson.AddMember("Sgi", oReservoir.m_dGasSaturation, oAllocator);
        oReservoirJson.AddMember("Swi", oReservoir.m_dWaterSaturation, oAllocator);
        oDocument.AddMember("Reservoir", oReservoirJson, oAllocator);

        const nmPebiResultPvtParameters& oPvt = pSnapshot->m_oPvtParameters;
        rapidjson::Value oPvtJson(rapidjson::kObjectType);
        oPvtJson.AddMember("HasBubblePoint", oPvt.m_bHasBubblePoint, oAllocator);
        oPvtJson.AddMember("BubblePoint", oPvt.m_dBubblePoint, oAllocator);
        oPvtJson.AddMember("ConstantBo", oPvt.m_dConstantBo, oAllocator);
        oPvtJson.AddMember("ConstantMiuo", oPvt.m_dConstantMiuo, oAllocator);
        oPvtJson.AddMember("ConstantBg", oPvt.m_dConstantBg, oAllocator);
        oPvtJson.AddMember("ConstantMiug", oPvt.m_dConstantMiug, oAllocator);
        oPvtJson.AddMember("ConstantBw", oPvt.m_dConstantBw, oAllocator);
        oPvtJson.AddMember("ConstantMiuw", oPvt.m_dConstantMiuw, oAllocator);
#define NM_ADD_PVT_VECTOR(Name) addDoubleVector(oPvtJson, #Name, oPvt.m_vec##Name, oAllocator)
        NM_ADD_PVT_VECTOR(Pressure); NM_ADD_PVT_VECTOR(Rso);
        NM_ADD_PVT_VECTOR(Bo); NM_ADD_PVT_VECTOR(Co);
        NM_ADD_PVT_VECTOR(Miuo); NM_ADD_PVT_VECTOR(Rouo);
        NM_ADD_PVT_VECTOR(Rv); NM_ADD_PVT_VECTOR(Bg);
        NM_ADD_PVT_VECTOR(Cg); NM_ADD_PVT_VECTOR(Miug);
        NM_ADD_PVT_VECTOR(Roug); NM_ADD_PVT_VECTOR(Z);
        NM_ADD_PVT_VECTOR(Rsw); NM_ADD_PVT_VECTOR(Bw);
        NM_ADD_PVT_VECTOR(Cw); NM_ADD_PVT_VECTOR(Miuw);
        NM_ADD_PVT_VECTOR(Rouw); NM_ADD_PVT_VECTOR(V);
        NM_ADD_PVT_VECTOR(KkInitial); NM_ADD_PVT_VECTOR(CfCfInitial);
        NM_ADD_PVT_VECTOR(So); NM_ADD_PVT_VECTOR(Kro);
        NM_ADD_PVT_VECTOR(Sg); NM_ADD_PVT_VECTOR(Krg);
        NM_ADD_PVT_VECTOR(Sw); NM_ADD_PVT_VECTOR(Krw);
#undef NM_ADD_PVT_VECTOR
        oDocument.AddMember("Pvt", oPvtJson, oAllocator);

        const nmPebiResultSolverSettings& oSettings =
                pSnapshot->m_oSolverSettings;
        rapidjson::Value oSettingsJson(rapidjson::kObjectType);
        oSettingsJson.AddMember("SolverModelType", oSettings.m_nSolverModelType, oAllocator);
        oSettingsJson.AddMember("PebiSolverType", oSettings.m_nPebiSolverType, oAllocator);
        oSettingsJson.AddMember("OmpThreads", oSettings.m_nOmpThreads, oAllocator);
        oSettingsJson.AddMember("IluReuseSteps", oSettings.m_nIluReuseSteps, oAllocator);
        oSettingsJson.AddMember("GridControl", oSettings.m_dGridControl, oAllocator);
        oSettingsJson.AddMember("HasTimeStepSettings", oSettings.m_bHasTimeStepSettings, oAllocator);
        oSettingsJson.AddMember("TimeGrowthExponent", oSettings.m_dTimeGrowthExponent, oAllocator);
        oSettingsJson.AddMember("MinDeltaT", oSettings.m_dMinDeltaT, oAllocator);
        oSettingsJson.AddMember("MaxDeltaT", oSettings.m_dMaxDeltaT, oAllocator);
        oDocument.AddMember("SolverSettings", oSettingsJson, oAllocator);

        if(!nmDataJsonTools::WriteDomToFile(oDocument, sJsonPath) ||
           !nmNumericalResultPersistence::buildFileReference(
                    sJsonPath, "Snapshot/Snapshot.json",
                    oSnapshotJsonReference) ||
           !validate(sWindowDirectory, oSnapshotJsonReference, pError))
        {
            return false;
        }
        return true;
    }
    catch(const std::bad_alloc&)
    {
        return setError(pError, "Not enough memory to save PEBI result snapshot.");
    }
}

bool nmPebiResultSnapshotSerializer::validate(
        const QString& sWindowDirectory,
        const nmNumericalFileReference& oSnapshotJsonReference,
        QString* pError)
{
    if(pError != NULL)
    {
        pError->clear();
    }
    QString sJsonPath;
    if(!nmNumericalResultPersistence::validateFileReference(
                sWindowDirectory, oSnapshotJsonReference,
                &sJsonPath, pError))
    {
        return false;
    }
    rapidjson::Document oDocument;
    nmNumericalFileReference oGridReference;
    nmNumericalFileReference oStaticReference;
    nmNumericalFileReference oPressureReference;
    nmNumericalFileReference oCurvesReference;
    quint64 nCellCount = 0;
    quint64 nOriginalCellCount = 0;
    quint32 nFrameCount = 0;
    quint32 nWellCount = 0;
    if(!parseSnapshotJson(sJsonPath, oDocument, oGridReference,
                oStaticReference, oPressureReference, oCurvesReference,
                nCellCount, nOriginalCellCount, nFrameCount,
                nWellCount, pError))
    {
        return false;
    }
    QSet<QString> setJsonWellIds;
    if(!readJsonWellIds(oDocument, nWellCount, setJsonWellIds))
    {
        return setError(pError,
                "PEBI snapshot well directory is invalid.");
    }

    QString sGridPath;
    QString sStaticPath;
    QString sPressurePath;
    QString sCurvesPath;
    QSet<QString> setCurveWellIds;
    double dActualPressureMinimum = 0.0;
    double dActualPressureMaximum = 0.0;
    if(!nmNumericalResultPersistence::validateFileReference(
                sWindowDirectory, oGridReference, &sGridPath, pError) ||
       !nmNumericalResultPersistence::validateFileReference(
                sWindowDirectory, oStaticReference, &sStaticPath, pError) ||
       !nmNumericalResultPersistence::validateFileReference(
                sWindowDirectory, oPressureReference, &sPressurePath, pError) ||
       !nmNumericalResultPersistence::validateFileReference(
                sWindowDirectory, oCurvesReference, &sCurvesPath, pError) ||
       !readStaticProperties(sStaticPath, nOriginalCellCount, NULL, pError) ||
       !readPressureFrames(sPressurePath, nCellCount, nFrameCount,
                           NULL, pError, &dActualPressureMinimum,
                           &dActualPressureMaximum) ||
       !readWellCurves(sCurvesPath, nWellCount, NULL,
                       &setCurveWellIds, pError))
    {
        return false;
    }
    if(setCurveWellIds != setJsonWellIds)
    {
        return setError(pError,
                "PEBI snapshot well curve mapping is inconsistent.");
    }
    double dDeclaredPressureMinimum = 0.0;
    double dDeclaredPressureMaximum = 0.0;
    const double dRangeScale = qMax(1.0, qMax(
            fabs(dActualPressureMinimum), fabs(dActualPressureMaximum)));
    const double dRangeTolerance = dRangeScale * 1.0e-10;
    if(!readRequiredDouble(oDocument, "ScalarMinimum",
                           dDeclaredPressureMinimum) ||
       !readRequiredDouble(oDocument, "ScalarMaximum",
                           dDeclaredPressureMaximum) ||
       fabs(dDeclaredPressureMinimum - dActualPressureMinimum) >
            dRangeTolerance ||
       fabs(dDeclaredPressureMaximum - dActualPressureMaximum) >
            dRangeTolerance)
    {
        return setError(pError,
                "PEBI snapshot pressure range is inconsistent.");
    }
    vtkSmartPointer<vtkUnstructuredGrid> pGrid;
    QVector<vtkIdType> vecVtkToOriginal;
    QVector<vtkIdType> vecOriginalToVtk;
    if(!nmNumericalResultPersistence::readGrid(sGridPath, pGrid, pError) ||
       pGrid == NULL ||
       static_cast<quint64>(pGrid->GetNumberOfCells()) != nCellCount ||
       nmPebiCellMapping::read(pGrid, &vecVtkToOriginal,
            &vecOriginalToVtk, pError) !=
                nmPebiCellMapping::MappingStatus_Valid ||
       static_cast<quint64>(vecOriginalToVtk.size()) !=
            nOriginalCellCount)
    {
        return setError(pError, pError != NULL && !pError->isEmpty()
                ? *pError : "PEBI snapshot grid mapping is invalid.");
    }
    return true;
}

bool nmPebiResultSnapshotSerializer::getPayloadRelativePaths(
        const QString& sWindowDirectory,
        const nmNumericalFileReference& oSnapshotJsonReference,
        QStringList& listRelativePaths,
        QString* pError)
{
    listRelativePaths.clear();
    QString sJsonPath;
    if(!nmNumericalResultPersistence::validateFileReference(
                sWindowDirectory, oSnapshotJsonReference, &sJsonPath, pError))
    {
        return false;
    }
    rapidjson::Document oDocument;
    nmNumericalFileReference oGridReference;
    nmNumericalFileReference oStaticReference;
    nmNumericalFileReference oPressureReference;
    nmNumericalFileReference oCurvesReference;
    quint64 nCellCount = 0;
    quint64 nOriginalCellCount = 0;
    quint32 nFrameCount = 0;
    quint32 nWellCount = 0;
    if(!parseSnapshotJson(sJsonPath, oDocument, oGridReference,
                oStaticReference, oPressureReference, oCurvesReference,
                nCellCount, nOriginalCellCount, nFrameCount,
                nWellCount, pError))
    {
        return false;
    }
    listRelativePaths << oGridReference.m_sRelativePath
                      << oStaticReference.m_sRelativePath
                      << oPressureReference.m_sRelativePath
                      << oCurvesReference.m_sRelativePath;
    return true;
}

bool nmPebiResultSnapshotSerializer::load(
        const QString& sWindowDirectory,
        const nmNumericalFileReference& oSnapshotJsonReference,
        QSharedPointer<nmPebiResultSnapshot>& pCandidate,
        QString* pError)
{
    pCandidate.clear();
    if(pError != NULL)
    {
        pError->clear();
    }
    try
    {
        QString sJsonPath;
        if(!nmNumericalResultPersistence::validateFileReference(
                    sWindowDirectory, oSnapshotJsonReference,
                    &sJsonPath, pError))
        {
            return false;
        }
        rapidjson::Document oDocument;
        nmNumericalFileReference oGridReference;
        nmNumericalFileReference oStaticReference;
        nmNumericalFileReference oPressureReference;
        nmNumericalFileReference oCurvesReference;
        quint64 nCellCount = 0;
        quint64 nOriginalCellCount = 0;
        quint32 nFrameCount = 0;
        quint32 nWellCount = 0;
        if(!parseSnapshotJson(sJsonPath, oDocument, oGridReference,
                    oStaticReference, oPressureReference, oCurvesReference,
                    nCellCount, nOriginalCellCount, nFrameCount,
                    nWellCount, pError))
        {
            return false;
        }
        QString sGridPath;
        QString sStaticPath;
        QString sPressurePath;
        QString sCurvesPath;
        if(!nmNumericalResultPersistence::validateFileReference(
                    sWindowDirectory, oGridReference, &sGridPath, pError) ||
           !nmNumericalResultPersistence::validateFileReference(
                    sWindowDirectory, oStaticReference,
                    &sStaticPath, pError) ||
           !nmNumericalResultPersistence::validateFileReference(
                    sWindowDirectory, oPressureReference, &sPressurePath, pError) ||
           !nmNumericalResultPersistence::validateFileReference(
                    sWindowDirectory, oCurvesReference, &sCurvesPath, pError))
        {
            return false;
        }

        vtkSmartPointer<vtkUnstructuredGrid> pGrid;
        QMap<QString, nmPebiResultWellCurves> mapCurves;
        nmPebiStaticPropertyValues oStaticProperties;
        QVector<vtkIdType> vecVtkToOriginal;
        QVector<vtkIdType> vecOriginalToVtk;
        if(!nmNumericalResultPersistence::readGrid(sGridPath, pGrid, pError) ||
           pGrid == NULL ||
           static_cast<quint64>(pGrid->GetNumberOfCells()) != nCellCount ||
           nmPebiCellMapping::read(pGrid, &vecVtkToOriginal,
                &vecOriginalToVtk, pError) !=
                    nmPebiCellMapping::MappingStatus_Valid ||
           static_cast<quint64>(vecOriginalToVtk.size()) !=
                nOriginalCellCount ||
           !readStaticProperties(sStaticPath, nOriginalCellCount,
                                 &oStaticProperties, pError) ||
           !readWellCurves(sCurvesPath, nWellCount, &mapCurves,
                           NULL, pError))
        {
            return setError(pError, pError != NULL && !pError->isEmpty()
                    ? *pError : "PEBI snapshot grid or curves are invalid.");
        }

        nmPebiResultSnapshotBuilder oBuilder;
        if(!oDocument.HasMember("SnapshotId") ||
           !oDocument["SnapshotId"].IsString() ||
           !oDocument.HasMember("GridInputRevision") ||
           !oDocument["GridInputRevision"].IsUint64() ||
           !oDocument.HasMember("ResultInputRevision") ||
           !oDocument["ResultInputRevision"].IsUint64() ||
           !oBuilder.setSnapshotId(QString::fromUtf8(
                oDocument["SnapshotId"].GetString())) ||
           !oBuilder.setInputRevisions(
                oDocument["GridInputRevision"].GetUint64(),
                oDocument["ResultInputRevision"].GetUint64()) ||
           !oBuilder.takeResultGrid(pGrid) || pGrid != NULL ||
           !oBuilder.takeStaticProperties(oStaticProperties) ||
           !oStaticProperties.m_vecPermeabilityMilliDarcy.isEmpty() ||
           !oStaticProperties.m_vecPorosity.isEmpty() ||
           !oStaticProperties.m_vecThicknessMeters.isEmpty() ||
           !readPressureFrames(sPressurePath, nCellCount, nFrameCount,
                               &oBuilder, pError))
        {
            return setError(pError, pError != NULL && !pError->isEmpty()
                    ? *pError : "PEBI snapshot identity or pressure frames are invalid.");
        }

        double dScalarMinimum = 0.0;
        double dScalarMaximum = 0.0;
        if(!readRequiredDouble(oDocument, "ScalarMinimum", dScalarMinimum) ||
           !readRequiredDouble(oDocument, "ScalarMaximum", dScalarMaximum) ||
           !oBuilder.setScalarRange(dScalarMinimum, dScalarMaximum) ||
           !oDocument.HasMember("SolverSlots") ||
           !oDocument["SolverSlots"].IsArray() ||
           oDocument["SolverSlots"].Size() > g_nMaximumWellCount + 100000u)
        {
            return setError(pError, "PEBI snapshot scalar range or solver slots are invalid.");
        }
        const rapidjson::Value& oSlots = oDocument["SolverSlots"];
        for(rapidjson::SizeType nIndex = 0; nIndex < oSlots.Size(); ++nIndex)
        {
            const rapidjson::Value& oJson = oSlots[nIndex];
            nmPebiResultSolverSlot oSlot;
            int nEntryKind = 0;
            int nWellType = 0;
            int nWellCategory = 0;
            if(!readRequiredInt(oJson, "SolverIndex", oSlot.m_nSolverIndex) ||
               !readRequiredInt(oJson, "EntryKind", nEntryKind) ||
               !readRequiredInt(oJson, "WellType", nWellType) ||
               !readRequiredInt(oJson, "WellCategory", nWellCategory) ||
               !oJson.HasMember("WellInstanceId") ||
               !oJson["WellInstanceId"].IsString() ||
               !oJson.HasMember("WellCode") || !oJson["WellCode"].IsString())
            {
                return setError(pError, "PEBI snapshot solver slot is invalid.");
            }
            oSlot.m_eEntryKind = static_cast<NM_SOLVER_ENTRY_KIND>(nEntryKind);
            oSlot.m_eWellType = static_cast<NM_WELL_MODEL>(nWellType);
            oSlot.m_eWellCategory = static_cast<NM_WELL_CATEGORY>(
                    nWellCategory);
            oSlot.m_sWellInstanceId = QString::fromUtf8(
                    oJson["WellInstanceId"].GetString());
            oSlot.m_sWellCode = QString::fromUtf8(oJson["WellCode"].GetString());
            if(!oBuilder.addSolverSlot(oSlot))
            {
                return setError(pError, "Cannot restore PEBI snapshot solver slot.");
            }
        }

        if(!oDocument.HasMember("Wells") || !oDocument["Wells"].IsArray() ||
           oDocument["Wells"].Size() != nWellCount)
        {
            return setError(pError, "PEBI snapshot well directory is invalid.");
        }
        const rapidjson::Value& oWells = oDocument["Wells"];
        QSet<QString> setJsonWellIds;
        for(rapidjson::SizeType nIndex = 0; nIndex < oWells.Size(); ++nIndex)
        {
            const rapidjson::Value& oJson = oWells[nIndex];
            nmPebiResultWellSnapshot oWell;
            int nWellType = 0;
            int nWellCategory = 0;
            int nWellMode = 0;
            int nFlowSchedulePhase = 0;
            if(!oJson.IsObject() ||
               !oJson.HasMember("WellInstanceId") ||
               !oJson["WellInstanceId"].IsString() ||
               !oJson.HasMember("WellCode") || !oJson["WellCode"].IsString() ||
               !oJson.HasMember("WellName") || !oJson["WellName"].IsString() ||
               !oJson.HasMember("GaugeInputSha1") ||
               !oJson["GaugeInputSha1"].IsString() ||
               oJson["GaugeInputSha1"].GetStringLength() != 40u ||
               !readRequiredInt(oJson, "WellType", nWellType) ||
               !readRequiredInt(oJson, "WellCategory", nWellCategory) ||
               !readRequiredInt(oJson, "WellMode", nWellMode) ||
               !readRequiredInt(oJson, "FlowSchedulePhase",
                    nFlowSchedulePhase) ||
               !readRequiredInt(oJson, "FlowSectionIndex",
                    oWell.m_nFlowSectionIndex) ||
               !readRequiredBool(oJson, "UseOilRate",
                    oWell.m_bUseOilRate) ||
               !readRequiredBool(oJson, "UseGasRate",
                    oWell.m_bUseGasRate) ||
               !readRequiredBool(oJson, "UseWaterRate",
                    oWell.m_bUseWaterRate) ||
               !readDoubleVector(oJson, "FlowDurations",
                    oWell.m_vecFlowDurations) ||
               !readDoubleVector(oJson, "OilRates",
                    oWell.m_vecOilRates) ||
               !readDoubleVector(oJson, "GasRates",
                    oWell.m_vecGasRates) ||
               !readDoubleVector(oJson, "WaterRates",
                    oWell.m_vecWaterRates) ||
               !readRequiredDouble(oJson, "X", oWell.m_oLocation.rx()) ||
               !readRequiredDouble(oJson, "Y", oWell.m_oLocation.ry()) ||
               !readRequiredBool(oJson, "HasPerforation", oWell.m_bHasPerforation) ||
               !readRequiredBool(oJson, "HasSkin", oWell.m_bHasSkin) ||
               !readRequiredBool(oJson, "HasDfc", oWell.m_bHasDfc) ||
               !readRequiredDouble(oJson, "Radius", oWell.m_dRadius) ||
               !readRequiredDouble(oJson, "WellboreStorage", oWell.m_dWellboreStorage) ||
               !readRequiredDouble(oJson, "Skin", oWell.m_dSkin) ||
               !readRequiredDouble(oJson, "Dfc", oWell.m_dDfc))
            {
                return setError(pError, "PEBI snapshot well metadata are invalid.");
            }
            oWell.m_sWellInstanceId = QString::fromUtf8(
                    oJson["WellInstanceId"].GetString());
            oWell.m_sWellCode = QString::fromUtf8(oJson["WellCode"].GetString());
            oWell.m_sWellName = QString::fromUtf8(oJson["WellName"].GetString());
            oWell.m_sGaugeInputSha1 = QString::fromLatin1(
                    oJson["GaugeInputSha1"].GetString(),
                    static_cast<int>(
                        oJson["GaugeInputSha1"].GetStringLength()));
            oWell.m_eWellType = static_cast<NM_WELL_MODEL>(nWellType);
            oWell.m_eWellCategory = static_cast<NM_WELL_CATEGORY>(
                    nWellCategory);
            oWell.m_eWellMode = static_cast<NM_CASE_WELL_MODE>(nWellMode);
            oWell.m_eFlowSchedulePhase = static_cast<NM_PHASE_TYPE>(
                    nFlowSchedulePhase);
            if(setJsonWellIds.contains(oWell.m_sWellInstanceId) ||
               !mapCurves.contains(oWell.m_sWellInstanceId))
            {
                return setError(pError, "PEBI snapshot well curve mapping is invalid.");
            }
            setJsonWellIds.insert(oWell.m_sWellInstanceId);
            oWell.m_oCurves = mapCurves.take(oWell.m_sWellInstanceId);
            if(!oBuilder.takeWell(oWell))
            {
                return setError(pError, "Cannot restore PEBI snapshot well.");
            }
        }
        if(!mapCurves.isEmpty())
        {
            return setError(pError, "PEBI well curve file contains unreferenced wells.");
        }

        if(!oDocument.HasMember("DisplayWellInstanceIds") ||
           !oDocument["DisplayWellInstanceIds"].IsArray())
        {
            return setError(pError, "PEBI display well list is missing.");
        }
        QStringList listDisplayWellIds;
        const rapidjson::Value& oDisplay = oDocument["DisplayWellInstanceIds"];
        for(rapidjson::SizeType nIndex = 0; nIndex < oDisplay.Size(); ++nIndex)
        {
            if(!oDisplay[nIndex].IsString())
            {
                return setError(pError, "PEBI display well list is invalid.");
            }
            listDisplayWellIds.append(QString::fromUtf8(
                    oDisplay[nIndex].GetString()));
        }
        if(!oBuilder.setDisplayWellInstanceIds(listDisplayWellIds))
        {
            return setError(pError, "Cannot restore PEBI display well list.");
        }

        if(!oDocument.HasMember("Reservoir") ||
           !oDocument["Reservoir"].IsObject())
        {
            return setError(pError, "PEBI reservoir snapshot is missing.");
        }
        const rapidjson::Value& oReservoirJson = oDocument["Reservoir"];
        nmPebiResultReservoirParameters oReservoir;
        if(!readRequiredDouble(oReservoirJson, "Pi", oReservoir.m_dInitialPressure) ||
           !readRequiredDouble(oReservoirJson, "K", oReservoir.m_dPermeability) ||
           !readRequiredDouble(oReservoirJson, "h", oReservoir.m_dThickness) ||
           !readRequiredDouble(oReservoirJson, "phi", oReservoir.m_dPorosity) ||
           !readRequiredDouble(oReservoirJson, "Cti", oReservoir.m_dTotalCompressibility) ||
           !readRequiredDouble(oReservoirJson, "Cf", oReservoir.m_dRockCompressibility) ||
           !readRequiredDouble(oReservoirJson, "Soi", oReservoir.m_dOilSaturation) ||
           !readRequiredDouble(oReservoirJson, "Sgi", oReservoir.m_dGasSaturation) ||
           !readRequiredDouble(oReservoirJson, "Swi", oReservoir.m_dWaterSaturation) ||
           !oBuilder.setReservoirParameters(oReservoir))
        {
            return setError(pError, "PEBI reservoir snapshot is invalid.");
        }

        if(!oDocument.HasMember("Pvt") || !oDocument["Pvt"].IsObject())
        {
            return setError(pError, "PEBI PVT snapshot is missing.");
        }
        const rapidjson::Value& oPvtJson = oDocument["Pvt"];
        nmPebiResultPvtParameters oPvt;
        if(!readRequiredBool(oPvtJson, "HasBubblePoint", oPvt.m_bHasBubblePoint) ||
           !readRequiredDouble(oPvtJson, "BubblePoint", oPvt.m_dBubblePoint) ||
           !readRequiredDouble(oPvtJson, "ConstantBo", oPvt.m_dConstantBo) ||
           !readRequiredDouble(oPvtJson, "ConstantMiuo", oPvt.m_dConstantMiuo) ||
           !readRequiredDouble(oPvtJson, "ConstantBg", oPvt.m_dConstantBg) ||
           !readRequiredDouble(oPvtJson, "ConstantMiug", oPvt.m_dConstantMiug) ||
           !readRequiredDouble(oPvtJson, "ConstantBw", oPvt.m_dConstantBw) ||
           !readRequiredDouble(oPvtJson, "ConstantMiuw", oPvt.m_dConstantMiuw))
        {
            return setError(pError, "PEBI PVT constants are invalid.");
        }
#define NM_READ_PVT_VECTOR(Name) readDoubleVector(oPvtJson, #Name, oPvt.m_vec##Name)
        if(!NM_READ_PVT_VECTOR(Pressure) || !NM_READ_PVT_VECTOR(Rso) ||
           !NM_READ_PVT_VECTOR(Bo) || !NM_READ_PVT_VECTOR(Co) ||
           !NM_READ_PVT_VECTOR(Miuo) || !NM_READ_PVT_VECTOR(Rouo) ||
           !NM_READ_PVT_VECTOR(Rv) || !NM_READ_PVT_VECTOR(Bg) ||
           !NM_READ_PVT_VECTOR(Cg) || !NM_READ_PVT_VECTOR(Miug) ||
           !NM_READ_PVT_VECTOR(Roug) || !NM_READ_PVT_VECTOR(Z) ||
           !NM_READ_PVT_VECTOR(Rsw) || !NM_READ_PVT_VECTOR(Bw) ||
           !NM_READ_PVT_VECTOR(Cw) || !NM_READ_PVT_VECTOR(Miuw) ||
           !NM_READ_PVT_VECTOR(Rouw) || !NM_READ_PVT_VECTOR(V) ||
           !NM_READ_PVT_VECTOR(KkInitial) || !NM_READ_PVT_VECTOR(CfCfInitial) ||
           !NM_READ_PVT_VECTOR(So) || !NM_READ_PVT_VECTOR(Kro) ||
           !NM_READ_PVT_VECTOR(Sg) || !NM_READ_PVT_VECTOR(Krg) ||
           !NM_READ_PVT_VECTOR(Sw) || !NM_READ_PVT_VECTOR(Krw) ||
           !oBuilder.setPvtParameters(oPvt))
        {
#undef NM_READ_PVT_VECTOR
            return setError(pError, "PEBI PVT arrays are invalid.");
        }
#undef NM_READ_PVT_VECTOR

        if(!oDocument.HasMember("SolverSettings") ||
           !oDocument["SolverSettings"].IsObject())
        {
            return setError(pError, "PEBI solver settings are missing.");
        }
        const rapidjson::Value& oSettingsJson = oDocument["SolverSettings"];
        nmPebiResultSolverSettings oSettings;
        if(!readRequiredInt(oSettingsJson, "SolverModelType", oSettings.m_nSolverModelType) ||
           !readRequiredInt(oSettingsJson, "PebiSolverType", oSettings.m_nPebiSolverType) ||
           !readRequiredInt(oSettingsJson, "OmpThreads", oSettings.m_nOmpThreads) ||
           !readRequiredInt(oSettingsJson, "IluReuseSteps", oSettings.m_nIluReuseSteps) ||
           !readRequiredDouble(oSettingsJson, "GridControl", oSettings.m_dGridControl) ||
           !readRequiredBool(oSettingsJson, "HasTimeStepSettings", oSettings.m_bHasTimeStepSettings) ||
           !readRequiredDouble(oSettingsJson, "TimeGrowthExponent", oSettings.m_dTimeGrowthExponent) ||
           !readRequiredDouble(oSettingsJson, "MinDeltaT", oSettings.m_dMinDeltaT) ||
           !readRequiredDouble(oSettingsJson, "MaxDeltaT", oSettings.m_dMaxDeltaT) ||
           !oBuilder.setSolverSettings(oSettings))
        {
            return setError(pError, "PEBI solver settings are invalid.");
        }

        QString sBuilderError;
        if(!oBuilder.finalize(&sBuilderError))
        {
            return setError(pError, sBuilderError);
        }
        pCandidate = oBuilder.takeCandidate();
        if(pCandidate.isNull())
        {
            return setError(pError, "Cannot take the loaded PEBI snapshot candidate.");
        }
        return true;
    }
    catch(const std::bad_alloc&)
    {
        pCandidate.clear();
        return setError(pError, "Not enough memory to load PEBI result snapshot.");
    }
}