/*
    This file is part of libeval, a simple math expression evaluator

    Copyright (C) 2017 Michael Geselbracht, mgeselbracht3@gmail.com

    This program 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.

    This program 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 for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/


#include <libeval/numeric_evaluator.h>

/* The (generated) lemon parser is written in C.
 * In order to keep its symbol from the global namespace include the parser code with
 * a C++ namespace.
 */
namespace numEval
{

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wsign-compare"
#endif

#include "grammar.c"

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif

} /* namespace numEval */


#define VAR                              1
#define ASSIGN                           2
#define SEMCOL                           3
#define PLUS                             4
#define MINUS                            5
#define UNIT                             6
#define DIVIDE                           7
#define MULT                             8
#define ENDS                             9
#define VALUE                           10
#define PARENL                          11
#define PARENR                          12


NUMERIC_EVALUATOR::NUMERIC_EVALUATOR( EDA_UNITS_T aUnits, bool aUseMils )
{
    struct lconv* lc = localeconv();
    m_localeDecimalSeparator = *lc->decimal_point;

    m_parseError = false;
    m_parseFinished = false;

    m_parser = numEval::ParseAlloc( malloc );

    switch( aUnits )
    {
    case INCHES:
        if( aUseMils )
            m_defaultUnits = Unit::Mil;
        else
            m_defaultUnits = Unit::Inch;
        break;
    case MILLIMETRES:m_defaultUnits = Unit::Metric;
        break;
    default:m_defaultUnits = Unit::Metric;
        break;
    }
}


NUMERIC_EVALUATOR::~NUMERIC_EVALUATOR()
{
    numEval::ParseFree( m_parser, free );

    // Allow explicit call to destructor
    m_parser = nullptr;

    Clear();
}


void NUMERIC_EVALUATOR::Clear()
{
    free( m_token.token );
    m_token.token = nullptr;
    m_token.input = nullptr;
    m_parseError = true;
    m_originalText = wxEmptyString;
}


void NUMERIC_EVALUATOR::parseError( const char* s )
{
    m_parseError = true;
}


void NUMERIC_EVALUATOR::parseOk()
{
    m_parseFinished = true;
}


void NUMERIC_EVALUATOR::parseSetResult( double val )
{
    snprintf( m_token.token, m_token.OutLen, "%.10g", val );
}


wxString NUMERIC_EVALUATOR::OriginalText() const
{
    return m_originalText;
}


bool NUMERIC_EVALUATOR::Process( const wxString& aString )
{
    m_originalText = aString;

    // Feed parser token after token until end of input.

    newString( aString );
    m_parseError = false;
    m_parseFinished = false;
    Token tok;

    do
    {
        tok = getToken();
        numEval::Parse( m_parser, tok.token, tok.value, this );

        if( m_parseFinished || tok.token == ENDS )
        {
            // Reset parser by passing zero as token ID, value is ignored.
            numEval::Parse( m_parser, 0, tok.value, this );
            break;
        }
    } while( tok.token );

    return !m_parseError;
}


void NUMERIC_EVALUATOR::newString( const wxString& aString )
{
    Clear();
    auto len = aString.length();
    m_token.token = reinterpret_cast<decltype( m_token.token )>( malloc( TokenStat::OutLen + 1 ));
    strcpy( m_token.token, "0" );
    m_token.inputLen = len;
    m_token.pos = 0;
    m_token.input = aString.mb_str();
    m_parseFinished = false;
}


