/* 
 * File:   PgclParser.h
 * Author: Lukas Westhofen
 *
 * Created on 1. April 2015, 19:12
 */

#ifndef PGCLPARSER_H
#define	PGCLPARSER_H

// Includes files for file input.
#include <fstream>
#include <memory>
#include <iomanip>
// Includes files for building and parsing the PGCL program
#include "src/parser/SpiritParserDefinitions.h"
#include "src/parser/ExpressionParser.h"
#include "src/storage/expressions/ExpressionManager.h"
#include "src/storage/expressions/Expression.h"
#include "src/storage/pgcl/PgclProgram.h"
#include "src/storage/pgcl/AssignmentStatement.h"
#include "src/storage/pgcl/BooleanExpression.h"
#include "src/storage/pgcl/UniformExpression.h"
#include "src/storage/pgcl/IfStatement.h"
#include "src/storage/pgcl/LoopStatement.h"
#include "src/storage/pgcl/NondeterministicBranch.h"
#include "src/storage/pgcl/ObserveStatement.h"
#include "src/storage/pgcl/ProbabilisticBranch.h"
#include "src/storage/pgcl/Statement.h"

namespace storm {
    namespace parser {
        
        class PgclParser : public qi::grammar<Iterator, storm::pgcl::PgclProgram(), Skipper> {
        public:
            /*!
             * Parses the given file into the PGCL storage classes in case it
             * complies with the PGCL syntax.
             *
             * @param filename the name of the file to parse.
             * @return The resulting PGCL program.
             */
            static storm::pgcl::PgclProgram parse(std::string const& filename);
            
            /*!
             * Parses the given input stream into the PGCL storage classes in
             * case it complies with the PGCL syntax.
             *
             * @param input The input string to parse.
             * @param filename Name of the file from which the input was read.
             * @return The resulting PGCL program.
             */
            static storm::pgcl::PgclProgram parseFromString(std::string const& input, std::string const& filename);
        private:
            // Internal constructor used by the parseFromString function.
            PgclParser(std::string const& filename, Iterator first);
            // Nonterminals (and their semantic types) of the PGCL grammar.
            qi::rule<Iterator, storm::pgcl::PgclProgram(), Skipper> program;
            qi::rule<Iterator, std::vector<std::shared_ptr<storm::pgcl::Statement> >(), Skipper> sequenceOfStatements;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::Statement>(), Skipper> statement;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::Statement>(), Skipper> simpleStatement;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::Statement>(), Skipper> compoundStatement;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::IfStatement>(), Skipper> ifElseStatement;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::BranchStatement>(), Skipper> branchStatement;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::LoopStatement>(), Skipper> loopStatement;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::NondeterministicBranch>(), Skipper> nondeterministicBranch;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::ProbabilisticBranch>(), Skipper> probabilisticBranch;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::AssignmentStatement>(), Skipper> assignmentStatement;
            qi::rule<Iterator, storm::expressions::Variable(), Skipper> declaration;
            qi::rule<Iterator, storm::expressions::Variable(), Skipper> doubleDeclaration;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::AssignmentStatement>(), Skipper> integerDeclarationStatement;
            qi::rule<Iterator, std::shared_ptr<storm::pgcl::ObserveStatement>(), Skipper> observeStatement;
            qi::rule<Iterator, storm::expressions::Expression(), Skipper> expression;
            qi::rule<Iterator, storm::pgcl::BooleanExpression(), Skipper> booleanCondition;
            qi::rule<Iterator, storm::pgcl::UniformExpression(), Skipper> uniformExpression;
            qi::rule<Iterator, std::string(), Skipper> variableName;
            qi::rule<Iterator, std::string(), Skipper> programName;

            /// Denotes the invalid identifiers, which are later passed to the expression parser.
            struct keywordsStruct : qi::symbols<char, uint_fast64_t> {
                keywordsStruct() {
                    add
                    ("while", 1)
                    ("if", 2)
                    ("observe", 3)
                    ("int", 4)
                    ("function", 5);
                }
            };

