#include "nmDataNumericalAnalysisCase.h"

#include <QSet>
#include <QtGlobal>

namespace
{
// 外部枚举值只允许落到当前方案支持的两种井角色，其他值保守按观察井处理。
NM_CASE_WELL_MODE normalizedWellMode(NM_CASE_WELL_MODE eMode)
{
    return eMode == NM_CaseWell_RateControlled
            ? NM_CaseWell_RateControlled : NM_CaseWell_Observation;
}
}

// ==================== 轻量井引用 ====================

nmCalculationWellRef::nmCalculationWellRef()
    : m_eMode(NM_CaseWell_Observation)
{
}

nmCalculationWellRef::nmCalculationWellRef(const QString& sWellCode,
                                           NM_CASE_WELL_MODE eMode)
    : m_sWellCode(sWellCode),
      m_eMode(eMode)
{
}

nmSolverWellRef::nmSolverWellRef()
    : m_nSolverIndex(-1),
      m_eWellType(NM_WELL_MODEL::Unknow_Well),
      m_eEntryKind(NM_SolverEntry_Well)
{
}

nmSolverWellRef::nmSolverWellRef(int nSolverIndex,
                                 NM_WELL_MODEL eWellType,
                                 const QString& sWellCode,
                                 NM_SOLVER_ENTRY_KIND eEntryKind)
    : m_nSolverIndex(nSolverIndex),
      m_eWellType(eWellType),
      m_sWellCode(sWellCode),
      m_eEntryKind(eEntryKind)
{
}

nmDataNumericalAnalysisCase::nmDataNumericalAnalysisCase()
{
    clear();
}

// ==================== 主分析井 ====================

QString nmDataNumericalAnalysisCase::getPrimaryWellCode() const
{
    return m_sPrimaryWellCode;
}

void nmDataNumericalAnalysisCase::setPrimaryWellCode(const QString& sWellCode)
{
    if(m_sPrimaryWellCode == sWellCode) {
        return;
    }

    const QString sOldPrimaryWellCode = m_sPrimaryWellCode;
    m_sPrimaryWellCode = sWellCode;
    normalizeIncludedWells();
    if(!m_bResultsAvailable &&
       (m_sCurrentResultWellCode.isEmpty() ||
        m_sCurrentResultWellCode == sOldPrimaryWellCode)) {
        m_sCurrentResultWellCode = m_sPrimaryWellCode;
    }
    invalidateGrid();
}

NM_CASE_WELL_MODE nmDataNumericalAnalysisCase::getPrimaryWellMode() const
{
    return m_ePrimaryWellMode;
}

void nmDataNumericalAnalysisCase::setPrimaryWellMode(NM_CASE_WELL_MODE eMode)
{
    eMode = normalizedWellMode(eMode);
    if(m_ePrimaryWellMode == eMode) {
        return;
    }

    m_ePrimaryWellMode = eMode;
    invalidateResults();
}

// ==================== 包含其他有产量井 ====================

bool nmDataNumericalAnalysisCase::getIncludeOtherWells() const
{
    return m_bIncludeOtherWells;
}

void nmDataNumericalAnalysisCase::setIncludeOtherWells(bool bInclude)
{
    if(m_bIncludeOtherWells == bInclude) {
        return;
    }

    m_bIncludeOtherWells = bInclude;

    // 只有确实选过有产量干扰井时，总开关才会改变网格中的井集合。
    // Map 中的无产量观察井不经过本开关，由数据管理层始终加入计算。
    // 空选择下切换开关只是保存用户设置，不应触发一次无意义的网格重建。
    if(!m_vecIncludedWells.isEmpty()) {
        invalidateGrid();
    }
}

double nmDataNumericalAnalysisCase::getPebiGridControl() const
{
    return m_dPebiGridControl;
}