NUMERIC_EVALUATOR::Token NUMERIC_EVALUATOR::getToken()
{
    Token retval;
    size_t idx;

    retval.token = ENDS;
    retval.value.dValue = 0;

    if( m_token.token == nullptr )
        return retval;

    if( m_token.input == nullptr )
        return retval;

    if( m_token.pos >= m_token.inputLen )
        return retval;

    auto isDecimalSeparator = [ & ]( char ch ) -> bool {
        return ( ch == m_localeDecimalSeparator || ch == '.' || ch == ',' );
    };

    // Lambda: get value as string, store into clToken.token and update current index.
    auto extractNumber = [ & ]() {
        bool haveSeparator = false;
        idx = 0;
        auto ch = m_token.input[ m_token.pos ];

        do
        {
            if( isDecimalSeparator( ch ) && haveSeparator )
                break;

            m_token.token[ idx++ ] = ch;

            if( isDecimalSeparator( ch ))
                haveSeparator = true;

            ch = m_token.input[ ++m_token.pos ];
        } while( isdigit( ch ) || isDecimalSeparator( ch ));

        m_token.token[ idx ] = 0;

        // Ensure that the systems decimal separator is used
        for( int i = strlen( m_token.token ); i; i-- )
            if( isDecimalSeparator( m_token.token[ i - 1 ] ))
                m_token.token[ i - 1 ] = m_localeDecimalSeparator;
    };

    // Lamda: Get unit for current token.
    // Valid units are ", in, mm, mil and thou.  Returns Unit::Invalid otherwise.
    auto checkUnit = [ this ]() -> Unit {
        char ch = m_token.input[ m_token.pos ];

        if( ch == '"' )
        {
            m_token.pos++;
            return Unit::Inch;
        }

        // Do not use strcasecmp() as it is not available on all platforms
        const char* cptr = &m_token.input[ m_token.pos ];
        const auto sizeLeft = m_token.inputLen - m_token.pos;

        if( sizeLeft >= 2 && ch == 'm' && cptr[ 1 ] == 'm' && !isalnum( cptr[ 2 ] ))
        {
            m_token.pos += 2;
            return Unit::Metric;
        }

        if( sizeLeft >= 2 && ch == 'i' && cptr[ 1 ] == 'n' && !isalnum( cptr[ 2 ] ))
        {
            m_token.pos += 2;
            return Unit::Inch;
        }

        if( sizeLeft >= 3 && ch == 'm' && cptr[ 1 ] == 'i' && cptr[ 2 ] == 'l' && !isalnum( cptr[ 3 ] ))
        {
            m_token.pos += 3;
            return Unit::Mil;
        }

        if( sizeLeft >= 4 && ch == 't' && cptr[ 1 ] == 'h' && cptr[ 2 ] == 'o' && cptr[ 3 ] == 'u' && !isalnum( cptr[ 4 ] ))
        {
            m_token.pos += 4;
            return Unit::Mil;
        }

        return Unit::Invalid;
    };

    char ch;

    // Start processing of first/next token: Remove whitespace
    for( ;; )
    {
        ch = m_token.input[ m_token.pos ];

        if( ch == ' ' )
            m_token.pos++;
        else
            break;
    }

    Unit convertFrom;

    if( ch == 0 )
    {
        /* End of input */
    }
    else if( isdigit( ch ) || isDecimalSeparator( ch ))
    {
        // VALUE
        extractNumber();
        retval.token = VALUE;
        retval.value.dValue = atof( m_token.token );
    }
    else if(( convertFrom = checkUnit()) != Unit::Invalid )
    {
        // UNIT
        // Units are appended to a VALUE.
        // Determine factor to default unit if unit for value is given.
        // Example: Default is mm, unit is inch: factor is 25.4
        // The factor is assigned to the terminal UNIT. The actual
        // conversion is done within a parser action.
        retval.token = UNIT;
        if( m_defaultUnits == Unit::Metric )
        {
            switch( convertFrom )
            {
            case Unit::Inch    :retval.value.dValue = 25.4;          break;
            case Unit::Mil     :retval.value.dValue = 25.4 / 1000.0; break;
            case Unit::Metric  :retval.value.dValue = 1.0;           break;
            case Unit::Invalid :break;
            }
        }
        else if( m_defaultUnits == Unit::Inch )
        {
            switch( convertFrom )
            {
            case Unit::Inch    :retval.value.dValue = 1.0;          break;
            case Unit::Mil     :retval.value.dValue = 1.0 / 1000.0; break;
            case Unit::Metric  :retval.value.dValue = 1.0 / 25.4;   break;
            case Unit::Invalid :break;
            }
        }
        else if( m_defaultUnits == Unit::Mil )
        {
            switch( convertFrom )
            {
            case Unit::Inch    :retval.value.dValue = 1.0 * 1000.0;  break;
            case Unit::Mil     :retval.value.dValue = 1.0;           break;
            case Unit::Metric  :retval.value.dValue = 1000.0 / 25.4; break;
            case Unit::Invalid :break;
            }
        }
    }
    else if( isalpha( ch ))
    {
        // VAR
        const char* cptr = &m_token.input[ m_token.pos ];
        cptr++;

        while( isalnum( *cptr ))
            cptr++;

        retval.token = VAR;
        size_t bytesToCopy = cptr - &m_token.input[ m_token.pos ];

        if( bytesToCopy >= sizeof( retval.value.text ))
            bytesToCopy = sizeof( retval.value.text ) - 1;

        strncpy( retval.value.text, &m_token.input[ m_token.pos ], bytesToCopy );
        retval.value.text[ bytesToCopy ] = 0;
        m_token.pos += cptr - &m_token.input[ m_token.pos ];
    }
    else
    {
        // Single char tokens
        switch( ch )
        {
        case '+' :retval.token = PLUS;   break;
        case '-' :retval.token = MINUS;  break;
        case '*' :retval.token = MULT;   break;
        case '/' :retval.token = DIVIDE; break;
        case '(' :retval.token = PARENL; break;
        case ')' :retval.token = PARENR; break;
        case '=' :retval.token = ASSIGN; break;
        case ';' :retval.token = SEMCOL; break;
        default  :m_parseError = true;   break;   /* invalid character */
        }
        m_token.pos++;
    }

    return retval;
}

void NUMERIC_EVALUATOR::SetVar( const wxString& aString, double aValue )
{
    m_varMap[ aString ] = aValue;
}

double NUMERIC_EVALUATOR::GetVar( const wxString& aString )
{
    if( m_varMap[ aString ] )
        return m_varMap[ aString ];
    else
        return 0.0;
}