/*
 * Copyright 2019, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT license.
 */
#ifndef DIRECTORY_ENTRY_TABLE_H
#define DIRECTORY_ENTRY_TABLE_H

#include <util/OpenHashTable.h>

#include "AllocationInfo.h"
#include "DebugSupport.h"
#include "Misc.h"
#include "Node.h"

// DirectoryEntryHash
struct DirectoryEntryHash {
        struct Key {
                ino_t id;
                const char* name;

                Key(ino_t i, const char* n) : id(i), name(n) {}
        };
        typedef Key                     KeyType;
        typedef Entry           ValueType;

        size_t HashKey(KeyType key) const
        {
                return node_child_hash(key.id, key.name);
        }

        size_t Hash(ValueType* value) const
        {
                return HashKey(Key(value->GetParent()->GetID(), value->GetName()));
        }

        bool Compare(KeyType key, ValueType* value) const
        {
                return (value->GetParent()->GetID() == key.id
                        && !strcmp(value->GetName(), key.name));
        }

        ValueType*& GetLink(ValueType* value) const
        {
                return value->HashLink();
        }
};

// DirectoryEntryTable
class DirectoryEntryTable {
public:
        DirectoryEntryTable();
        ~DirectoryEntryTable();

        status_t InitCheck() const;

        status_t AddEntry(Directory *node, Entry *child);
        status_t AddEntry(ino_t, Entry *child);
        status_t RemoveEntry(Directory *node, Entry *child);
        status_t RemoveEntry(ino_t id, Entry *child);
        status_t RemoveEntry(ino_t id, const char *name);
        Entry *GetEntry(ino_t id, const char *name);

        void GetAllocationInfo(AllocationInfo &info)
        {
                info.AddDirectoryEntryTableAllocation(0, fTable.TableSize(),
                        sizeof(void*), fTable.CountElements());
        }

protected:
        BOpenHashTable<DirectoryEntryHash> fTable;
        status_t fInitStatus;
};

// constructor
DirectoryEntryTable::DirectoryEntryTable()
{
        fInitStatus = fTable.Init(1000);
}

// destructor
DirectoryEntryTable::~DirectoryEntryTable()
{
}

// InitCheck
status_t
DirectoryEntryTable::InitCheck() const
{
        RETURN_ERROR(fInitStatus);
}

// AddEntry
status_t
DirectoryEntryTable::AddEntry(Directory *node, Entry *child)
{
        status_t error = (node && child ? B_OK : B_BAD_VALUE);
        if (error == B_OK)
                error = AddEntry(node->GetID(), child);
        return error;
}

// AddEntry
status_t
DirectoryEntryTable::AddEntry(ino_t id, Entry *child)
{
        status_t error = (child ? B_OK : B_BAD_VALUE);
        if (error == B_OK) {
                RemoveEntry(id, child);
                SET_ERROR(error, fTable.Insert(child));
        }
        return error;
}

// RemoveEntry
status_t
DirectoryEntryTable::RemoveEntry(Directory *node, Entry *child)
{
        status_t error = (node && child ? B_OK : B_BAD_VALUE);
        if (error == B_OK)
                error = RemoveEntry(node->GetID(), child->GetName());
        return error;
}

// RemoveEntry
status_t
DirectoryEntryTable::RemoveEntry(ino_t id, Entry *child)
{
        status_t error = (child ? B_OK : B_BAD_VALUE);
        if (error == B_OK)
                error = RemoveEntry(id, child->GetName());
        return error;
}

// RemoveEntry
status_t
DirectoryEntryTable::RemoveEntry(ino_t id, const char *name)
{
        Entry* child = fTable.Lookup(DirectoryEntryHash::Key(id, name));
        if (!child)
                return B_NAME_NOT_FOUND;
        return fTable.Remove(child) ? B_OK : B_ERROR;
}

// GetEntry
Entry *
DirectoryEntryTable::GetEntry(ino_t id, const char *name)
{
        Entry *child = fTable.Lookup(DirectoryEntryHash::Key(id, name));
        return child;
}

#endif  // DIRECTORY_ENTRY_TABLE_H