#ifndef DOMAIN_VALUE_H
#define DOMAIN_VALUE_H

#include "address_space.h"

#include <string>
#include <optional>


namespace domain {

    class ComponentInstance;

    class Value {
    public:
        enum ValueType {
            INT,
            STRING,
            BOOL,
            ADDRESS_SPACE,
            ADDRESS_SPACE_REFERENCE,
            ATTRIBUTE_REFERENCE,
            MEMORY_REFERENCE,
            MEMORY,
            WIRE_REFERENCE,
            NIL,
            UNDEFINED,
        };

    private:
        long long intValue = 0;
        std::string stringValue;
        bool boolValue = false;
        std::optional<AddressSpace> addressSpace = std::nullopt;
        std::string reference;
        domain::ComponentInstance *memory = nullptr;

        std::optional<std::string> memoryReference = std::nullopt;

        ValueType type = UNDEFINED;

    public:

        Value() = default;

        bool equals(Value value) {
            if (value.getType() == type) {
                switch (type) {
                    case INT:
                        return value.asInt() == intValue;
                    case STRING:
                        return value.asString() == stringValue;
                    case NIL:
                    case UNDEFINED:
                        return true;
                    case WIRE_REFERENCE:
                    case ATTRIBUTE_REFERENCE:
                    case ADDRESS_SPACE_REFERENCE:
                        return value.asReference() == reference;
                    case MEMORY_REFERENCE:
                        return value.asMemoryReference() == memoryReference;
                    case MEMORY:
                        return value.asMemory() == memory;
                    case BOOL:
                        return value.asBool() == boolValue;
                    default:
                        return false;
                }
            }
            return false;
        }

        std::string string();

        ValueType getType();

        bool isType(ValueType type);

        long long asInt();

        std::string asString();

        bool asBool();

        std::string asReference();

        std::optional<std::string> asMemoryReference();

        domain::ComponentInstance *asMemory();

        AddressSpace asAddressSpace();

        void setInt(long long intValue);

        void setString(std::string value);

        void setBool(bool value);

        void setReference(std::string value);

        std::string stringify();

        static Value fromInt(long long value);

        static Value fromString(std::string value);

        static Value fromBool(bool value);

        static Value fromNull();

        static Value fromAddressSpace(AddressSpace addressSpace);

        static Value fromReference(std::string value, ValueType type);

        static Value fromMemoryReference(std::optional<std::string> memoryReference);

        static Value ofType(ValueType type);
    };

} // namespace domain

#endif // DOMAIN_VALUE_H