void nmDataNumericalAnalysisCase::setPebiGridControl(double dGridControl)
{
    // 第一步：网格控制值必须为正数，非法输入不能污染当前有效方案。
    if(dGridControl <= 0.0) {
        return;
    }

    // 第二步：相同数值不重复增加输入版本，避免界面刷新引发无意义重划分。
    if(qFuzzyCompare(m_dPebiGridControl, dGridControl)) {
        return;
    }

    // 第三步：网格密度属于几何离散输入，变化后网格和结果必须同时失效。
    m_dPebiGridControl = dGridControl;
    invalidateGrid();
}

// 包含井列表只保存用户显式选择；Map 中无产量井由数据管理器动态补入有效集合。
QVector<nmCalculationWellRef> nmDataNumericalAnalysisCase::getIncludedWells() const
{
    return m_vecIncludedWells;
}

void nmDataNumericalAnalysisCase::setIncludedWells(
    const QVector<nmCalculationWellRef>& vecWells)
{
    // 第一步：保存旧选择，并对新的有产量干扰井做去空和去重。
    QVector<nmCalculationWellRef> vecOldWells = m_vecIncludedWells;
    m_vecIncludedWells = vecWells;
    normalizeIncludedWells();

    // 第二步：井在对话框中的显示顺序不影响 PEBI 几何，只比较 WellCode 集合。
    QSet<QString> setOldWellCodes;
    QSet<QString> setNewWellCodes;
    for(int nIndex = 0; nIndex < vecOldWells.size(); ++nIndex) {
        setOldWellCodes.insert(vecOldWells[nIndex].m_sWellCode);
    }
    for(int nIndex = 0; nIndex < m_vecIncludedWells.size(); ++nIndex) {
        setNewWellCodes.insert(m_vecIncludedWells[nIndex].m_sWellCode);
    }

    const bool bWellSetChanged = setOldWellCodes != setNewWellCodes;

    // 第三步：总开关关闭时，包含井尚未进入有效计算集合，选择变化只需保存。
    if(!m_bIncludeOtherWells) {
        return;
    }

    // 第四步：IncludedWells 中的井固定为主动井，增删井会改变网格。
    if(bWellSetChanged) {
        invalidateGrid();
    }
}

bool nmDataNumericalAnalysisCase::isIncludedWell(const QString& sWellCode) const
{
    for(int nIndex = 0; nIndex < m_vecIncludedWells.size(); ++nIndex) {
        if(m_vecIncludedWells[nIndex].m_sWellCode == sWellCode) {
            return true;
        }
    }

    return false;
}

NM_CASE_WELL_MODE nmDataNumericalAnalysisCase::getWellMode(
    const QString& sWellCode) const
{
    if(sWellCode == m_sPrimaryWellCode) {
        return m_ePrimaryWellMode;
    }

    for(int nIndex = 0; nIndex < m_vecIncludedWells.size(); ++nIndex) {
        if(m_vecIncludedWells[nIndex].m_sWellCode == sWellCode) {
            return m_vecIncludedWells[nIndex].m_eMode;
        }
    }

    return NM_CaseWell_Observation;
}

QVector<nmCalculationWellRef> nmDataNumericalAnalysisCase::getEffectiveWells() const
{
    QVector<nmCalculationWellRef> vecResult;

    // 第一步：主分析井始终参与当前数值分析，并固定排在第一位。
    if(!m_sPrimaryWellCode.isEmpty()) {
        vecResult.append(nmCalculationWellRef(m_sPrimaryWellCode,
                                               m_ePrimaryWellMode));
    }

    // 第二步：这里只返回方案显式保存的井。数据管理层还会把 Map 中所有
    // 无产量井自动追加为观察井，它们与 Include Other Wells 完全无关。
    if(m_bIncludeOtherWells) {
        vecResult += m_vecIncludedWells;
    }

    return vecResult;
}

// ==================== 结果查看状态 ====================

QString nmDataNumericalAnalysisCase::getCurrentResultWellCode() const
{
    return m_sCurrentResultWellCode;
}

