/////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (C) 2011-     Statoil ASA
//  Copyright (C) 2013-     Ceetron Solutions AS
//  Copyright (C) 2011-2012 Ceetron AS
//
//  ResInsight is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
//  FITNESS FOR A PARTICULAR PURPOSE.
//
//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
//  for more details.
//
/////////////////////////////////////////////////////////////////////////////////

#include "RigReservoirBuilderMock.h"

#include "RigActiveCellInfo.h"
#include "RigCell.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RigSimWellData.h"

/* rand example: guess the number */
#include <cstdio>
#include <cstdlib>
#include <ctime>

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigReservoirBuilderMock::RigReservoirBuilderMock()
{
    m_resultCount         = 0;
    m_timeStepCount       = 0;
    m_gridPointDimensions = cvf::Vec3st::ZERO;
    m_enableWellData      = true;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::setGridPointDimensions( const cvf::Vec3st& gridPointDimensions )
{
    m_gridPointDimensions = gridPointDimensions;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::setResultInfo( size_t resultCount, size_t timeStepCount )
{
    m_resultCount   = resultCount;
    m_timeStepCount = timeStepCount;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::appendNodes( const cvf::Vec3d&        min,
                                           const cvf::Vec3d&        max,
                                           const cvf::Vec3st&       cubeDimension,
                                           std::vector<cvf::Vec3d>& nodes )
{
    double dx = ( max.x() - min.x() ) / static_cast<double>( cubeDimension.x() );
    double dy = ( max.y() - min.y() ) / static_cast<double>( cubeDimension.y() );
    double dz = ( max.z() - min.z() ) / static_cast<double>( cubeDimension.z() );

    double zPos = min.z();

    size_t k;
    for ( k = 0; k < cubeDimension.z(); k++ )
    {
        double yPos = min.y();

        size_t j;
        for ( j = 0; j < cubeDimension.y(); j++ )
        {
            double xPos = min.x();

            size_t i;
            for ( i = 0; i < cubeDimension.x(); i++ )
            {
                cvf::Vec3d cornerA( xPos, yPos, zPos );
                cvf::Vec3d cornerB( xPos + dx, yPos + dy, zPos + dz );

                appendCubeNodes( cornerA, cornerB, nodes );

                xPos += dx;
            }

            yPos += dy;
        }

        zPos += dz;
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::appendCubeNodes( const cvf::Vec3d& min, const cvf::Vec3d& max, std::vector<cvf::Vec3d>& nodes )
{
    //
    //     7---------6                Faces:
    //    /|        /|     |k           0 bottom   0, 3, 2, 1
    //   / |       / |     | /j         1 top      4, 5, 6, 7
    //  4---------5  |     |/           2 front    0, 1, 5, 4
    //  |  3------|--2     *---i        3 right    1, 2, 6, 5
    //  | /       | /                   4 back     3, 7, 6, 2
    //  |/        |/                    5 left     0, 4, 7, 3
    //  0---------1

    cvf::Vec3d v0( min.x(), min.y(), min.z() );
    cvf::Vec3d v1( max.x(), min.y(), min.z() );
    cvf::Vec3d v2( max.x(), max.y(), min.z() );
    cvf::Vec3d v3( min.x(), max.y(), min.z() );

    cvf::Vec3d v4( min.x(), min.y(), max.z() );
    cvf::Vec3d v5( max.x(), min.y(), max.z() );
    cvf::Vec3d v6( max.x(), max.y(), max.z() );
    cvf::Vec3d v7( min.x(), max.y(), max.z() );

    nodes.push_back( v0 );
    nodes.push_back( v1 );
    nodes.push_back( v2 );
    nodes.push_back( v3 );
    nodes.push_back( v4 );
    nodes.push_back( v5 );
    nodes.push_back( v6 );
    nodes.push_back( v7 );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::appendCells( size_t                nodeStartIndex,
                                           size_t                cellCount,
                                           RigGridBase*          hostGrid,
                                           std::vector<RigCell>& cells )
{
    size_t cellIndexStart = cells.size();
    cells.resize( cells.size() + cellCount );

#pragma omp parallel for
    for ( long long i = 0; i < static_cast<long long>( cellCount ); i++ )
    {
        RigCell& riCell = cells[cellIndexStart + i];

        riCell.setHostGrid( hostGrid );
        riCell.setGridLocalCellIndex( i );

        riCell.cornerIndices()[0] = nodeStartIndex + i * 8 + 0;
        riCell.cornerIndices()[1] = nodeStartIndex + i * 8 + 1;
        riCell.cornerIndices()[2] = nodeStartIndex + i * 8 + 2;
        riCell.cornerIndices()[3] = nodeStartIndex + i * 8 + 3;
        riCell.cornerIndices()[4] = nodeStartIndex + i * 8 + 4;
        riCell.cornerIndices()[5] = nodeStartIndex + i * 8 + 5;
        riCell.cornerIndices()[6] = nodeStartIndex + i * 8 + 6;
        riCell.cornerIndices()[7] = nodeStartIndex + i * 8 + 7;

        riCell.setParentCellIndex( 0 );
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::populateReservoir( RigEclipseCaseData* eclipseCase )
{
    std::vector<cvf::Vec3d>& mainGridNodes = eclipseCase->mainGrid()->nodes();
    appendNodes( m_minWorldCoordinate, m_maxWorldCoordinate, cellDimension(), mainGridNodes );
    size_t mainGridNodeCount = mainGridNodes.size();
    size_t mainGridCellCount = mainGridNodeCount / 8;

    // Must create cells in main grid here, as this information is used when creating LGRs
    appendCells( 0, mainGridCellCount, eclipseCase->mainGrid(), eclipseCase->mainGrid()->globalCellArray() );

    size_t totalCellCount = mainGridCellCount;

    size_t lgrIdx;
    for ( lgrIdx = 0; lgrIdx < m_localGridRefinements.size(); lgrIdx++ )
    {
        LocalGridRefinement& lgr = m_localGridRefinements[lgrIdx];

        // Compute all global cell indices to be replaced by local grid refinement
        std::vector<size_t> mainGridIndicesWithSubGrid;
        {
            size_t i;
            for ( i = lgr.m_mainGridMinCellPosition.x(); i <= lgr.m_mainGridMaxCellPosition.x(); i++ )
            {
                size_t j;
                for ( j = lgr.m_mainGridMinCellPosition.y(); j <= lgr.m_mainGridMaxCellPosition.y(); j++ )
                {
                    size_t k;
                    for ( k = lgr.m_mainGridMinCellPosition.z(); k <= lgr.m_mainGridMaxCellPosition.z(); k++ )
                    {
                        mainGridIndicesWithSubGrid.push_back( cellIndexFromIJK( i, j, k ) );
                    }
                }
            }
        }

        // Create local grid and set local grid dimensions
        RigLocalGrid* localGrid = new RigLocalGrid( eclipseCase->mainGrid() );
        localGrid->setGridId( 1 );
        localGrid->setGridName( "LGR_1" );
        eclipseCase->mainGrid()->addLocalGrid( localGrid );
        localGrid->setParentGrid( eclipseCase->mainGrid() );

        localGrid->setIndexToStartOfCells( mainGridNodes.size() / 8 );
        cvf::Vec3st gridPointDimensions( lgr.m_singleCellRefinementFactors.x() * ( lgr.m_mainGridMaxCellPosition.x() -
                                                                                   lgr.m_mainGridMinCellPosition.x() + 1 ) +
                                             1,
                                         lgr.m_singleCellRefinementFactors.y() * ( lgr.m_mainGridMaxCellPosition.y() -
                                                                                   lgr.m_mainGridMinCellPosition.y() + 1 ) +
                                             1,
                                         lgr.m_singleCellRefinementFactors.z() * ( lgr.m_mainGridMaxCellPosition.z() -
                                                                                   lgr.m_mainGridMinCellPosition.z() + 1 ) +
                                             1 );
        localGrid->setGridPointDimensions( gridPointDimensions );

        cvf::BoundingBox bb;
        size_t           cellIdx;
        for ( cellIdx = 0; cellIdx < mainGridIndicesWithSubGrid.size(); cellIdx++ )
        {
            RigCell& cell = eclipseCase->mainGrid()->globalCellArray()[mainGridIndicesWithSubGrid[cellIdx]];

            std::array<size_t, 8>& indices = cell.cornerIndices();
            int                    nodeIdx;
            for ( nodeIdx = 0; nodeIdx < 8; nodeIdx++ )
            {
                bb.add( eclipseCase->mainGrid()->nodes()[indices[nodeIdx]] );
            }
            // Deactivate cell in main grid
            cell.setSubGrid( localGrid );
        }

        cvf::Vec3st lgrCellDimensions = gridPointDimensions - cvf::Vec3st( 1, 1, 1 );
        appendNodes( bb.min(), bb.max(), lgrCellDimensions, mainGridNodes );

        size_t subGridCellCount = ( mainGridNodes.size() / 8 ) - totalCellCount;
        appendCells( totalCellCount * 8, subGridCellCount, localGrid, eclipseCase->mainGrid()->globalCellArray() );
        totalCellCount += subGridCellCount;
    }

    eclipseCase->mainGrid()->setGridPointDimensions( m_gridPointDimensions );

    if ( m_enableWellData )
    {
        addWellData( eclipseCase, eclipseCase->mainGrid() );
    }

    addFaults( eclipseCase );

    // Set all cells active
    RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
    activeCellInfo->setReservoirCellCount( eclipseCase->mainGrid()->globalCellArray().size() );
    for ( size_t i = 0; i < eclipseCase->mainGrid()->globalCellArray().size(); i++ )
    {
        activeCellInfo->setCellResultIndex( i, i );
    }

    activeCellInfo->setGridCount( 1 );
    activeCellInfo->setGridActiveCellCounts( 0, eclipseCase->mainGrid()->globalCellArray().size() );
    activeCellInfo->computeDerivedData();

    // Add grid coarsening for main grid
    if ( cellDimension().x() > 4 && cellDimension().y() > 5 && cellDimension().z() > 6 )
    {
        eclipseCase->mainGrid()->addCoarseningBox( 1, 2, 1, 3, 1, 4 );
        eclipseCase->mainGrid()->addCoarseningBox( 3, 4, 4, 5, 5, 6 );
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::addLocalGridRefinement( const cvf::Vec3st& mainGridStart,
                                                      const cvf::Vec3st& mainGridEnd,
                                                      const cvf::Vec3st& refinementFactors )
{
    m_localGridRefinements.push_back( LocalGridRefinement( mainGridStart, mainGridEnd, refinementFactors ) );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::setWorldCoordinates( cvf::Vec3d minWorldCoordinate, cvf::Vec3d maxWorldCoordinate )
{
    m_minWorldCoordinate = minWorldCoordinate;
    m_maxWorldCoordinate = maxWorldCoordinate;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigReservoirBuilderMock::inputProperty( RigEclipseCaseData*  eclipseCase,
                                             const QString&       propertyName,
                                             std::vector<double>* values )
{
    size_t k;

    /* initialize random seed: */
    srand( time( nullptr ) );

    /* generate secret number: */
    int iSecret = rand() % 20 + 1;

    for ( k = 0; k < eclipseCase->mainGrid()->globalCellArray().size(); k++ )
    {
        values->push_back( k * iSecret );
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigReservoirBuilderMock::staticResult( RigEclipseCaseData* eclipseCase, const QString& result, std::vector<double>* values )
{
    values->resize( eclipseCase->mainGrid()->globalCellArray().size() );

#pragma omp parallel for
    for ( long long k = 0; k < static_cast<long long>( eclipseCase->mainGrid()->globalCellArray().size() ); k++ )
    {
        values->at( k ) = ( k * 2 ) % eclipseCase->mainGrid()->globalCellArray().size();
    }

    return false;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigReservoirBuilderMock::dynamicResult( RigEclipseCaseData*  eclipseCase,
                                             const QString&       result,
                                             size_t               stepIndex,
                                             std::vector<double>* values )
{
    int resultIndex = 1;

    QRegExp rx( "[0-9]{1,2}" ); // Find number 0-99
    int     digitPos = rx.indexIn( result );
    if ( digitPos > -1 )
    {
        resultIndex = rx.cap( 0 ).toInt() + 1;
    }

    double scaleValue  = 1.0 + resultIndex * 0.1;
    double offsetValue = 100 * resultIndex;

    values->resize( eclipseCase->mainGrid()->globalCellArray().size() );

#pragma omp parallel for
    for ( long long k = 0; k < static_cast<long long>( eclipseCase->mainGrid()->globalCellArray().size() ); k++ )
    {
        double val = offsetValue +
                     scaleValue * ( ( stepIndex * 1000 + k ) % eclipseCase->mainGrid()->globalCellArray().size() );
        values->at( k ) = val;
    }

    // Set result size to zero for some timesteps
    if ( ( stepIndex + 1 ) % 3 == 0 )
    {
        values->clear();
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::addWellData( RigEclipseCaseData* eclipseCase, RigGridBase* grid )
{
    CVF_ASSERT( eclipseCase );
    CVF_ASSERT( grid );

    cvf::Vec3st dim = grid->gridPointDimensions();

    cvf::Collection<RigSimWellData> wells;

    int wellIdx;
    for ( wellIdx = 0; wellIdx < 1; wellIdx++ )
    {
        cvf::ref<RigSimWellData> wellCellsTimeHistory = new RigSimWellData;
        wellCellsTimeHistory->m_wellName              = QString( "Well %1" ).arg( wellIdx );

        wellCellsTimeHistory->m_wellCellsTimeSteps.resize( m_timeStepCount );

        size_t timeIdx;
        for ( timeIdx = 0; timeIdx < m_timeStepCount; timeIdx++ )
        {
            RigWellResultFrame& wellCells = wellCellsTimeHistory->m_wellCellsTimeSteps[timeIdx];

            wellCells.m_productionType = RigWellResultFrame::PRODUCER;
            wellCells.m_isOpen         = true;

            wellCells.m_wellHead.m_gridIndex     = 0;
            wellCells.m_wellHead.m_gridCellIndex = grid->cellIndexFromIJK( 1, 0, 0 );

            // Connections
            //            int connectionCount = std::min(dim.x(), std::min(dim.y(), dim.z())) - 2;
            size_t connectionCount = dim.z() - 2;
            if ( connectionCount > 0 )
            {
                // Only main grid supported by now. Must be taken care of when LGRs are supported
                wellCells.m_wellResultBranches.resize( 1 );
                RigWellResultBranch& wellSegment = wellCells.m_wellResultBranches[0];

                size_t connIdx;
                for ( connIdx = 0; connIdx < connectionCount; connIdx++ )
                {
                    if ( connIdx == ( size_t )( connectionCount / 4 ) ) continue;

                    RigWellResultPoint data;
                    data.m_gridIndex = 0;

                    if ( connIdx < dim.y() - 2 )
                        data.m_gridCellIndex = grid->cellIndexFromIJK( 1, 1 + connIdx, 1 + connIdx );
                    else
                        data.m_gridCellIndex = grid->cellIndexFromIJK( 1, dim.y() - 2, 1 + connIdx );

                    if ( connIdx < connectionCount / 2 )
                    {
                        data.m_isOpen = true;
                    }
                    else
                    {
                        data.m_isOpen = false;
                    }

                    if ( wellSegment.m_branchResultPoints.size() == 0 ||
                         wellSegment.m_branchResultPoints.back().m_gridCellIndex != data.m_gridCellIndex )
                    {
                        wellSegment.m_branchResultPoints.push_back( data );

                        if ( connIdx == connectionCount / 2 )
                        {
                            RigWellResultPoint deadEndData = data;
                            deadEndData.m_gridCellIndex    = data.m_gridCellIndex + 1;
                            deadEndData.m_isOpen           = true;

                            RigWellResultPoint deadEndData1 = data;
                            deadEndData1.m_gridCellIndex    = data.m_gridCellIndex + 2;
                            deadEndData1.m_isOpen           = false;

                            wellSegment.m_branchResultPoints.push_back( deadEndData );
                            wellSegment.m_branchResultPoints.push_back( deadEndData1 );

                            wellSegment.m_branchResultPoints.push_back( deadEndData );

                            data.m_isOpen = true;
                            wellSegment.m_branchResultPoints.push_back( data );
                        }
                    }

                    if ( connIdx < dim.y() - 2 )
                    {
                        data.m_gridCellIndex = grid->cellIndexFromIJK( 1, 1 + connIdx, 2 + connIdx );

                        if ( wellSegment.m_branchResultPoints.size() == 0 ||
                             wellSegment.m_branchResultPoints.back().m_gridCellIndex != data.m_gridCellIndex )
                        {
                            wellSegment.m_branchResultPoints.push_back( data );
                        }
                    }
                }
            }
        }

        // Create a mapping from result timestep indices to well timestep indices.
        // Use one-to-one mapping for easy use
        std::vector<size_t> map;
        for ( timeIdx = 0; timeIdx < m_timeStepCount; timeIdx++ )
        {
            map.push_back( timeIdx );
        }
        wellCellsTimeHistory->m_resultTimeStepIndexToWellTimeStepIndex = map;

        wells.push_back( wellCellsTimeHistory.p() );
    }

    eclipseCase->setSimWellData( wells );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::addFaults( RigEclipseCaseData* eclipseCase )
{
    if ( !eclipseCase ) return;

    RigMainGrid* grid = eclipseCase->mainGrid();
    if ( !grid ) return;

    cvf::Collection<RigFault> faults;

    {
        cvf::ref<RigFault> fault = new RigFault;
        fault->setName( "Fault A" );

        cvf::Vec3st min = cvf::Vec3st::ZERO;
        cvf::Vec3st max( 0, 0, cellDimension().z() - 2 );

        if ( cellDimension().x() > 5 )
        {
            min.x() = cellDimension().x() / 2;
            max.x() = min.x() + 2;
        }

        if ( cellDimension().y() > 5 )
        {
            min.y() = cellDimension().y() / 2;
            max.y() = cellDimension().y() / 2;
        }

        cvf::CellRange cellRange( min, max );

        fault->addCellRangeForFace( cvf::StructGridInterface::POS_I, cellRange );
        faults.push_back( fault.p() );
    }

    grid->setFaults( faults );

    // NNCs
    RigConnectionContainer nncConnections;
    {
        size_t i1 = 2;
        size_t j1 = 2;
        size_t k1 = 3;

        size_t i2 = 2;
        size_t j2 = 3;
        size_t k2 = 4;

        addNnc( grid, i1, j1, k1, i2, j2, k2, nncConnections );
    }

    {
        size_t i1 = 2;
        size_t j1 = 2;
        size_t k1 = 3;

        size_t i2 = 2;
        size_t j2 = 1;
        size_t k2 = 4;

        addNnc( grid, i1, j1, k1, i2, j2, k2, nncConnections );
    }

    grid->nncData()->setNativeConnections( nncConnections );

    std::vector<double>& tranVals =
        grid->nncData()->makeStaticConnectionScalarResult( RiaDefines::propertyNameCombTrans() );
    for ( size_t cIdx = 0; cIdx < tranVals.size(); ++cIdx )
    {
        tranVals[cIdx] = 0.2;
    }
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::enableWellData( bool enableWellData )
{
    m_enableWellData = false;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::addNnc( RigMainGrid*            grid,
                                      size_t                  i1,
                                      size_t                  j1,
                                      size_t                  k1,
                                      size_t                  i2,
                                      size_t                  j2,
                                      size_t                  k2,
                                      RigConnectionContainer& nncConnections )
{
    size_t c1GlobalIndex = grid->cellIndexFromIJK( i1, j1, k1 );
    size_t c2GlobalIndex = grid->cellIndexFromIJK( i2, j2, k2 );

    RigConnection conn( c1GlobalIndex, c2GlobalIndex );

    nncConnections.push_back( conn );
}