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

// ***************************************************************************
// ***************************************************************************
// Restart Blocks
// Run the code until a restart block condition is satisfied. Set the restart
// block as active, write a restart dump, stop the code, and restart.
// ***************************************************************************
// ***************************************************************************
#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 "Restartblock.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.
// ===========================================================================
Restartblock::Restartblock() 
{
    active = -1;
}

// ===========================================================================
// Usual constructor.
//    restart_block name (time .eq. 50) then
// ===========================================================================
Restartblock::Restartblock(int &nrb, Cmd &cmdi, bool &skiprb,
                           bool &single_line_rb,
                           deque<string> &bnames_on_dump,
                           deque<bool> &baflags_on_dump,
                           deque<int> &rbsatprb_on_dump,
                           deque<bool> &rbsat_on_dump,
                           stringstream &serr, int &ierr)
{
    //cout << "&&&&&cw ********** Restartblock.cc, Enter Constructor **********" << endl;
    active = -1;
    nrb += 1;
    skiprb = true;
    single_line_rb = false;
    int nwords = cmdi.get_nwords();

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

    if (nwords < 8) {
        cmdi.fatal_error(0, serr, ierr);
        serr << "A restart block line must have at least 8 words on it (the "
             << endl
             << "opening and closing parentheses each count as a word)"
             << endl;
        serr << "This restart block command only has " << nwords <<
            " words on it." << endl;
        serr << "Expected something like (this has 8 words):" << endl;
        serr << "    restart_block after5 (time .gt. 5) then" << endl;
        serr << "Or perhaps a single line restart block like (this has 13 words):"
             << endl;
        serr << "    restart_block after5 (time .gt. 5) sizemat(2) = 0.005" << endl;
        ierr = 2;
        return;
    }

    string p2 = cmdi.get_string(2);
    if (p2 != "(") {
        cmdi.fatal_error(2, serr, ierr);
        serr << "Expected an open parentheses following the restart block name.."
             << endl;
        serr << "Instead found " << p2 << " following the restart block name."
             << endl;
        serr << "The restart block command should be something like:" << endl;
        serr << "    restart_block t_is_gt_5 (time .gt. 5) then" << endl;
        serr << "Or perhaps a single line restart block like:" << endl;
        serr << "    restart_block t_is_gt_5 (time .gt. 5) sizemat(2) = 0.005" << 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 restart_block command."
                 << endl;
            serr << "If a then keyword is present it must be the last "
                 "word on the line." << endl;
            serr << "The restart_block command should be something like:" << endl;
            serr << "    restart_block t_is_gt_5 (time .gt. 5) then" << endl;
            serr << "Or perhaps a single line restart block like:" << endl;
            serr << "    restart_block t_is_gt_5 (time .gt. 5) sizemat(2) = 0.005" << 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 restart_block command should be something like:" << endl;
        serr << "    restart_block t_is_gt_5 (time .gt. 5) then" << endl;
        serr << "Or perhaps a single line restart block like:" << endl;
        serr << "    restart_block t_is_gt_5 (time .gt. 5) sizemat(2) = 0.005" << endl;
        ierr = 2;
        return;
    }


    int nw = close_paren_dex - 3;
    if ((nw+1)%4 != 0) {
        cmdi.fatal_error(0, serr, ierr);
        serr << "Wrong number of words in the restart_block 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=3; 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 restart_block 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;
        }
    }

    // The name of the restart block is the second word on the
    // restart_block command.
    name = cmdi.get_string(1);
    //cout << "&&&&&cw Restartblock.cc, name1 = " << name << endl;
    //cout << "&&&&&cw Restartblock.cc, satsize = " << satisfied.size() << endl;

    // If this is a restart, then restart block names and active flags
    // could be stored on the restart dump. If this restart block matches
    // any stored on the dump, then set the active flag to what is on
    // the dump.
    for (int i=0; i<(int)bnames_on_dump.size(); i++) {
        //cout << "&&&&&cw Restartblock.cc, name = " << name << endl;
        //cout << "&&&&&cw Restartblock.cc, bnames_on_dump = " << 
        //    bnames_on_dump[i] << endl;
        //cout << "&&&&&cw Restartblock.cc, baflags_on_dump = " << 
        //    baflags_on_dump[i] << endl;
        if (name == bnames_on_dump[i]) {
            active = 0;
            if (baflags_on_dump[i]) active = 1;

            int satdex = 0;
            for (int j=0; j<i; j++) {
                satdex += rbsatprb_on_dump[j];
            }
            for (int j=satdex; j<satdex+rbsatprb_on_dump[i]; j++) {
                string s = "false";
                if (rbsat_on_dump[j]) s = "true";
                satisfied[j-satdex] = s;
            }

            break;
        }
    }
    //cout << "&&&&&cw Restartblock.cc, after set restart" << endl;


    // If this restart block is active, that means we want to process
    // the commands in the block, therefore we set the skip flag to false.
    if (active == 1) skiprb = false;


    // 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 restart_block
    if (cmdi.get_string(nwords-1) != "then") {
        single_line_rb = true;
        cmdi.delete_words(0, 5);
        cmdi.reset_name_type();
    }
    //cout << "&&&&&cw ********** Restartblock.cc, Exit Constructor **********" << endl;
}


