/////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (C) 2017-  Statoil ASA
//
//  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 "RifEclipseUserDataKeywordTools.h"

#include "RiaLogging.h"
#include "RiaStdStringTools.h"

#include "RifEclipseUserDataParserTools.h"

#include "RiuSummaryQuantityNameInfoProvider.h"

#include <QStringList>

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<size_t> RifEclipseUserDataKeywordTools::requiredItemsPerLineForKeyword( const std::string& identifier )
{
    if ( identifier.size() < 2 ) return {};

    char firstLetter = identifier[0];
    switch ( firstLetter )
    {
        case 'B':
            return { 3 }; // Block triplet
        case 'C':
            return { 1, 3 }; // Well Name and completion triplet
        case 'G':
            return { 1 }; // Group
        case 'R':
            return { 1 }; // Region number
        case 'S':
            return { 1, 1 }; // Well name and segment number
        case 'W':
            return { 1 }; // Well Name
    }

    std::string firstTwoLetters = identifier.substr( 0, 2 );

    if ( firstTwoLetters == "LB" )
        return { 1, 3 }; // LGR name and block triplet
    else if ( firstTwoLetters == "LC" )
        return { 1, 1, 3 }; // LGR name, well name and block triplet
    else if ( firstTwoLetters == "LW" )
        return { 1, 1 }; // LGR name and well name

    return {};
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<std::string>>
    RifEclipseUserDataKeywordTools::buildColumnHeaderText( const std::vector<std::string>&              quantityNames,
                                                           const std::vector<std::vector<std::string>>& restOfHeaderRows,
                                                           std::vector<std::string>*                    errorText )
{
    std::vector<std::vector<std::string>> tableHeaderText;

    std::vector<size_t> headerLineWordIndices( restOfHeaderRows.size(), 0 );

    for ( size_t i = 0; i < quantityNames.size(); i++ )
    {
        std::vector<std::string> columnHeaderText;

        auto quantityName = quantityNames[i];
        columnHeaderText.push_back( quantityName );

        auto itemCountPerLine = RifEclipseUserDataKeywordTools::requiredItemsPerLineForKeyword( quantityName );
        if ( itemCountPerLine.size() > restOfHeaderRows.size() )
        {
            std::string text = "Detected too few header lines";
            if ( errorText ) errorText->push_back( text );

            return std::vector<std::vector<std::string>>();
        }

        for ( size_t lineIdx = 0; lineIdx < itemCountPerLine.size(); lineIdx++ )
        {
            auto line = restOfHeaderRows[lineIdx];

            for ( size_t itemIndex = 0; itemIndex < itemCountPerLine[lineIdx]; itemIndex++ )
            {
                size_t wordIndex = headerLineWordIndices[lineIdx];
                if ( wordIndex >= line.size() )
                {
                    std::string text = "Detected too few items for header line";
                    if ( errorText ) errorText->push_back( text );

                    return std::vector<std::vector<std::string>>();
                }

                auto word = line[wordIndex];

                columnHeaderText.push_back( word );

                headerLineWordIndices[lineIdx]++;
            }
        }

        tableHeaderText.push_back( columnHeaderText );
    }

    return tableHeaderText;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseUserDataKeywordTools::isTime( const std::string& identifier )
{
    return ( identifier == "TIME" );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseUserDataKeywordTools::isDate( const std::string& identifier )
{
    return ( identifier == "DATE" );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseUserDataKeywordTools::isDays( const std::string& identifier )
{
    return ( identifier.find( "DAYS" ) != std::string::npos );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseUserDataKeywordTools::isYears( const std::string& identifier )
{
    return ( identifier.find( "YEARS" ) != std::string::npos );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseUserDataKeywordTools::isYearX( const std::string& identifier )
{
    return ( identifier.find( "YEARX" ) != std::string::npos );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifEclipseSummaryAddress RifEclipseUserDataKeywordTools::makeAndFillAddress( const std::string               quantityName,
                                                                             const std::vector<std::string>& columnHeaderText )
{
    RifEclipseSummaryAddress::SummaryVarCategory category = RiuSummaryQuantityNameInfoProvider::instance()->identifyCategory( quantityName );

    if ( category == RifEclipseSummaryAddress::SUMMARY_INVALID )
    {
        return RifEclipseSummaryAddress::importedAddress( quantityName );
    }

    int         regionNumber      = -1;
    int         regionNumber2     = -1;
    std::string groupName         = "";
    std::string wellName          = "";
    int         wellSegmentNumber = -1;
    std::string lgrName           = "";
    int         cellI             = -1;
    int         cellJ             = -1;
    int         cellK             = -1;
    int         aquiferNumber     = -1;
    bool        isErrorResult     = false;
    int         id                = -1;

    switch ( category )
    {
        case RifEclipseSummaryAddress::SUMMARY_FIELD:
            break;
        case RifEclipseSummaryAddress::SUMMARY_AQUIFER:
        {
            if ( columnHeaderText.size() > 0 )
            {
                aquiferNumber = RiaStdStringTools::toInt( columnHeaderText[0] );
            }
            break;
        }
        case RifEclipseSummaryAddress::SUMMARY_NETWORK:
            break;
        case RifEclipseSummaryAddress::SUMMARY_MISC:
            break;
        case RifEclipseSummaryAddress::SUMMARY_REGION:
        {
            if ( columnHeaderText.size() > 0 )
            {
                regionNumber = RiaStdStringTools::toInt( columnHeaderText[0] );
            }
            break;
        }
        case RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION:
            break;
        case RifEclipseSummaryAddress::SUMMARY_GROUP:
        {
            if ( columnHeaderText.size() > 0 )
            {
                groupName = columnHeaderText[0];
            }
            break;
        }
        case RifEclipseSummaryAddress::SUMMARY_WELL:
        {
            if ( columnHeaderText.size() > 0 )
            {
                wellName = columnHeaderText[0];
            }
            break;
        }
        case RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION:
        {
            if ( columnHeaderText.size() > 1 )
            {
                wellName = columnHeaderText[0];

                RifEclipseUserDataKeywordTools::extractThreeInts( &cellI, &cellJ, &cellK, columnHeaderText[1] );
            }
            break;
        }
        break;
        case RifEclipseSummaryAddress::SUMMARY_WELL_LGR:
            if ( columnHeaderText.size() > 1 )
            {
                wellName = columnHeaderText[0];
                lgrName  = columnHeaderText[1];
            }
            break;
        case RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR:
            if ( columnHeaderText.size() > 2 )
            {
                wellName = columnHeaderText[0];
                lgrName  = columnHeaderText[1];

                RifEclipseUserDataKeywordTools::extractThreeInts( &cellI, &cellJ, &cellK, columnHeaderText[2] );
            }
            break;
        case RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT:
            if ( columnHeaderText.size() > 1 )
            {
                wellName          = columnHeaderText[0];
                wellSegmentNumber = RiaStdStringTools::toInt( columnHeaderText[1] );
            }
            break;
        case RifEclipseSummaryAddress::SUMMARY_BLOCK:
            if ( columnHeaderText.size() > 0 )
            {
                RifEclipseUserDataKeywordTools::extractThreeInts( &cellI, &cellJ, &cellK, columnHeaderText[0] );
            }
            break;
        case RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR:
            if ( columnHeaderText.size() > 1 )
            {
                lgrName = columnHeaderText[0];

                RifEclipseUserDataKeywordTools::extractThreeInts( &cellI, &cellJ, &cellK, columnHeaderText[1] );
            }
            break;
        default:
            break;
    }

    return RifEclipseSummaryAddress( category,
                                     quantityName,
                                     regionNumber,
                                     regionNumber2,
                                     groupName,
                                     wellName,
                                     wellSegmentNumber,
                                     lgrName,
                                     cellI,
                                     cellJ,
                                     cellK,
                                     aquiferNumber,
                                     isErrorResult,
                                     id );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseUserDataKeywordTools::isStepType( const std::string& identifier )
{
    return ( identifier.find( "STEPTYPE" ) != std::string::npos );
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RifEclipseUserDataKeywordTools::computeRequiredHeaderLineCount( const std::vector<std::string>& words )
{
    size_t maxHeaderLinesFromKeywords = 0;

    for ( auto w : words )
    {
        if ( knownKeywordsWithZeroRequiredHeaderLines( w ) ) continue;

        auto linesForKeyword = RifEclipseUserDataKeywordTools::requiredItemsPerLineForKeyword( w ).size();
        if ( linesForKeyword > maxHeaderLinesFromKeywords )
        {
            maxHeaderLinesFromKeywords = linesForKeyword;
        }
    }

    // Vector name and unit, scaling is optional
    return 1 + maxHeaderLinesFromKeywords;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseUserDataKeywordTools::knownKeywordsWithZeroRequiredHeaderLines( const std::string& identifier )
{
    if ( identifier.find( "DAY" ) != std::string::npos ) return true;
    if ( identifier.find( "MONTH" ) != std::string::npos ) return true;
    if ( identifier.find( "YEAR" ) != std::string::npos ) return true;

    if ( identifier.find( "DATE" ) != std::string::npos ) return true;
    if ( identifier.find( "TIME" ) != std::string::npos ) return true;

    if ( identifier.find( "ELAPSED" ) != std::string::npos ) return true;

    if ( identifier.find( "NEWTON" ) != std::string::npos ) return true;

    if ( identifier.find( "NLINSMIN" ) != std::string::npos ) return true;
    if ( identifier.find( "NLINSMAX" ) != std::string::npos ) return true;

    if ( identifier.find( "MLINEARS" ) != std::string::npos ) return true;

    if ( identifier.find( "MSUMLINS" ) != std::string::npos ) return true;
    if ( identifier.find( "MSUMNEWT" ) != std::string::npos ) return true;

    if ( identifier.find( "TCPU" ) != std::string::npos ) return true;
    if ( identifier.find( "TCPUTS" ) != std::string::npos ) return true;
    if ( identifier.find( "TCPUDAY" ) != std::string::npos ) return true;

    if ( identifier.find( "TELAPLIN" ) != std::string::npos ) return true;
    if ( identifier.find( "STEPTYPE" ) != std::string::npos ) return true;

    return false;
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifEclipseUserDataKeywordTools::extractThreeInts( int* cellI, int* cellJ, int* cellK, const std::string& line )
{
    std::vector<std::string> words = RiaStdStringTools::splitString( line, ' ' );
    if ( words.size() > 2 )
    {
        *cellI = RiaStdStringTools::toInt( words[0] );
        *cellJ = RiaStdStringTools::toInt( words[1] );
        *cellK = RiaStdStringTools::toInt( words[2] );
    }
}
