/* Copyright 2015.  Los Alamos National Security, LLC. This material was produced
 * under U.S. Government contract DE-AC52-06NA25396 for Los Alamos National 
 * Laboratory (LANL), which is operated by Los Alamos National Security, LLC
 * for the U.S. Department of Energy. The U.S. Government has rights to use,
 * reproduce, and distribute this software.  NEITHER THE GOVERNMENT NOR LOS
 * ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
 * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE.  If software is modified
 * to produce derivative works, such modified software should be clearly marked,
 * so as not to confuse it with the version available from LANL.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy
 * of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed
 * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * Under this license, it is required to include a reference to this work. We
 * request that each derivative work contain a reference to LANL Copyright
 * Disclosure C15076/LA-CC-15-054 so that this work's impact can be roughly
 * measured.
 *
 * This is LANL Copyright Disclosure C15076/LA-CC-15-054
 */

/*
 *  PowerParser is a general purpose input file parser for software applications.
 *
 *  Authors: Chuck Wingate   XCP-2   caw@lanl.gov
 *           Robert Robey    XCP-2   brobey@lanl.gov
 */

#ifndef WORDHHINCLUDE
#define WORDHHINCLUDE

// ***************************************************************************
// ***************************************************************************
// This class holds each word from the line.
// ***************************************************************************
// ***************************************************************************

#include <string>
#include <sstream>
#include <vector>
#include <map>
#include <deque>
#include <stdint.h>

namespace PP
{
using std::string;
using std::stringstream;
using std::vector;
using std::map;
using std::deque;

enum WordType {WUNKNOWN, WSTRING, INTEGER, DOUBLE, EQUALS, OPERATOR,
               OPEN_PARENS, CLOSED_PARENS,
               OPEN_SQUARE_BRACKET, CLOSED_SQUARE_BRACKET,
               OPEN_BRACE, CLOSED_BRACE,
               COMMA, VARIABLE};

class Word
{

public:
    Word();
    Word(string s);
    Word(string s, int lnum, int file_lnum, string fname,
         deque<string> *lstr);
    Word(double d, int lnum, int file_lnum, string fname,
         deque<string> *lstr);
    Word(int ia, int lnum, int file_lnum, string fname,
         deque<string> *lstr);
    Word operator=(const Word &);
    Word(const Word &);
    ~Word();

    // Given a word, change its value.
    void set_value(double d);
    void set_value(string s);
    void set_value(const char *s);
    void set_value(bool b);

    // Print the type of word to a stringstream.
    void print_type(stringstream &ss);

    // Set the type of word.
    void set_type();

    // Get the operator type, arithmetic, relational, ...
    string get_op_type() {return op_type;}

    bool is_operator() { if (type == OPERATOR) return true; return false; }

    bool is_operator(int level) {
        if (type != OPERATOR) return false;
        if (level == op_level) return true;
        return false;
    }

    bool is_bool();

    bool is_string()   { if (type == WSTRING)  return true; return false; }

    bool is_integer()  { if (type == INTEGER) return true; return false; }

    bool is_number()   { if (type == INTEGER || type == DOUBLE) return true;
                         return false; }

    bool is_numvar()   { if (type == INTEGER || type == DOUBLE ||
                             type == VARIABLE) return true;
                         return false; }

    bool has_value()   { if (type == INTEGER || type == DOUBLE) return true;
                         return false; }

    bool is_variable() { if (type == VARIABLE) return true; return false; }

    bool is_comma()    { if (type == COMMA) return true; return false; }

    /*! \brief Get the word as a string. */
    string get_string()    { return wstr; }
    string get_print_string(bool enc_quotes);
    string get_stringp()   { processed=true; return wstr; }
    char get_single_char(stringstream &serr, int &ierr);

    /*! \brief Get the word as a float. */
    float get_float();

    /*! \brief Get the word as a double. */
    double get_double();
    double get_double(stringstream &serr, int &ierr);

    // Get the word as an int, without and with error processing.
    int get_int();
    int get_int(stringstream &serr, int &ierr);

    int64_t get_int64_t();
    int64_t get_int64_t(stringstream &serr, int &ierr);

    /*! \brief Get the word as a boolean. */
    bool get_bool(stringstream &serr, int &ierr);

    /*! \brief Templated get method for get_double, get_int, etc. */
    template< class T >
    T get_val( T &dummy );

    /*!
     * \brief Convert string s to the type of the first argument.  Function
     * returns the converted value as a reference and as the function
     * result. 
     *
     * These overloaded functions are the base for the templated accessor
     * functions "get_val()".
     *
     * \param rtti - Convert the string s into the type of rtti and return it.
     */
    int     convertFromString ( const int     &rtti, const string &s ) const; 
    int64_t convertFromString ( const int64_t &rtti, const string &s ) const; 
    string  convertFromString ( const string  &rtti, const string &s ) const;
    float   convertFromString ( const float   &rtti, const string &s ) const;
    double  convertFromString ( const double  &rtti, const string &s ) const;
    //bool    convertFromString ( const bool   &rtti, const string &s ) const;

    /*! \brief Negate the word or set a flag to negate it later. */
    void negate_value();

    // Handle errors.
    void fatal_error(stringstream &serr, int &ierr);
    void warning(stringstream &serr, int &ierr);

    // Miscellaneous functions.
    void handle_quotes(stringstream &serr, int &ierr);
    void erase_char(int ic);

    // Accessor methods.
    void   set_word(string str)    { wstr = str; }
    void   set_processed(bool p)   { processed = p; }
    bool   get_processed()         { return processed; }
    int    get_line_number()       { return line_number; }
    int    get_file_line_number()  { return file_line_number; }
    string get_filename()          { return filename; }
    deque<string> *get_lines()     { return lines; }
    void   set_filename(string fn) { filename = fn; }
    int    get_multiplicity()      { return multiplicity; }
    void   set_multiplicity(int m) { multiplicity = m; }

private:
    void init();
    bool check_before_e(string s, int i1, int i2);
    bool check_after_e(string s, int i1, int i2);

    // This is the basic storage for the word.
    string wstr;

    // The type of word, like operator, string, variable, etc.
    WordType type;

    // Flag for testing whether this word was processed or not.
    bool processed;

    // Flag to negate a variable.
    bool negate;

    // This word is repeated multiplicity times.
    int multiplicity;

    // If the word is an operator, then this is its level, i.e. "**" has
    // the highest level, then "*","/", etc.
    int op_level;

    // The operator type, arithmetic, relational, ...
    string op_type;

    // Convert the input string to lower case.
    void string_to_lower( string &s ) const;

    // This is needed for telling the user what line in the input
    // file or include file the error occurred on.
    //
    // line_number  The line_number corresponding to this command, this is
    //              an index into lines and starts from 1, not 0.
    // lines        Pointer to the deque of original lines. This contains all
    //              the lines from the input file and any include files.
    // file_line_number  The line number in the input file or include file.
    // filename          The name of the input file or include file.
    //
    // file_line_number and filename are needed to that the user can open
    // the file and go to the line in error.
    int line_number, file_line_number;
    string filename;
    deque<string> *lines;
    
};


} // end of PP namespace

#endif