            /// Initializes the invalid identifier struct.
            keywordsStruct invalidIdentifiers;
            /// Is used to store the identifiers of the PGCL program that are found while parsing.
            qi::symbols<char, storm::expressions::Expression> identifiers_;

            /// Functor used for annotating entities with line number information.
            class PositionAnnotation {
            public:
                typedef void result_type;

                PositionAnnotation(Iterator first) : first(first) {
                    // Intentionally left empty.
                }

                template<typename Entity, typename First, typename Last>
                result_type operator()(Entity& entity, First f, Last l) const {
                    entity.setLineNumber(get_line(f));
                }
            private:
                std::string filename;
                Iterator const first;
            };

            /// A function used for annotating the entities with their position.
            phoenix::function<PositionAnnotation> annotate;

            /// Manages the expressions and their parsing externally.
            std::shared_ptr<storm::expressions::ExpressionManager> expressionManager;
            storm::parser::ExpressionParser expressionParser;

            /// Stores a mapping from location numbers to statements.
            std::vector<std::shared_ptr<storm::pgcl::Statement> > locationToStatement;

            /// Saves whether a loop statements was created.
            bool loopCreated    = false;
            /// Saves whether a nondet statements was created.
            bool nondetCreated  = false;
            /// Saves whether a observe statement was created.
            bool observeCreated = false;

            /// Stores the unique identifier of the currently parsed statement, starting at 1.
            std::size_t currentLocationNumber = 1;

            /// Sets the expression parser to a mode where it actually generates valid expressions.
            void enableExpressions();

            // Constructors for the single program parts. They just wrap the statement constructors and throw exceptions in case something unexpected was parsed.
            storm::pgcl::PgclProgram createProgram(std::string const& programName, boost::optional<std::vector<storm::expressions::Variable> > parameters, std::vector<std::shared_ptr<storm::pgcl::Statement> > statements);
            storm::expressions::Variable declareDoubleVariable(std::string const& variableName);
            std::shared_ptr<storm::pgcl::AssignmentStatement> createAssignmentStatement(std::string const& variableName, boost::variant<storm::expressions::Expression, storm::pgcl::UniformExpression> const& assignedExpression);
            std::shared_ptr<storm::pgcl::AssignmentStatement> createIntegerDeclarationStatement(std::string const& variableName, storm::expressions::Expression const& assignedExpression);
            std::shared_ptr<storm::pgcl::ObserveStatement> createObserveStatement(storm::pgcl::BooleanExpression const& condition);
            std::shared_ptr<storm::pgcl::IfStatement> createIfElseStatement(storm::pgcl::BooleanExpression const& condition, std::vector<std::shared_ptr<storm::pgcl::Statement> > const& if_body, boost::optional<std::vector<std::shared_ptr<storm::pgcl::Statement> > > const& else_body);
            std::shared_ptr<storm::pgcl::LoopStatement> createLoopStatement(storm::pgcl::BooleanExpression const& condition, std::vector<std::shared_ptr<storm::pgcl::Statement> > const& body);
            std::shared_ptr<storm::pgcl::NondeterministicBranch> createNondeterministicBranch(std::vector<std::shared_ptr<storm::pgcl::Statement> > const& left, std::vector<std::shared_ptr<storm::pgcl::Statement> > const& right);
            std::shared_ptr<storm::pgcl::ProbabilisticBranch> createProbabilisticBranch(storm::expressions::Expression const& probability, std::vector<std::shared_ptr<storm::pgcl::Statement> > const& left, std::vector<std::shared_ptr<storm::pgcl::Statement> > const& right);
            storm::pgcl::BooleanExpression createBooleanExpression(storm::expressions::Expression const& expression);
            storm::pgcl::UniformExpression createUniformExpression(int const& begin, int const& end);
        };
    } // namespace parser
} // namespace storm

#endif	/* PGCLPARSER_H */