/*
PseudoCode Interpreted Language (PCIL):  Part of the algoviz@vt collection of algorithm visualizations.
Copyright (C) 2008  Brandon Malone, Frank Hadlock

This file is part of the PseudoCode Interpreted Language.

PseudoCode Interpreted Language 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.

PseudoCode Interpreted Language 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
PseudoCode Interpreted Language.  If not, see
<http://www.gnu.org/licenses/>.
*/

/*
 * Grammar.java
 *
 * Created on March 2, 2008, 7:17 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
package syntacticanalysis;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;

/**
 *
 * @author Brandon
 */
public class Grammar {
    // grammar consists of a start symbol
    private GrammarToken startSymbol;    // list of rules
    private ArrayList<GrammarRule> rules;    // terminals
    private ArrayList<Terminal> terminals;    // nonterminals
    private ArrayList<Nonterminal> nonterminals;    // action symbols
    private ArrayList<ActionSymbol> actionSymbols;
    HashMap<GrammarToken, ArrayList<GrammarToken>> first;
    HashMap<GrammarToken, ArrayList<GrammarToken>> follow;
    ArrayList<ArrayList<GrammarToken>> rulesSignature;
    HashMap<ParseEntry, GrammarRule> parseTable;

    
    public static Grammar createFromFile() throws IOException {
        
        Grammar g = new Grammar(grammarString);

        FirstCalculator.constructFirsts(g);
        FollowCalculator.constructFollows(g);
        SignatureCalculator.constructSignatures(g);
        ParseTableCalculator.constructParseTable(g);

        return g;
    }
    
    public static Grammar createFromFile(String grammarFilePath) throws IOException {
        // open the source file
        BufferedReader br = new BufferedReader(new FileReader(grammarFilePath));

        // read the grammar file
        String grammar = readFile(br);

        Grammar g = new Grammar(grammar);

        // close the source file
        br.close();

        FirstCalculator.constructFirsts(g);
        FollowCalculator.constructFollows(g);
        SignatureCalculator.constructSignatures(g);
        ParseTableCalculator.constructParseTable(g);

        return g;
    }

    public static Grammar createFromFile(String grammarFilePath, String parseTablePath) throws IOException {
        Grammar g = createFromFile(grammarFilePath);

        BufferedReader br = new BufferedReader(new FileReader(parseTablePath));

        // read the parseTable file
        String parseTable = readFile(br);

        br.close();

        g.setParseTable(parseTable);

        return g;
    }

    public static String readFile(BufferedReader br) throws IOException {
        StringBuilder sb = new StringBuilder();

        String line = br.readLine();

        while (line != null) {
            sb.append(line);
            sb.append("\n");

            line = br.readLine();
        }

        return sb.toString();
    }

    /** Creates a new instance of Grammar */
    public Grammar(String grammar) {
        setRules(new ArrayList<GrammarRule>());
        setNonterminals(new ArrayList<Nonterminal>());
        setTerminals(new ArrayList<Terminal>());
        setActionSymbols(new ArrayList<ActionSymbol>());

        // find the start state
        StringBuilder g = new StringBuilder();
        g.append(grammar);

        setStartState(g);

        while (g.length() > 0) {
            findRule(g);
        }

        for (GrammarRule rule : rules) {
            checkRule(rule);
        }
    }

    private void setStartState(StringBuilder grammar) {
        // the first line should be: "StartState: <s>"
        int start = grammar.indexOf("<");
        int end = grammar.indexOf(">");
        String startName = grammar.substring(start + 1, end);

        setStartSymbol(new Nonterminal(startName));

        // strip off the line

        // also grab the new line
        grammar.replace(0, end + 2, "");
    }

    private void findRule(StringBuilder grammar) {
        // assume each rule is on a line
        int index = grammar.indexOf("\n");
        String rule = grammar.substring(0, index);

        if (rule.startsWith("<")) {
            getRules().add(new GrammarRule(rule));
        } else {
            boolean br = true;
        }

        // add one to also remove the new line
        grammar.replace(0, index + 1, "");

    }