void nmDataNumericalAnalysisCase::setCurrentResultWellCode(
    const QString& sWellCode)
{
    // 切换结果井只是界面查看状态，不应触发网格或求解结果失效。
    m_sCurrentResultWellCode = sWellCode;
}

// ==================== DLL 求解器井槽位顺序 ====================

QVector<nmSolverWellRef> nmDataNumericalAnalysisCase::getSolverWellOrder() const
{
    return m_vecSolverWellOrder;
}

void nmDataNumericalAnalysisCase::clearSolverWellOrder()
{
    m_vecSolverWellOrder.clear();
    m_nBuiltGridRevision = 0;
    m_bResultsValid = false;
}

void nmDataNumericalAnalysisCase::appendSolverWell(
    const nmSolverWellRef& oWellRef)
{
    nmSolverWellRef oIndexedRef = oWellRef;
    oIndexedRef.m_nSolverIndex = m_vecSolverWellOrder.size();
    m_vecSolverWellOrder.append(oIndexedRef);
    m_bResultsValid = false;
}

void nmDataNumericalAnalysisCase::insertSolverWell(
    int nIndex,
    const nmSolverWellRef& oWellRef)
{
    if(nIndex < 0 || nIndex > m_vecSolverWellOrder.size()) {
        return;
    }

    m_vecSolverWellOrder.insert(nIndex, oWellRef);
    for(int nOrderIndex = 0;
        nOrderIndex < m_vecSolverWellOrder.size();
        ++nOrderIndex) {
        m_vecSolverWellOrder[nOrderIndex].m_nSolverIndex = nOrderIndex;
    }
    m_bResultsValid = false;
}

bool nmDataNumericalAnalysisCase::removeSolverWell(int nIndex)
{
    if(nIndex < 0 || nIndex >= m_vecSolverWellOrder.size()) {
        return false;
    }

    m_vecSolverWellOrder.remove(nIndex);
    for(int nOrderIndex = 0;
        nOrderIndex < m_vecSolverWellOrder.size();
        ++nOrderIndex) {
        m_vecSolverWellOrder[nOrderIndex].m_nSolverIndex = nOrderIndex;
    }
    m_bResultsValid = false;
    return true;
}

void nmDataNumericalAnalysisCase::setSolverWellOrder(
    const QVector<nmSolverWellRef>& vecOrder)
{
    m_vecSolverWellOrder = vecOrder;
    for(int nIndex = 0; nIndex < m_vecSolverWellOrder.size(); ++nIndex) {
        m_vecSolverWellOrder[nIndex].m_nSolverIndex = nIndex;
    }
    m_bResultsValid = false;
}

QVector<nmSolverWellRef>
nmDataNumericalAnalysisCase::getResultSolverWellOrder() const
{
    return m_vecResultSolverWellOrder;
}

QStringList nmDataNumericalAnalysisCase::getResultSelectableWellCodes() const
{
    return m_listResultSelectableWellCodes;
}

void nmDataNumericalAnalysisCase::restoreResultState(
    const QVector<nmSolverWellRef>& vecOrder,
    bool bAvailable,
    bool bCurrent)
{
    restoreResultState(vecOrder, QStringList(), bAvailable, bCurrent);
}

