// Directory.cpp

#include <new>

#include <dirent.h>
#include <errno.h>

#include <AutoDeleter.h>

#include "Directory.h"
#include "FDManager.h"
#include "Path.h"
#include "VolumeManager.h"

// CachedDirIterator
class CachedDirIterator : public DirIterator {
public:
                                                                CachedDirIterator();
                                                                ~CachedDirIterator();

        virtual status_t                        SetDirectory(Directory* directory);

        virtual Entry*                          NextEntry();
        virtual void                            Rewind();

        virtual Entry*                          GetCurrentEntry() const;

        virtual status_t                        GetStat(struct stat* st);

private:
                        Entry*                          fCurrentEntry;
};

// UncachedDirIterator
class UncachedDirIterator : public DirIterator {
public:
                                                                UncachedDirIterator();
                                                                ~UncachedDirIterator();

        virtual status_t                        SetDirectory(Directory* directory);

        virtual Entry*                          NextEntry();
        virtual void                            Rewind();

        virtual Entry*                          GetCurrentEntry() const;

protected:
        virtual int                                     GetFD() const;

private:
                        DIR*                            fDirHandle;
};


// #pragma mark -

// constructor
CachedDirIterator::CachedDirIterator()
        : DirIterator(),
          fCurrentEntry(NULL)
{
}

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

// SetDirectory
status_t
CachedDirIterator::SetDirectory(Directory* directory)
{
        // set the new directory
        fDirectory = directory;
        fCurrentEntry = (fDirectory ? fDirectory->GetFirstEntry() : NULL);

        if (directory)
                fNodeRef = directory->GetNodeRef();

        return B_OK;
}

// NextEntry
Entry*
CachedDirIterator::NextEntry()
{
        if (!IsValid() || !fCurrentEntry)
                return NULL;

        Entry* entry = fCurrentEntry;
        fCurrentEntry = fDirectory->GetNextEntry(fCurrentEntry);
        return entry;
}

// Rewind
void
CachedDirIterator::Rewind()
{
        fCurrentEntry = (IsValid() ? fDirectory->GetFirstEntry() : NULL);
}

// GetCurrentEntry
Entry*
CachedDirIterator::GetCurrentEntry() const
{
        return (IsValid() ? fCurrentEntry : NULL);
}

// GetStat
status_t
CachedDirIterator::GetStat(struct stat* st)
{
        if (!fDirectory || !st)
                return B_BAD_VALUE;

        *st = fDirectory->GetStat();
        return B_OK;
}


// #pragma mark -

// constructor
UncachedDirIterator::UncachedDirIterator()
        : DirIterator(),
          fDirHandle(NULL)
{
}

// destructor
UncachedDirIterator::~UncachedDirIterator()
{
        // close
        if (fDirHandle) {
                closedir(fDirHandle);
                fDirHandle = NULL;
        }
}

// SetDirectory
status_t
UncachedDirIterator::SetDirectory(Directory* directory)
{
        // unset old
        if (fDirHandle) {
                closedir(fDirHandle);
                fDirHandle = NULL;
        }
        fDirectory = NULL;

        // set new
        if (directory) {
                // get the directory path
                Path path;
                status_t error = directory->GetPath(&path);
                if (error != B_OK)
                        return error;

                // open the directory
                error = FDManager::OpenDir(path.GetPath(), fDirHandle);
                if (error != B_OK)
                        return error;

                fDirectory = directory;
                fNodeRef = directory->GetNodeRef();
        }

        return B_OK;
}

// NextEntry
Entry*
UncachedDirIterator::NextEntry()
{
        if (!IsValid() && fDirHandle)
                return NULL;

        while (struct dirent* dirEntry = readdir(fDirHandle)) {
                Entry* entry;
                if (VolumeManager::GetDefault()->LoadEntry(dirEntry->d_pdev,
                                dirEntry->d_pino, dirEntry->d_name, false, &entry) == B_OK) {
                        return entry;
                }
        }

        // we're through: set the directory to "complete"
        fDirectory->SetComplete(true);

        return NULL;
}

// Rewind
void
UncachedDirIterator::Rewind()
{
        if (IsValid() && fDirHandle)
                rewinddir(fDirHandle);
}

// GetCurrentEntry
Entry*
UncachedDirIterator::GetCurrentEntry() const
{
        return NULL;
}

// GetFD
int
UncachedDirIterator::GetFD() const
{
        return dirfd(fDirHandle);
}


// #pragma mark -

// constructor
Directory::Directory(Volume* volume, const struct stat& st)
        : Node(volume, st),
          fEntries(),
          fIterators(),
          fIsComplete(false)
{
}

// destructor
Directory::~Directory()
{
        // remove all directory iterators
        while (DirIterator* iterator = fIterators.First())
                iterator->SetDirectory(NULL);
}

// GetActualReferringEntry
Entry*
Directory::GetActualReferringEntry() const
{
        // any entry other than "." and ".." is fine
        for (Entry* entry = GetFirstReferringEntry();
                 entry;
                 entry = GetNextReferringEntry(entry)) {
                if (entry->IsActualEntry())
                        return entry;
        }
        return NULL;
}

// AddEntry
void
Directory::AddEntry(Entry* entry)
{
        if (entry)
                fEntries.Insert(entry);
}

// RemoveEntry
void
Directory::RemoveEntry(Entry* entry)
{
        if (entry) {
                // update the directory iterators pointing to the removed entry
                for (DirIterator* iterator = fIterators.First();
                         iterator;
                         iterator = fIterators.GetNext(iterator)) {
                        if (iterator->GetCurrentEntry() == entry)
                                iterator->NextEntry();
                }

                fEntries.Remove(entry);
        }
}

// GetFirstEntry
Entry*
Directory::GetFirstEntry() const
{
        return fEntries.First();
}

// GetNextEntry
Entry*
Directory::GetNextEntry(Entry* entry) const
{
        return (entry ? fEntries.GetNext(entry) : NULL);
}

// CountEntries
int32
Directory::CountEntries() const
{
        int32 count = 0;
        Entry* entry = GetFirstEntry();
        while (entry) {
                count++;
                entry = GetNextEntry(entry);
        }
        return count;
}

// OpenDir
status_t
Directory::OpenDir(DirIterator** _iterator)
{
        if (!_iterator)
                return B_BAD_VALUE;

        // create the iterator
        DirIterator* iterator;
        if (fIsComplete)
                iterator = new(std::nothrow) CachedDirIterator;
        else
                iterator = new(std::nothrow) UncachedDirIterator;
        if (!iterator)
                return B_NO_MEMORY;
        ObjectDeleter<DirIterator> iteratorDeleter(iterator);

        // initialize it
        status_t error = iterator->SetDirectory(this);
        if (error != B_OK)
                return error;

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

        // add it
        fIterators.Insert(iterator);

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

// HasDirIterators
bool
Directory::HasDirIterators() const
{
        return fIterators.First();
}

// RemoveDirIterator
void
Directory::RemoveDirIterator(DirIterator* iterator)
{
        if (iterator)
                fIterators.Remove(iterator);
}

// SetComplete
void
Directory::SetComplete(bool complete)
{
        fIsComplete = complete;
}

// IsComplete
bool
Directory::IsComplete() const
{
        return fIsComplete;
}