// ===========================================================================
// Add word to the deque wq.
// ===========================================================================
void Restartblock::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 Restartblock::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);
}


// ===========================================================================
// This is the check for when the condition is satisfied.
// ===========================================================================
void Restartblock::check_rb(vector<string> &code_varnames,
                            vector<string> &code_values,
                            vector<int> &vv_active, int *rbci,
                            stringstream &serr, int &ierr)
{
    *rbci = 0;
    //if (active==1) 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);

    // rbci is an output flag telling the code to write a dump and end
    // the calculation or not. rbci=0 means do not end the calc,
    // rbci=1 tells the code to end the calc.
    // Basically, if the condition changes from its previous value, then
    // set rbci to 1.

    // This is the current value of the condition that was calculated above.
    bool b = wordsf[0].get_bool(serr, ierr);

    // *rcbi is the key output result from this function
    //     *rbci = 0    Calling code does nothing
    //     *rbci = 1    Calling code stops calculation, normally does restart
    *rbci = 0;

    // Here we check to see if the condition has changed, i.e. is b different
    // from the active flag. If so, then we end the calculation.
    // When the restart block is first created, the active flag is set to -1,
    // this is for runs from scratch.
    // If this is a restart, then the active flag will come from the dump and
    // be either 0 or 1.
    // So if active is -1 and the condition is true, then we end the calculation
    // right away (this should not be common, but could happen).
    //
    // Changed on 7/2/10 - The original idea for restart blocks was that they
    // would trigger when the condition changed from false to true. But they
    // would also trigger when the condition changed back from true to false.
    // This causes problems for the users when the restart block would
    // repeatedly trigger because the condition oscillates between true and
    // false. Therefore, change the restart blocks so they trigger once and
    // only once (which happens when the condition first becomes true). If
    // the users ever need a restart block that also triggers when the
    // condition changes from true to false, then some
    // sort of option could be put in to allow this.
    if (b  && active == -1) { *rbci = 1; active = 1; return; }   // Trigger
    if (b  && active ==  0) { *rbci = 1; active = 1; return; }   // Trigger
    if (b  && active ==  1) { *rbci = 0;             return; }   // Do nothing
    if (!b && active == -1) { *rbci = 0; active = 0; return; }   // Do nothing
    if (!b && active ==  0) { *rbci = 0;             return; }   // Do nothing

    // This is the true to false trigger that causes problems.
    //if (!b && active ==  1) { *rbci = 1; active = 0; return; }   // Trigger
}


// ===========================================================================
// Given a deque of words, go through them evaluating relational and logical
// operators. The words should evaluate to one final word.
// ===========================================================================
void Restartblock::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 << "restart_block condition did not evaluate to a single boolean value."
             << endl;
        serr << "Fix the restart_block condition" << endl;
        ierr = 2;
    }
}


// ===========================================================================
// List the condition for this restart block to a stringstream.
// This is done to let the user indentify this restart block. It is
// also useful for debugging.
// ===========================================================================
void Restartblock::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 Restartblock::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 Restartblock::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