void nmDataNumericalAnalysisCase::restoreResultState(
    const QVector<nmSolverWellRef>& vecOrder,
    const QStringList& listSelectableWellCodes,
    bool bAvailable,
    bool bCurrent)
{
    m_vecResultSolverWellOrder = vecOrder;
    QSet<QString> setResultWellCodes;
    for(int nIndex = 0;
        nIndex < m_vecResultSolverWellOrder.size();
        ++nIndex) {
        m_vecResultSolverWellOrder[nIndex].m_nSolverIndex = nIndex;
        const nmSolverWellRef& oWellRef = m_vecResultSolverWellOrder[nIndex];
        if(oWellRef.m_eEntryKind == NM_SolverEntry_Well) {
            setResultWellCodes.insert(oWellRef.m_sWellCode);
        }
    }

    m_listResultSelectableWellCodes.clear();
    for(int nIndex = 0; nIndex < listSelectableWellCodes.size(); ++nIndex) {
        const QString sWellCode = listSelectableWellCodes[nIndex];
        if(setResultWellCodes.contains(sWellCode) &&
           !m_listResultSelectableWellCodes.contains(sWellCode)) {
            m_listResultSelectableWellCodes.append(sWellCode);
        }
    }

    m_bResultsAvailable = bAvailable &&
            !m_vecResultSolverWellOrder.isEmpty();
    m_bResultsValid = m_bResultsAvailable && bCurrent;
    if(m_bResultsAvailable) {
        // 旧成果没有独立可显示井字段时，按保存的主井和包含井保守恢复。
        if(m_listResultSelectableWellCodes.isEmpty()) {
            freezeResultSelectableWellCodes();
        }
        normalizeCurrentResultWellCode();
    }
}

// ==================== 网格与结果版本管理 ====================

void nmDataNumericalAnalysisCase::invalidateGrid()
{
    ++m_nGridInputRevision;
    m_nBuiltGridRevision = 0;
    m_vecSolverWellOrder.clear();
    invalidateResults();
}

void nmDataNumericalAnalysisCase::invalidateResults()
{
    ++m_nResultInputRevision;
    m_bResultsValid = false;
}

void nmDataNumericalAnalysisCase::markGridBuilt()
{
    m_nBuiltGridRevision = m_nGridInputRevision;
    m_bResultsValid = false;
}

bool nmDataNumericalAnalysisCase::markGridBuiltIfCurrent(
    quint64 nGridInputRevision)
{
    // 第一步：后台划分期间几何输入发生变化时，当前输出立即作废。
    if(nGridInputRevision != m_nGridInputRevision ||
       m_vecSolverWellOrder.isEmpty()) {
        m_nBuiltGridRevision = 0;
        m_bResultsValid = false;
        return false;
    }

    // 第二步：输入版本未变化时，才把求解器顺序和网格登记为同一版本。
    markGridBuilt();
    return true;
}

void nmDataNumericalAnalysisCase::discardResults()
{
    // 重新求解本身不是输入修改，只清除有效标记，不增加结果输入版本号。
    m_bResultsValid = false;
}

void nmDataNumericalAnalysisCase::markResultsAvailable()
{
    if(!isGridValid()) {
        return;
    }

    m_vecResultSolverWellOrder = m_vecSolverWellOrder;
    freezeResultSelectableWellCodes();
    m_bResultsAvailable = true;
    m_bResultsValid = true;
    normalizeCurrentResultWellCode();
}

bool nmDataNumericalAnalysisCase::markResultsAvailableIfCurrent(
    quint64 nGridInputRevision,
    quint64 nResultInputRevision)
{
    // 第一步：任务使用的网格版本和求解输入版本必须仍是当前版本。
    const bool bInputCurrent =
            nGridInputRevision == m_nGridInputRevision &&
            nResultInputRevision == m_nResultInputRevision;

    // 第二步：只有输入未变化且网格仍有效时，才允许旧线程提交结果。
    // 校验失败不能破坏此前已经存在的结果。
    if(!bInputCurrent || !isGridValid()) {
        return false;
    }

    m_vecResultSolverWellOrder = m_vecSolverWellOrder;
    freezeResultSelectableWellCodes();
    m_bResultsAvailable = true;
    m_bResultsValid = true;
    normalizeCurrentResultWellCode();
    return true;
}

bool nmDataNumericalAnalysisCase::isGridValid() const
{
    return m_nBuiltGridRevision != 0 &&
           m_nBuiltGridRevision == m_nGridInputRevision &&
           !m_vecSolverWellOrder.isEmpty();
}

bool nmDataNumericalAnalysisCase::areResultsValid() const
{
    return areResultsCurrent() && isGridValid();
}

