#ifndef DOMAIN_COMDEL_GENERATOR_H
#define DOMAIN_COMDEL_GENERATOR_H

#include "library.h"
#include "schema.h"

#include <set>
#include <utility>

#include <comdel/parser/ast_nodes.h>
#include <comdel/parser/parse_context.h>
#include <comdel/parser/presult.h>

namespace domain {

    /** Context used for loading model */
    struct ComdelContext {
        std::vector<Attribute> attributes;
        std::vector<std::string> wires;
        std::string name;
        bool inComponent;
        bool inConnection;
        bool inSingleAutomaticConnection;

        ComdelContext(std::string name, bool inComponent, bool inConnection, bool inSingleAutomaticConnection);

        bool doesAttributeExists(std::string name, Value::ValueType type);
        bool doesWireExists(std::string name);

    };

    class SchemaCreator {

    public:
        explicit SchemaCreator(std::vector<FunctionValidator *> validators);

        std::vector<SourceError> getErrors();

        std::optional<Library> loadLibrary(LibraryNode node);
        Schema *loadSchema(SchemaNode node, Library &library);

    private:
        std::vector<ComdelContext> context;

        std::string name;
        std::string libraryInfo;
        std::string header;
        std::string componentDirectory;
        std::optional<std::string> componentHeader = nullopt;
        std::vector<AddressSpace> addressSpaces;
        std::vector<Component> components;
        std::vector<Bus> buses;
        std::vector<Connection> connections;
        std::map<std::string, std::string> messages;

        std::vector<SourceError> errors;
        std::vector<FunctionValidator *> validators;


        std::optional<AddressSpace> loadAddressSpace(AddressSpaceNode node);
        std::optional<Component> loadComponent(ComponentNode node);
        std::optional<Attribute> loadAttribute(AttributeNode node);
        std::optional<Rule> loadRule(RuleNode node);
        std::optional<Condition> loadCondition(ConditionNode node);
        std::optional<Popup> loadPopup(PopupNode node, std::string name, Value::ValueType type);
        std::optional<Display> loadDisplay(DisplayNode node);
        std::optional<Wire> loadWire(WireNode node);
        std::optional<Pin> loadPin(PinNode pins);
        std::optional<Connection> loadConnection(ConnectionNode node);
        std::optional<Bus> loadBus(BusNode node);
        std::shared_ptr<ComponentInstance> loadComponentInstance(InstanceNode instance, Library &library);
        std::shared_ptr<BusInstance> loadBusInstance(InstanceNode instance, Library &library);

        /** Utility classes */
        std::optional<Bus> getBus(std::string name);
        std::optional<Pin> getComponentPin(std::string name, std::string pin);
        bool hasAddressSpace(std::string name);

        std::optional<Attribute> createMemoryAttribute();
        vector<Enumeration> createWireEnumeration(vector<Value> enumeration);
        std::optional<Popup> createMemoryPopup();

        /** Context stack operations */
        void push(ComdelContext context);
        void pushAdditional(std::string name);
        ComdelContext &current();
        void pop();
    };

} // namespace domain

#endif // DOMAIN_COMDEL_GENERATOR_H