// Node.cpp

#include <errno.h>
#include <fcntl.h>
#include <new>
#include <unistd.h>
#include <sys/stat.h>

#include <AutoDeleter.h>
#include <fs_attr.h>

#include "DebugSupport.h"
#include "Entry.h"
#include "FDManager.h"
#include "Node.h"
#include "NodeHandle.h"
#include "Path.h"
#include "VolumeManager.h"

// constructor
Node::Node(Volume* volume, const struct stat& st)
        : AttributeDirectory(),
          fVolume(volume),
          fStat(st),
          fReferringEntries()
{
}

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

// GetVolume
Volume*
Node::GetVolume() const
{
        return fVolume;
}

// GetNodeRef
node_ref
Node::GetNodeRef() const
{
        node_ref ref;
        ref.device = fStat.st_dev;
        ref.node = fStat.st_ino;
        return ref;
}

// GetVolumeID
dev_t
Node::GetVolumeID() const
{
        return fStat.st_dev;
}

// GetID
ino_t
Node::GetID() const
{
        return fStat.st_ino;
}

// AddReferringEntry
void
Node::AddReferringEntry(Entry* entry)
{
        if (!entry)
                return;
        fReferringEntries.Insert(entry);
}

// RemoveReferringEntry
void
Node::RemoveReferringEntry(Entry* entry)
{
        if (entry)
                fReferringEntries.Remove(entry);
}

// GetFirstReferringEntry
Entry*
Node::GetFirstReferringEntry() const
{
        return fReferringEntries.First();
}

// GetNextReferringEntry
Entry*
Node::GetNextReferringEntry(Entry* entry) const
{
        return (entry ? fReferringEntries.GetNext(entry) : NULL);
}

// FindReferringEntry
Entry*
Node::FindReferringEntry(dev_t volumeID, ino_t directoryID, const char* name)
{
        if (!name)
                return NULL;

        NoAllocEntryRef ref(volumeID, directoryID, name);
        return FindReferringEntry(ref);
}

// FindReferringEntry
Entry*
Node::FindReferringEntry(const entry_ref& entryRef)
{
        for (Entry* entry = GetFirstReferringEntry();
                 entry;
                 entry = GetNextReferringEntry(entry)) {
                NoAllocEntryRef ref(entry->GetEntryRef());
                if (ref == entryRef)
                        return entry;
        }

        return NULL;
}

// GetActualReferringEntry
Entry*
Node::GetActualReferringEntry() const
{
        return GetFirstReferringEntry();
}

// GetStat
const struct stat&
Node::GetStat() const
{
        return fStat;
}

// UpdateStat
status_t
Node::UpdateStat()
{
        // get a path
        Path path;
        status_t error = GetPath(&path);
        if (error != B_OK)
                return error;

        // read stat
        struct stat st;
        if (lstat(path.GetPath(), &st) < 0)
                return errno;

        // check if it is the same node
        if (st.st_dev != fStat.st_dev || st.st_ino != fStat.st_ino) {
                ERROR("Node::UpdateStat(): ERROR: GetPath() returned path that "
                        "doesn't point to this node: node: (%" B_PRIdDEV ", %" B_PRIdINO "), "
                        "path: `%s'\n",
                        GetVolumeID(), GetID(), path.GetPath());
                return B_ENTRY_NOT_FOUND;
        }

        fStat = st;
        return B_OK;
}

// IsDirectory
bool
Node::IsDirectory() const
{
        return S_ISDIR(fStat.st_mode);
}

// IsFile
bool
Node::IsFile() const
{
        return S_ISREG(fStat.st_mode);
}

// IsSymlink
bool
Node::IsSymlink() const
{
        return S_ISLNK(fStat.st_mode);
}

// GetPath
status_t
Node::GetPath(Path* path)
{
        return VolumeManager::GetDefault()->GetPath(this, path);
}

// Open
status_t
Node::Open(int openMode, FileHandle** _fileHandle)
{
        if (!_fileHandle)
                return B_BAD_VALUE;

        // allocate the file handle
        FileHandle* fileHandle = new(std::nothrow) FileHandle;
        if (!fileHandle)
                return B_NO_MEMORY;
        ObjectDeleter<FileHandle> fileHandleDeleter(fileHandle);

        // open the file
        status_t error = fileHandle->Open(this, openMode);
        if (error != B_OK)
                return error;

        // check, if it really belongs to this node
        error = _CheckNodeHandle(fileHandle);
        if (error != B_OK)
                return error;

        fileHandleDeleter.Detach();
        *_fileHandle = fileHandle;
        return B_OK;
}

// OpenAttrDir
status_t
Node::OpenAttrDir(AttrDirIterator** _iterator)
{
        if (!_iterator)
                return B_BAD_VALUE;

        // allocate the file handle
        AttrDirIterator* iterator = new(std::nothrow) AttrDirIterator;
        if (!iterator)
                return B_NO_MEMORY;
        ObjectDeleter<AttrDirIterator> iteratorDeleter(iterator);

        // open the attr dir
        status_t error = iterator->Open(this);
        if (error != B_OK)
                return error;

        // check, if it really belongs to this node
        error = _CheckNodeHandle(iterator);
        if (error != B_OK)
                return error;

        iteratorDeleter.Detach();
        *_iterator = iterator;
        return B_OK;
}

// OpenNode
status_t
Node::OpenNode(BNode& node)
{
        Entry* entry = GetActualReferringEntry();
        if (!entry)
                return B_ENTRY_NOT_FOUND;

        NoAllocEntryRef entryRef(entry->GetEntryRef());
        return FDManager::SetNode(&node, &entryRef);
}

// ReadSymlink
status_t
Node::ReadSymlink(char* buffer, int32 bufferSize, int32* _bytesRead)
{
        if (!buffer || bufferSize < 1)
                return B_BAD_VALUE;

        // get a path
        Path path;
        status_t error = GetPath(&path);
        if (error != B_OK)
                return error;

        // read the symlink
        ssize_t bytesRead = readlink(path.GetPath(), buffer, bufferSize);
        if (bytesRead < 0)
                return bytesRead;
        if (bytesRead < bufferSize)
                buffer[bytesRead] = '\0';
        else
                buffer[bufferSize - 1] = '\0';

        if (_bytesRead)
                *_bytesRead = bytesRead;
        return B_OK;
}

// _CheckNodeHandle
status_t
Node::_CheckNodeHandle(NodeHandle* nodeHandle)
{
        if (!nodeHandle)
                return B_BAD_VALUE;

        // read the stat
        struct stat st;
        status_t error = nodeHandle->GetStat(&st);
        if (error != B_OK)
                return error;

        // check if it is the same node
        if (st.st_dev != fStat.st_dev || st.st_ino != fStat.st_ino)
                return B_ENTRY_NOT_FOUND;
        return B_OK;
}