#pragma once

#include "type.hpp"
#include "../parser/parser.hpp"

#include <string>
#include <unordered_map>

namespace Solstice {

    class TypeChecker {
        std::unordered_map<std::string, Type> variables;
        std::unordered_map<std::string, Type> types;

        std::unordered_map<TypePair, Type> addOverloads;
        std::unordered_map<TypePair, Type> subtractOverloads;
        std::unordered_map<TypePair, Type> multiplyOverloads;
        std::unordered_map<TypePair, Type> divideOverloads;
        std::unordered_map<TypePair, Type> equalOverloads;
        std::unordered_map<TypePair, Type> notEqualOverloads;
        std::unordered_map<TypePair, Type> greaterThanOverloads;
        std::unordered_map<TypePair, Type> lesserThanOverloads;

        Node& input;

        bool inFunction = false;

        void initOverloads();

        void checkLiteralNodeType(Node& node);
        void checkIdentifierNodeType(Node& node);
        void checkTupleNodeType(Node& node);

        void checkBindNodeType(Node& node);
        void checkFunctionBindNodeType(Node& node);
        void checkSetNodeType(Node& node);

        void checkCodeBlockType(Node& node);

        void checkNodeType(Node& node);

        public:

        TypeChecker() = delete;
        TypeChecker(Node& node) : input(node) {
            initOverloads();
        }

        void checkTypes();
    };
}