    private void checkRule(GrammarRule rule) {
        // check the lhs
        if (!getNonterminals().contains(rule.getLhs())) {
            getNonterminals().add(rule.getLhs());
        }

        // check the rhs
        for (GrammarToken t : rule.getRhs()) {
            if (t instanceof Terminal) {
                if (!getTerminals().contains(t)) {
                    getTerminals().add((Terminal) t);
                }
            }

            if (t instanceof Nonterminal) {
                if (!getNonterminals().contains(t)) {
                    getNonterminals().add((Nonterminal) t);
                }
            }

            if (t instanceof ActionSymbol) {
                if (!getActionSymbols().contains(t)) {
                    getActionSymbols().add((ActionSymbol) t);
                }
            }
        }
    }

    public void setParseTable(String parseTable) {
        this.setParseTable(new HashMap<ParseEntry, GrammarRule>());

        StringBuilder sb = new StringBuilder();
        sb.append(parseTable);

        // assume of the form: <Program>~[input]~0
        int index = sb.indexOf("\n");

        while (index > -1) {
            // read the next parse entry
            String line = sb.substring(0, index);
            ParseEntry parseEntry = new ParseEntry(line);

            // find the rule
            GrammarRule rule = getRules().get(parseEntry.getRuleIndex());

            // add to the parse table
            this.getParseTable().put(parseEntry, rule);

            // strip off the entry
            sb.replace(0, index + 1, "");
            index = sb.indexOf("\n");
        }
    }

    public GrammarRule determineRule(Nonterminal sententialFormToken, Terminal sourceToken) {
        ParseEntry entry = new ParseEntry(sourceToken, sententialFormToken);
        GrammarRule r = getParseTable().get(entry);

        // HACK FIX
        if (r == null && sourceToken.name.equals("=")) {
            // try changing the type to [relationalOperator]
            sourceToken.name = "relationalOperator";

            entry = new ParseEntry(sourceToken, sententialFormToken);
            r = getParseTable().get(entry);
        }

        return r;
    }

