/* 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
 */

// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>
#include <deque>
#include <sstream>
#include <map>
#include <math.h>

#include "Variable.hh"
#include "Function.hh"
#include "Word.hh"
#include "Parser_math.hh"
#include "Cmd.hh"
#include "Whenthen.hh"

namespace PP
{
using std::cout;
using std::endl;
using std::string;
using std::deque;
using std::vector;
using std::stringstream;
using std::pair;
using std::ifstream;
using std::ios;


// ===========================================================================
// Default constructor.
// ===========================================================================
Whenthen::Whenthen() 
{
    processed = false;
    seqdex = -1;
    ever_flag = false;
}


// ===========================================================================
// Usual constructor.
// ===========================================================================
Whenthen::Whenthen(int &nwhen, Cmd &cmdi, bool &skipwhen,
                   bool &single_line_when, bool eflag,
                   stringstream &serr, int &ierr)
{
    processed = false;
    seqdex = -1;
    ever_flag = eflag;
    nwhen += 1;
    skipwhen = true;
    single_line_when = false;
    int nwords = cmdi.get_nwords();

    // &&&&&cw
    //stringstream ssprint;
    //cmdi.print_using_words(ssprint);
    //cout << ssprint.str() << endl;

    if (nwords < 7) {
        cmdi.fatal_error(0, serr, ierr);
        serr << "A when command line must have at least 7 words on it (the "
             << endl
             << "opening and closing parenthses each count as a word)"
             << endl;
        serr << "This when command only has " << nwords << " words on it." << endl;
        serr << "Expected something like (this has 7 words):" << endl;
        serr << "    when (time .gt. 5) then" << endl;
        serr << "Or perhaps a single line when like (this has 9 words):" << endl;
        serr << "    when (time .gt. 5) shortmodcyc = 5" << endl;
        ierr = 2;
        return;
    }

    string p1 = cmdi.get_string(1);
    if (p1 != "(") {
        cmdi.fatal_error(1, serr, ierr);
        serr << "Expected an open parentheses following the when keyword."
             << endl;
        serr << "Instead found " << p1 << " following the when keyword."
             << endl;
        serr << "The when command should be something like:" << endl;
        serr << "    when (time .gt. 5) then" << endl;
        serr << "Or perhaps a single line when like:" << endl;
        serr << "    when (time .gt. 5) shortmodcyc = 5" << endl;
        ierr = 2;
        return;
    }


    for (int i=1; i<nwords-1; i++) {
        string t1 = cmdi.get_string(i);
        if (t1 == "then") {
            cmdi.fatal_error(i, serr, ierr);
            serr << "Found a then keyword embedded in the when command."
                 << endl;
            serr << "If a then keyword is present it must be the last "
                 "word on the line." << endl;
            serr << "The when command should be something like:" << endl;
            serr << "    when (time .gt. 5) then" << endl;
            serr << "Or perhaps a single line when like:" << endl;
            serr << "    when (time .gt. 5) shortmodcyc = 5" << endl;
            ierr = 2;
            return;
        }
    }


    // Find the closing parenthesis
    int close_paren_dex = -1;
    for (int i=2; i<nwords; i++) {
        string pi = cmdi.get_string(i);
        if (pi == "then") break;
        if (pi == ")") {
            close_paren_dex = i;
            break;
        }
    }

    if (close_paren_dex == -1) {
        cmdi.fatal_error(0, serr, ierr);
        serr << "Expected a close parentheses following the condition."
             << endl;
        serr << "Did not find a close parentheses." << endl;
        serr << "The when command should be something like:" << endl;
        serr << "    when (time .gt. 5) then" << endl;
        serr << "Or perhaps a single line when like:" << endl;
        serr << "    when (time .gt. 5) shortmodcyc = 5" << endl;
        ierr = 2;
        return;
    }


    int nw = close_paren_dex - 2;
    if ((nw+1)%4 != 0) {
        cmdi.fatal_error(0, serr, ierr);
        serr << "Wrong number of words in the when...then condition."
             << endl;
        serr << "The number of words in this condition is " << nw << endl;
        serr << "The number of words + 1 should be a multiple of 4." << endl;
        serr << "The condition should be something like:" << endl;
        serr << "    time .gt. 5" << endl;
        serr << "This has 3 words and 3+1 is a multiple of 4." << endl;
        serr << "Or the following is valid" << endl;
        serr << "    time .gt. 5 .and. ncycle .ge. 10" << endl;
        serr << "This has 7 words and 7+1 is a multiple of 4." << endl;
        ierr = 2;
        return;
    }

    
    for (int i=2; i<close_paren_dex; i+=4) {
        add_word(cmdi, i,   varname);
        add_word(cmdi, i+1, relation);
        add_word(cmdi, i+2, value);

        if (i+3 < close_paren_dex) add_word(cmdi, i+3, logop);
        else                       add_word(cmdi, i+3, logop, "none");

        satisfied.push_back("false");
    }


    // Check to make sure that the relation is valid.
    for (int n=0; n<(int)varname.size(); n++) {
        bool valid_relation = false;
        if (relation[n].get_string() == ".hglt.") valid_relation = true;
        if (relation[n].get_string() == ".hgle.") valid_relation = true;
        if (relation[n].get_string() == ".hgeq.") valid_relation = true;
        if (relation[n].get_string() == ".hgne.") valid_relation = true;
        if (relation[n].get_string() == ".hggt.") valid_relation = true;
        if (relation[n].get_string() == ".hgge.") valid_relation = true;
        if (relation[n].get_string() == ".lt.") valid_relation = true;
        if (relation[n].get_string() == ".le.") valid_relation = true;
        if (relation[n].get_string() == ".eq.") valid_relation = true;
        if (relation[n].get_string() == ".ne.") valid_relation = true;
        if (relation[n].get_string() == ".gt.") valid_relation = true;
        if (relation[n].get_string() == ".ge.") valid_relation = true;

        if (!valid_relation) {
            relation[n].fatal_error(serr, ierr);
            serr << "Invalid when...then relation." << endl;
            serr << "Expected  .lt., .le., .eq., .ne., .gt., .ge." << endl;
            serr << "Also could be .hglt., .hgle., .hgeq., .hgne., .hggt., .hgge." << endl;
            serr << "Instead found relation:  " << relation[n].get_string() << endl;
            ierr = 2;
            return;
        }
    }


    // Set the has gotten to flags.
    for (int n=0; n<(int)varname.size(); n++) {
        bool hg = false;

        if (relation[n].get_string() == ".hglt.") {
            hg = true;
            relation[n].set_value(".lt.");
        }
        else if (relation[n].get_string() == ".hgle.") {
            hg = true;
            relation[n].set_value(".le.");
        }
        else if (relation[n].get_string() == ".hgeq.") {
            hg = true;
            relation[n].set_value(".eq.");
        }
        else if (relation[n].get_string() == ".hgne.") {
            hg = true;
            relation[n].set_value(".ne.");
        }
        else if (relation[n].get_string() == ".hggt.") {
            hg = true;
            relation[n].set_value(".gt.");
        }
        else if (relation[n].get_string() == ".hgge.") {
            hg = true;
            relation[n].set_value(".ge.");
        }


        has_got.push_back(hg);
    }


    // Handle single line when...then
    if (cmdi.get_string(nwords-1) != "then") {
        single_line_when = true;
        cmdi.delete_words(0, 5);
        cmdi.reset_name_type();
        skipwhen = false;
    }
}


// ===========================================================================
// Add word.
// ===========================================================================
void Whenthen::add_word(Cmd &cmdi, int idex, deque<Word> &wq)
{
    int ln = cmdi.get_line_number(idex);
    int file_ln = cmdi.get_file_line_number(idex);
    string fname = cmdi.get_filename(idex);
    deque<string> *lines = cmdi.get_lines();
    Word w(cmdi.get_string(idex), ln, file_ln, fname, lines);
    wq.push_back(w);
}

void Whenthen::add_word(Cmd &cmdi, int idex, deque<Word> &wq, string sadd)
{
    int ln = cmdi.get_line_number(idex);
    int file_ln = cmdi.get_file_line_number(idex);
    string fname = cmdi.get_filename(idex);
    deque<string> *lines = cmdi.get_lines();
    Word w(sadd, ln, file_ln, fname, lines);
    wq.push_back(w);
}


// ===========================================================================
// Add a command to the deque of commands for this whenthen.
// ===========================================================================
void Whenthen::add_cmdf(Cmd &cmdi)
{
    cmdsf.push_back(cmdi);
}


// ===========================================================================
// This is the check for when the condition is satisfied.
// ===========================================================================
void Whenthen::check_wt(vector<string> &code_varnames,
                        vector<string> &code_values,
                        vector<int> &vv_active,
                        int *wtci, stringstream &serr, int &ierr)
{
    *wtci = 0;
    if (processed) return;

    Parser_math pmath;

    deque<Word> wordsf;

    bool skip_sat = false;
    int num_sub_cond = (int)varname.size();
    for (int n=0; n<num_sub_cond; n++) {
        deque<Word> words;

        if (satisfied[n] == "true") {
            int ln = varname[n].get_line_number();
            int file_ln = varname[n].get_file_line_number();
            string fname = varname[n].get_filename();
            deque<string> *lines = varname[n].get_lines();
            Word w("true", ln, file_ln, fname, lines);
            words.push_back(w);
        }
        else {
            words.push_back(varname[n]);
            words.push_back(relation[n]);
            words.push_back(value[n]);

            process_words(words, code_varnames, code_values, vv_active,
                          serr, ierr);

            if (has_got[n]) {
                if (words[0].get_bool(serr, ierr)) {
                    bool doit = true;
                    if (n > 0) {
                        if (logop[n-1].get_string() == ".andthen." && skip_sat) {
                            doit = false;
                        }
                    }
                    if (doit) satisfied[n] = "true";
                }
                else {
                    skip_sat = true;
                }
            }
        }

        wordsf.push_back(words[0]);
        if (logop[n].get_string() == "none") break;
        else wordsf.push_back(logop[n]);
    }

    process_words(wordsf, code_varnames, code_values, vv_active,
                  serr, ierr);

    // The output value, wtci, defaults to false (0). If the condition
    // is satisfied then the output is true (1). 
    if (wordsf[0].get_bool(serr, ierr)) {
        *wtci = 1;
        if (!ever_flag) processed = true;
        return;
    }
}


// ===========================================================================
// Given a deque of words, go through them evaluating relational and logical
// operators. The words should evaluate to one final word.
// ===========================================================================
void Whenthen::process_words(deque <Word> &words, vector<string> &code_varnames,
                             vector<string> &code_values,
                             vector<int> &vv_active,
                             stringstream &serr, int &ierr)
{
    Parser_math pmath;

    // Replace any code vars with their values.
    int i2 = (int)words.size();
    for (int i=0; i<i2; i++) {
        for (int j=0; j<(int)code_varnames.size(); j++) {
            if (words[i].get_string() == code_varnames[j]) {
                int ln = words[i].get_line_number();
                int file_ln = words[i].get_file_line_number();
                string fname = words[i].get_filename();
                deque<string> *lines = words[i].get_lines();
                if (vv_active[j] == 0) {
                    Word wj("false", ln, file_ln, fname, lines);
                    replace_words(i, i+2, words, wj);
                    i2 -= 2;
                    break;
                }
                else {
                    Word wj(code_values[j], ln, file_ln, fname, lines);
                    words[i] = wj;
                }
            }
        }
    }

    int i1 = 0;
    i2 = (int)words.size() - 1;
    for (int level=6; level>=0; level--) {
        for (int i=i1; i<=i2; i+=1) {
            if (words[i].is_operator(level)) {
                int ln = words[i].get_line_number();
                int file_ln = words[i].get_file_line_number();
                string fname = words[i].get_filename();
                deque<string> *lines = words[i].get_lines();
                Word w("", ln, file_ln, fname, lines);

                string op_type = words[i].get_op_type();

                if (op_type == "relational") {
                    pmath.do_op_relational(i-1, i, i+1, words, w, serr, ierr);
                }

                if (op_type == "logical" && level == 2)   // .not. is unary
                    pmath.do_op_not(i, i+1, words, w, serr, ierr);

                if (op_type == "logical" && level != 2)
                    pmath.do_op_logical(i-1, i, i+1, words, w, serr, ierr);

                // level 2, .not., is unary and is handled differently.
                if (level == 2) {
                    replace_words(i, i+1, words, w);
                    i2 -= 1;
                }
                else {
                    replace_words(i-1, i+1, words, w);
                    i2 -= 2;
                    i -= 1;
                }
                continue;
            }
        }
    }

    // The condition has to evaluate to a single boolean value.
    if ((int)words.size() != 1) {
        words[0].fatal_error(serr, ierr);
        serr << "When...then condition did not evaluate to a single boolean value."
             << endl;
        serr << "Fix the when...then condition" << endl;
        ierr = 2;
    }
}


// ===========================================================================
// ===========================================================================
void Whenthen::get_char_array_size(int *ca_size)
{
    string sc;
    get_char_array(sc);
    (*ca_size) = (int)sc.size();
}


// ===========================================================================
// ===========================================================================
void Whenthen::get_char_array(string &sc)
{
    for (int n=0; n<(int)varname.size(); n++) {
        sc += varname[n].get_string();
        sc += relation[n].get_string();
        sc += value[n].get_string();
        sc += logop[n].get_string();
        if (has_got[n]) sc += "hasgot";
    }
    for (int n=0; n<(int)cmdsf.size(); n++) {
        int nw = cmdsf[n].get_nwords();
        for (int i=0; i<nw; i++) {
            sc += cmdsf[n].get_string(i);
        }
    }
}


// ===========================================================================
// ===========================================================================
void Whenthen::get_satsize(int *sat_size)
{
    (*sat_size) = (int)satisfied.size();
}


// ===========================================================================
// Get and Set the satisfied flags.
// ===========================================================================
void Whenthen::getsat(int *sat)
{
    for (int i=0; i<(int)satisfied.size(); i++) {
        if (satisfied[i] == "true")  sat[i] = 1;
        if (satisfied[i] == "false") sat[i] = 0;
    }
}

void Whenthen::setsat(int *sat)
{
    for (int i=0; i<(int)satisfied.size(); i++) {
        if (sat[i] == 1) satisfied[i] = "true";
        if (sat[i] == 0) satisfied[i] = "false";
    }
}


// ===========================================================================
// Get and Set the processed flag for a whenthen.
// ===========================================================================
void Whenthen::getprocessed(int *wtp)
{
    *wtp = 0;
    if (processed) *wtp = 1;
}

void Whenthen::setprocessed(int wtp)
{
    processed = false;
    if (wtp == 1) processed = true;
}


// ===========================================================================
// Get and Set the sequence index.
// ===========================================================================
void Whenthen::getseq(int *wtseq)
{
    *wtseq = seqdex;
}

void Whenthen::setseq(int wtseq)
{
    seqdex = wtseq;
}


// ===========================================================================
// List the final commands deque for this whenthen to a stringstream.
// This is done to let the user know what the final commands are. It is
// also useful for debugging.
// ===========================================================================
void Whenthen::list_cmdsf_ss(stringstream &ssc)
{
    for (int i=0; i<(int)cmdsf.size(); i++) {
        ssc << "        ";
        cmdsf[i].print_using_words_fm(ssc);
        ssc << endl;
    }
}


// ===========================================================================
// List the condition for this whenthen to a stringstream.
// This is done to let the user indentify this whenthen. It is
// also useful for debugging.
// ===========================================================================
void Whenthen::list_condition(string offset1, string offset2,
                              stringstream &ssc)
{
    for (int n=0; n<(int)varname.size(); n++) {

        string relstr = relation[n].get_string();
        string rstr = relstr;
        if (has_got[n]) {
            if (relstr == ".lt.") rstr = ".hglt.";
            if (relstr == ".le.") rstr = ".hgle.";
            if (relstr == ".eq.") rstr = ".hgeq.";
            if (relstr == ".ne.") rstr = ".hgne.";
            if (relstr == ".gt.") rstr = ".hggt.";
            if (relstr == ".ge.") rstr = ".hgge.";
        }
        relstr = rstr;

        string offset = offset1;
        if (n > 0) offset = offset2;

        ssc << offset << varname[n].get_string() << " "
            << relstr << " " << value[n].get_string();

        if (logop[n].get_string() == "none") break;
        ssc << " " << logop[n].get_string();
        ssc << endl;
    }
}


// ===========================================================================
// Delete words i1 through i2 inclusive from the deque.
// ===========================================================================
void Whenthen::delete_words(int i1, int i2, deque <Word> &words)
{
    deque<Word>::iterator p = words.begin();
    words.erase(p + i1, p + i2 + 1);
}


// ===========================================================================
// Replace words i1 through i2 inclusive with word w.
// ===========================================================================
void Whenthen::replace_words(int i1, int i2, deque <Word> &words, Word &w)
{
    delete_words(i1, i2, words);
    deque<Word>::iterator p = words.begin();
    words.insert(p + i1, w);
}


} // End of the PP namespace