#ifndef PORYGONLANG_BASICLIBRARY_HPP
#define PORYGONLANG_BASICLIBRARY_HPP

#include <string>
#include <map>
#include "../Evaluator/EvaluationException.hpp"
#include "../Evaluator/EvalValues/EvalValue.hpp"
#include "../Evaluator/EvalValues/NilEvalValue.hpp"
#include "../Utilities/StringUtils.hpp"
#include "../Binder/BoundVariables/BoundVariable.hpp"
#include "../UserData/UserDataFunction.hpp"
#include "../UserData/UserDataFunctionType.hpp"

namespace Porygon::StandardLibraries{
    class BasicLibrary{
        static Evaluation::EvalValue* _error(void*, Evaluation::EvalValue* parameters[], int parameterCount){
            auto message = parameters[0]->EvaluateString();
            auto conv = Utilities::StringUtils::FromUTF8(message);
            throw Evaluation::EvaluationException(conv);
        }

        static Evaluation::EvalValue* _assert(void*, Evaluation::EvalValue* parameters[], int parameterCount){
            auto assertion = parameters[0]->EvaluateBool();
            if (!assertion){
                throw Evaluation::EvaluationException("assertion failed!");
            }
            return new Evaluation::BooleanEvalValue(true);
        }


    public:
        static void RegisterVariables(std::map<Utilities::HashedString, Binder::BoundVariable *>* bound,
                               std::map<Utilities::HashedString, shared_ptr<Evaluation::EvalValue>>* values){
            // Register error function
            auto errorFuncType = make_shared<UserData::UserDataFunctionType>(
                            make_shared<ScriptType>(TypeClass::Nil),
                            vector<shared_ptr<ScriptType>>{make_shared<StringScriptType>(false, 0)});
            auto errorFunc = make_shared<UserData::UserDataFunction>(_error, nullptr);
            auto errorLookup = Utilities::HashedString::CreateLookup(u"error");
            bound->insert({errorLookup, new Binder::BoundVariable(errorFuncType)});
            values->insert({errorLookup, errorFunc});

            // Register assert function
            auto assertFuncType = make_shared<UserData::UserDataFunctionType>(
                    make_shared<ScriptType>(TypeClass::Bool),
                    vector<shared_ptr<ScriptType>>{make_shared<ScriptType>(TypeClass::Bool)});
            auto assertFunc = make_shared<UserData::UserDataFunction>(_assert, nullptr);
            auto assertLookup = Utilities::HashedString::CreateLookup(u"assert");
            bound->insert({assertLookup, new Binder::BoundVariable(assertFuncType)});
            values->insert({assertLookup, assertFunc});

        }
    };
}

#endif //PORYGONLANG_BASICLIBRARY_HPP