bool nmDataNumericalAnalysisCase::hasResults() const
{
    return m_bResultsAvailable &&
           !m_vecResultSolverWellOrder.isEmpty();
}

bool nmDataNumericalAnalysisCase::areResultsCurrent() const
{
    return hasResults() && m_bResultsValid;
}

quint64 nmDataNumericalAnalysisCase::getGridInputRevision() const
{
    return m_nGridInputRevision;
}

quint64 nmDataNumericalAnalysisCase::getBuiltGridRevision() const
{
    return m_nBuiltGridRevision;
}

quint64 nmDataNumericalAnalysisCase::getResultInputRevision() const
{
    return m_nResultInputRevision;
}

// 项目重新初始化时恢复完整默认状态，不保留上一成果的井关联或有效标记。
void nmDataNumericalAnalysisCase::clear()
{
    m_sPrimaryWellCode.clear();
    m_ePrimaryWellMode = NM_CaseWell_Observation;
    m_bIncludeOtherWells = false;
    m_dPebiGridControl = 150.0;
    m_vecIncludedWells.clear();
    m_sCurrentResultWellCode.clear();
    m_vecSolverWellOrder.clear();
    m_vecResultSolverWellOrder.clear();
    m_listResultSelectableWellCodes.clear();
    m_nGridInputRevision = 1;
    m_nBuiltGridRevision = 0;
    m_nResultInputRevision = 1;
    m_bResultsAvailable = false;
    m_bResultsValid = false;
}

void nmDataNumericalAnalysisCase::normalizeIncludedWells()
{
    QVector<nmCalculationWellRef> vecNormalized;
    QSet<QString> setSeenWellCodes;

    for(int nIndex = 0; nIndex < m_vecIncludedWells.size(); ++nIndex) {
        const nmCalculationWellRef& oWellRef = m_vecIncludedWells[nIndex];
        if(oWellRef.m_sWellCode.isEmpty() ||
           oWellRef.m_sWellCode == m_sPrimaryWellCode ||
           setSeenWellCodes.contains(oWellRef.m_sWellCode)) {
            continue;
        }

        setSeenWellCodes.insert(oWellRef.m_sWellCode);
        vecNormalized.append(nmCalculationWellRef(
                oWellRef.m_sWellCode,
                NM_CaseWell_RateControlled));
    }

    m_vecIncludedWells = vecNormalized;
}

void nmDataNumericalAnalysisCase::normalizeCurrentResultWellCode()
{
    if(m_listResultSelectableWellCodes.contains(
           m_sCurrentResultWellCode)) {
        return;
    }

    m_sCurrentResultWellCode = m_listResultSelectableWellCodes.isEmpty()
            ? QString() : m_listResultSelectableWellCodes.first();
}

void nmDataNumericalAnalysisCase::freezeResultSelectableWellCodes()
{
    QSet<QString> setSelectableWellCodes;
    if(!m_sPrimaryWellCode.isEmpty()) {
        setSelectableWellCodes.insert(m_sPrimaryWellCode);
    }
    if(m_bIncludeOtherWells) {
        for(int nIndex = 0; nIndex < m_vecIncludedWells.size(); ++nIndex) {
            setSelectableWellCodes.insert(
                        m_vecIncludedWells[nIndex].m_sWellCode);
        }
    }

    m_listResultSelectableWellCodes.clear();
    for(int nIndex = 0;
        nIndex < m_vecResultSolverWellOrder.size();
        ++nIndex) {
        const nmSolverWellRef& oWellRef =
                m_vecResultSolverWellOrder[nIndex];
        if(oWellRef.m_eEntryKind == NM_SolverEntry_Well &&
           setSelectableWellCodes.contains(oWellRef.m_sWellCode) &&
           !m_listResultSelectableWellCodes.contains(oWellRef.m_sWellCode)) {
            m_listResultSelectableWellCodes.append(oWellRef.m_sWellCode);
        }
    }
}