#pragma once
#include <cstdint>
#include <set>
#include <vector>
#include <string>

#ifdef NT_EXPORTS
#define NT_API __declspec(dllexport)
#else
#define NT_API __declspec(dllimport)
#endif

enum OBJECT_TYPE {
    MULTIGROUP,
    RELATION,
    TUPLE,
    ATTRIBUTE,
    TRANSACTION
};

enum METHOD {
    OPEN,
    CLOSE,
    PARSE, // To plug a secondary namespace
    SECURITY
};

enum AUTH_CLAIM {
    READ,
    WRITE
};

enum AUTH_METHOD {
    CERTIFICATE,
    PLAIN_TEXT
};

namespace nt
{
    class NT_API ObjectManager
    {
    public:
        class IObject {
            virtual ~IObject() {}
        };
        class Multigroup : IObject {};
        class Relation : IObject {};
        class Tuple : IObject {};
        class Transaction : IObject {};
        struct object_type {
            OBJECT_TYPE label;
            // If the object is not durable. E.g.: TRANSACTION
            bool disposable;
            std::set<METHOD> methods;
        };
        struct registry_head {
            uint32_t reference_count;
            uint32_t handle_count;
            struct object_type* type;
            std::vector<std::string> path;
            //security_descriptor to be added later, maybe also a set of labels
        };
        struct registry {
            struct registry_head* head;
            IObject object;
            // TODO: Treat as a list for now, but ideally it's a tree
            struct registry* next;
        };
        struct registry** registry;
        // Looks into this registry and attempts to retrieve the entry
        struct registry* Find(const std::vector<std::string> object_path){}
    };

    class NT_API PermissionsManager
    {
    public:
        // For validating connections at login
        std::set<AUTH_CLAIM> Firewall(AUTH_METHOD method) {}
        // For validating permission to an object
        const bool Access(const std::vector<std::string> object_path, const void* connection_context) {
            // Checks the security descriptor on the head of the object we find in the ObjectManager::registry
            // Then additionally check other metadata yet to be defined in the connection_context,
            // like user group, policy, etc.
            // Yet to decide if this should be summoned at every attempt to get ahold of an object,
            // that might produce significant overhead. How can we solve this?
        }
    };

    class NT_API NamespaceReferenceManager
    {
    };
    
    class NT_API CursorManager
    {
    };
    
    class NT_API IdentityManager
    {
    public:
        // Looks into the methods of the object type and asserts if it can be opened
        const bool CanOpen(struct ObjectManager::registry* object) {}
    };

    class NT_API LifecycleManager
    {
    public:
        // If object is not being monitored already, monitors the lifecycle by updating the handle count.
        // Maybe also look at the reference count and kill some categories of disposable objects no longer referenced by other objects, like transactions.
        // Think of other use cases later.
        void Monitor(struct ObjectManager::registry* object) {}
        // Serializes contention for the change of a mutable reference.
        // This can be used in, for example, the HEAD of a branch to serialize the access.
        // If the object does not causes contention, like a relation (since they are immutable, just like multigroups, all snapshots)
        // then just approve, as they do not cause any contention. Transactions also do not cause any, 
        // the only things that do are mutable reference states in shared sessions,
        // for example: the HEAD of a branch, namespace collisions (creating two branches with the same name, or two multigroups with the same name from the same state, etc),
        // multi-branch atomic commits (which I wish to not have as it damages isolation), 
        // garbage collection of old state (as in, we want to delete an old-enough history to save up space), etc.
        const bool Contention(struct ObjectManager::registry* object){}
        // The inverse of `Monitor`, stops monitoring.
        // Maybe garbage collect here also if the counters goes to zero.
        void Unmonitor(struct ObjectManager::registry* object) {}
    };

    class NT_API HandlerManager
    {
    public:
        // This is supposed to represent an authorized access to a certain object in the registry
        // This increases the handle count in the object manager
        // We should consider adding on the object manager a vector of all the handles that refer to an object
        struct handle {};
        void DeallocateHandle(struct handle* handle) {}
        struct handle Open(std::vector<std::string> object_path, void* connection_context) {
            struct ObjectManager::registry* retrieved_object = ObjectManager::Find((const std::vector<std::string>)object_path);
            if (PermissionsManager::Access(retrieved_object, (const void*)connection_context)
                && IdentityManager::CanOpen(retrieved_object)
                && LifecycleManager::Contention(retrieved_object)) {
                // Starts monitoring this guy
                LifecycleManager::Monitor(retrieved_object);
                return {}; // Return a successful handle
            }
            else {
                // Return something more algebraic instead of null or an int
                return {};
            };
        }
        bool Close(struct handle *handle) {
            // Somehow grab the object pointer and connection (maybe drop it...) from the handle
            struct ObjectManager::registry* object = handle->object;
            void* connection_context = handle->connection_context;
            // Checking for permissions here may be relevant.
            // What if we have a handle but no permission? Spooky
            if (PermissionsManager::Access(object, connection_context)
                && IdentityManager::CanClose(object)
                // TODO: I think that in this case we do not need to worry about contention.
                // But be careful to evaluate this scenario later.
                //&& LifecycleManager::Contention(retrieved_object)
                ) {
                // Stops monitoring this guy
                LifecycleManager::Unmonitor(object);
                DeallocateHandle(handle);
                return true; // Return a successful handle
            }
            else {
                // Return something more algebraic instead of null or an int.
                // It's kinda bad to not even report what went wrong.
                return false;
            };
        }
    };

    class NT_API WAM
    {
    };

    class NT_API NT
    {
    public:
        bool IsRunning() const;
        void SimulateEntryCall() {};
    };
}