    public void toFile(String filePath) throws IOException {
        PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(filePath)));

        pw.print(toString());

        pw.close();
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();

        sb.append("Start State:");
        sb.append(getStartSymbol().toString());
        sb.append("\n");

        for (GrammarRule rule : rules) {
            sb.append(rule.toString());
            sb.append("\n");
        }

        return sb.toString();
    }

    public void parseTableToFile(String filePath) throws IOException {
        PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(filePath)));

        pw.print(parseTableToString());

        pw.close();
    }

    public String parseTableToString() {
        StringBuilder sb = new StringBuilder();

        for (ParseEntry entry : getParseTable().keySet()) {
            sb.append(entry.toString());
            sb.append("\n");
        }

        return sb.toString();
    }

    public GrammarToken getStartSymbol() {
        return startSymbol;
    }

    public void setStartSymbol(GrammarToken startSymbol) {
        this.startSymbol = startSymbol;
    }

    public ArrayList<GrammarRule> getRules() {
        return rules;
    }

    public void setRules(ArrayList<GrammarRule> rules) {
        this.rules = rules;
    }

    public ArrayList<Terminal> getTerminals() {
        return terminals;
    }

    public void setTerminals(ArrayList<Terminal> terminals) {
        this.terminals = terminals;
    }

    public ArrayList<Nonterminal> getNonterminals() {
        return nonterminals;
    }

    public void setNonterminals(ArrayList<Nonterminal> nonterminals) {
        this.nonterminals = nonterminals;
    }

    public ArrayList<ActionSymbol> getActionSymbols() {
        return actionSymbols;
    }

    public void setActionSymbols(ArrayList<ActionSymbol> actionSymbols) {
        this.actionSymbols = actionSymbols;
    }

    public HashMap<ParseEntry, GrammarRule> getParseTable() {
        return parseTable;
    }

    public void setParseTable(HashMap<ParseEntry, GrammarRule> parseTable) {
        this.parseTable = parseTable;
    }
    protected static String grammarString = "Start Symbol:<Program>\n" +
            "<Program>-><InputDeclarations>{24}{26}<MainStatementList><FunctionDeclarations>\n" +
            "<InputDeclarations>->[#]\n" +
            "<InputDeclarations>-><InputDeclaration>[nl]{1}{27}<InputDeclarations>\n" +
            "<InputDeclaration>->[input][=]{2}<InputList>\n" +
            "<InputList>->[variableName][variableName]{3}<RestOfInputList>\n" +
            "<RestOfInputList>->[#]\n" +
            "<RestOfInputList>->[,]{1}<InputList>\n" +
            "<MainStatementList>-><StatementList>\n" +
            "<StatementList>-><Statement>[nl]{1}{24}<StatementList>\n" +
            "<StatementList>->[#]\n" +
            "<Statement>-><Initialize>\n" +
            "<Statement>-><Assignment>\n" +
            "<Statement>-><IfBlock>\n" +
            "<Statement>-><WhileLoop>\n" +
            "<Statement>-><ForEachLoop>\n" +
            "<Statement>-><FunctionCall>\n" +
            "<Statement>-><Return>\n" +
            "<Statement>-><Say>\n" +
            "<Statement>-><Finish>\n" +
            "<Statement>-><Ask>\n" +
            "<Initialize>->[initialize]{1}<InitializeList>\n" +
            "<InitializeList>->[variableName][as][variableName]{4}<RestOfInitializeList>\n" +
            "<RestOfInitializeList>->[,]{1}<InitializeList>\n" +
            "<RestOfInitializeList>->[#]\n" +
            "<Assignment>->{22}<VariableName>[=]<Expression>{5}\n" +
            "<IfBlock>->[if]<Expression>[then][nl]{6}{24}<StatementList><RestOfIfBlock>\n" +
            "<RestOfIfBlock>->[else][nl]{7}{24}<StatementList>[endIf]{1}{31}\n" +
            "<RestOfIfBlock>->[endIf]{1}{31}\n" +
            "<WhileLoop>->{39}[while]{40}<Expression>[nl]{8}{24}<StatementList>[endWhile]{41}{9}\n" +
            "<ForEachLoop>->{30}[forEach][variableName][in]{32}<Expression>[nl]{10}{29}{24}<StatementList>[next]{11}\n" +
            "<FunctionCall>->[call]{22}<VariableName>{28}\n" +
            "<Return>->[return]<Expression>{21}\n" +
            "<Say>->[say][(]<Expression>[)]{25}\n" +
            "<Finish>->[finish]{1}{33}\n" +
            "<Ask>->[ask][:]{38}<Statement>\n" +
            "<Expression>-><Augend><Addend><RestOfExpression>\n" +
            "<Augend>->{22}<Multiplicand><Multiplier>\n" +
            "<Multiplier>->[#]\n" +
            "<Multiplier>->[*/]<Augend>{12}\n" +
            "<Multiplicand>-><VariableName>\n" +
            "<Multiplicand>->[(]{1}<Expression>[)]{36}\n" +
            "<Addend>->[#]\n" +
            "<Addend>->[+-]<Expression>{13}\n" +
            "<RestOfExpression>->[#]\n" +
            "<RestOfExpression>->[or]<Expression>{34}\n" +
            "<RestOfExpression>->[and]<Expression>{35}\n" +
            "<RestOfExpression>->[relationalOperator]<Expression>{14}\n" +
            "<VariableName>->[variableName]{15}<RestOfVariableName>\n" +
            "<VariableName>->[constant]{23}<RestOfVariableName>\n" +
            "<RestOfVariableName>->[#]{16}\n" +
            "<RestOfVariableName>->[.]{17}<VariableName>\n" +
            "<RestOfVariableName>->[(]<ParameterList>[)]{18}<RestOfVariableName>\n" +
            "<ParameterList>-><Expression><RestOfParameterList>\n" +
            "<ParameterList>->[#]\n" +
            "<RestOfParameterList>->[#]\n" +
            "<RestOfParameterList>->[,]<ParameterList>\n" +
            "<FunctionDeclarations>->[nl]<FunctionDeclarations>\n" +
            "<FunctionDeclarations>->[#]\n" +
            "<FunctionDeclarations>-><FunctionDeclaration><FunctionDeclarations>\n" +
            "<FunctionDeclaration>->[function][variableName][(]{19}<FormalParameterList>[)][nl]{20}{24}<StatementList>[endFunction]\n" +
            "<FormalParameterList>->[variableName][variableName]<RestOfFormalParameterList>\n" +
            "<RestOfFormalParameterList>->[,]<FormalParameterList>\n" +
            "<RestOfFormalParameterList>->[#]\n" +
            "<FormalParameterList>->[#]\n";
    
//"<Ask>->[ask][:]{38}<Statement>{37}\n" +
}