interpreter.h

#ifndef INTERPRETER_H
#define INTERPRETER_H

#include "ast.h"
#include "token.h"
#include <unordered_map>
#include <any>
#include <string>
#include <vector>
#include <functional>

namespace AR437 {

class RuntimeError : public std::exception {
private:
    std::string message;

public:
    RuntimeError(const std::string& msg) : message(msg) {}
    const char* what() const noexcept override {
        return message.c_str();
    }
};

class ReturnValue : public std::exception {
private:
    std::any value;

public:
    ReturnValue(std::any val) : value(val) {}
    std::any getValue() const { return value; }
};

class Environment {
private:
    std::unordered_map<std::string, std::any> variables;
    Environment* enclosing;

public:
    Environment(Environment* enc = nullptr) : enclosing(enc) {}
    
    void define(const std::string& name, std::any value);
    std::any get(const std::string& name);
    void assign(const std::string& name, std::any value);
    bool exists(const std::string& name);
};

class Function {
public:
    std::string name;
    std::vector<std::string> parameters;
    Block* body;  // Use raw pointer instead of unique_ptr to avoid move issues
    Environment* closure;

    Function(const std::string& n, const std::vector<std::string>& params,
             Block* b, Environment* env)
        : name(n), parameters(params), body(b), closure(env) {}

    std::any call(const std::vector<std::any>& arguments, class Interpreter* interpreter);
};

class Interpreter : public ASTVisitor {
private:
    Environment* globals;
    Environment* environment;
    std::unordered_map<std::string, std::unique_ptr<Function>> functions;
    std::any lastValue;

    std::string anyToString(const std::any& value);
    bool isTruthy(const std::any& value);
    bool isEqual(const std::any& left, const std::any& right);
    std::any performBinaryOperation(const std::any& left, TokenType operator_, const std::any& right);
    std::any performUnaryOperation(TokenType operator_, const std::any& operand);

public:
    Interpreter();
    ~Interpreter();
    
    void interpret(Program& program);
    Environment* getGlobalEnvironment() { return globals; }
    
    // Visitor methods
    void visit(NumberLiteral& node) override;
    void visit(StringLiteral& node) override;
    void visit(BooleanLiteral& node) override;
    void visit(NullLiteral& node) override;
    void visit(Identifier& node) override;
    void visit(BinaryOperation& node) override;
    void visit(UnaryOperation& node) override;
    void visit(Assignment& node) override;
    void visit(FunctionCall& node) override;
    void visit(ExpressionStatement& node) override;
    void visit(VariableDeclaration& node) override;
    void visit(Block& node) override;
    void visit(IfStatement& node) override;
    void visit(WhileStatement& node) override;
    void visit(ReturnStatement& node) override;
    void visit(DisplayStatement& node) override;
    void visit(ReadStatement& node) override;
    void visit(FunctionDeclaration& node) override;
    void visit(Program& node) override;
    
    void executeBlock(Block& block, Environment* env);
};

} // namespace AR437

#endif // INTERPRETER_H