#ifndef PORYGONLANG_EVALUATOR_HPP
#define PORYGONLANG_EVALUATOR_HPP

#include <string>
#include "../Binder/BoundStatements/BoundStatement.hpp"
#include "EvalValues/EvalValue.hpp"
#include "EvalValues/NumericEvalValue.hpp"
#include "EvalValues/StringEvalValue.hpp"
#include "EvalValues/StringEvalValue.hpp"
#include "EvalValues/ScriptFunctionEvalValue.hpp"
#include "EvaluationScope/EvaluationScope.hpp"

using namespace std;

namespace Porygon::Evaluation{
    class Evaluator {
        shared_ptr<const EvalValue> _returnValue;
        map<Utilities::HashedString, shared_ptr<const EvalValue>>* _scriptVariables;
        bool _hasReturned;
        bool _hasBroken;
        shared_ptr<const EvalValue> _lastValue;

        //Porygon::Script* _scriptData;
        shared_ptr<EvaluationScope> _evaluationScope;

        void EvaluateStatement(const BoundStatement* statement);
        void EvaluateBlockStatement(const BoundBlockStatement *statement);
        void EvaluateExpressionStatement(const BoundExpressionStatement* statement);
        void EvaluateAssignmentStatement(const BoundAssignmentStatement* statement);
        void EvaluateIndexAssignmentStatement(const BoundIndexAssignmentStatement* statement);
        void EvaluateFunctionDeclarationStatement(const BoundFunctionDeclarationStatement *statement);
        void EvaluateReturnStatement(const BoundReturnStatement *statement);
        void EvaluateConditionalStatement(const BoundConditionalStatement *statement);
        void EvaluateNumericalForStatement(const BoundNumericalForStatement *statement);
        void EvaluateGenericForStatement(const BoundGenericForStatement *statement);
        void EvaluateWhileStatement(const BoundWhileStatement *statement);

        shared_ptr<const EvalValue> EvaluateExpression(const BoundExpression *expression);
        shared_ptr<const NumericEvalValue> EvaluateIntegerExpression(const BoundExpression *expression);
        shared_ptr<const BooleanEvalValue> EvaluateBoolExpression(const BoundExpression *expression);
        shared_ptr<const StringEvalValue> EvaluateStringExpression(const BoundExpression *expression);
        shared_ptr<const EvalValue> EvaluateFunctionExpression(const BoundExpression *expression);
        shared_ptr<const EvalValue> EvaluateNilExpression(const BoundExpression *expression);
        shared_ptr<const EvalValue> EvaluateTableExpression(const BoundExpression *expression);

        shared_ptr<const NumericEvalValue> EvaluateIntegerBinary(const BoundBinaryExpression *expression);
        shared_ptr<const BooleanEvalValue> EvaluateBooleanBinary(const BoundBinaryExpression *expression);
        shared_ptr<const StringEvalValue> EvaluateStringBinary(const BoundBinaryExpression *expression);

        shared_ptr<const NumericEvalValue> EvaluateIntegerUnary(const BoundUnaryExpression *expression);
        shared_ptr<const BooleanEvalValue> EvaluateBooleanUnary(const BoundUnaryExpression *expression);
        shared_ptr<const EvalValue> EvaluateFunctionCallExpression(const BoundExpression *expression);
        shared_ptr<const EvalValue> EvaluateIndexExpression(const BoundExpression *expression);
        shared_ptr<const EvalValue> EvaluatePeriodIndexExpression(const BoundExpression *expression);
        shared_ptr<const EvalValue> EvaluateNumericTableExpression(const BoundExpression *expression);
        shared_ptr<const EvalValue> EvaluateUserDataExpression(const BoundExpression *expression);
        shared_ptr<const EvalValue> EvaluateComplexTableExpression(const BoundExpression *expression);

        shared_ptr<const EvalValue> GetVariable(const BoundVariableExpression *expression);
    public:
        explicit Evaluator(map<Utilities::HashedString, shared_ptr<const EvalValue>>* scriptVariables)
            : _scriptVariables(scriptVariables), _hasReturned(false), _hasBroken(false), _returnValue(nullptr),
            _evaluationScope(nullptr){
        }

        const EvalValue* Evaluate(const BoundScriptStatement* statement);
        shared_ptr<const EvalValue> EvaluateFunction(const GenericFunctionEvalValue *function,
                                                     const vector<EvalValue *> &parameters);

        inline const EvalValue* GetLastValue(){
            return _lastValue.get();
        }

    };
}



#endif //PORYGONLANG_EVALUATOR_HPP