/*
 * Copyright 2013, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include <MergedDirectory.h>

#include <new>
#include <set>
#include <string>
#include <cstddef>

#include <Directory.h>
#include <Entry.h>

#include <AutoDeleter.h>

#include "storage_support.h"


struct BMergedDirectory::EntryNameSet : std::set<std::string> {
};


BMergedDirectory::BMergedDirectory(BPolicy policy)
        :
        BEntryList(),
        fDirectories(10),
        fPolicy(policy),
        fDirectoryIndex(0),
        fVisitedEntries(NULL)
{
}


BMergedDirectory::~BMergedDirectory()
{
        delete fVisitedEntries;
}


status_t
BMergedDirectory::Init()
{
        delete fVisitedEntries;
        fDirectories.MakeEmpty(true);

        fVisitedEntries = new(std::nothrow) EntryNameSet;
        return fVisitedEntries != NULL ? B_OK : B_NO_MEMORY;
}


BMergedDirectory::BPolicy
BMergedDirectory::Policy() const
{
        return fPolicy;
}


void
BMergedDirectory::SetPolicy(BPolicy policy)
{
        fPolicy = policy;
}


status_t
BMergedDirectory::AddDirectory(BDirectory* directory)
{
        return fDirectories.AddItem(directory) ? B_OK : B_NO_MEMORY;
}


status_t
BMergedDirectory::AddDirectory(const char* path)
{
        BDirectory* directory = new(std::nothrow) BDirectory(path);
        if (directory == NULL)
                return B_NO_MEMORY;
        ObjectDeleter<BDirectory> directoryDeleter(directory);

        if (directory->InitCheck() != B_OK)
                return directory->InitCheck();

        status_t error = AddDirectory(directory);
        if (error != B_OK)
                return error;
        directoryDeleter.Detach();

        return B_OK;
}


status_t
BMergedDirectory::GetNextEntry(BEntry* entry, bool traverse)
{
        entry_ref ref;
        status_t error = GetNextRef(&ref);
        if (error != B_OK)
                return error;

        return entry->SetTo(&ref, traverse);
}


status_t
BMergedDirectory::GetNextRef(entry_ref* ref)
{
        BPrivate::Storage::LongDirEntry longEntry;
        struct dirent* dirEntry = longEntry.dirent();
        int32 result = GetNextDirents(dirEntry, sizeof(longEntry), 1);
        if (result < 0)
                return result;
        if (result == 0)
                return B_ENTRY_NOT_FOUND;

        BEntry entry;
        status_t error
                = entry.SetTo(fDirectories.ItemAt(fDirectoryIndex), dirEntry->d_name);
        if (error != B_OK)
                return error;

        return entry.GetRef(ref);
}


int32
BMergedDirectory::GetNextDirents(struct dirent* direntBuffer, size_t bufferSize,
        int32 maxEntries)
{
        if (maxEntries <= 0)
                return B_BAD_VALUE;

        while (fDirectoryIndex < fDirectories.CountItems()) {
                int32 count = fDirectories.ItemAt(fDirectoryIndex)->GetNextDirents(
                        direntBuffer, bufferSize, 1);
                if (count < 0)
                        return count;
                if (count == 0) {
                        fDirectoryIndex++;
                        continue;
                }

                if (strcmp(direntBuffer->d_name, ".") == 0
                        || strcmp(direntBuffer->d_name, "..") == 0) {
                        continue;
                }

                switch (fPolicy) {
                        case B_ALLOW_DUPLICATES:
                                return count;

                        case B_ALWAYS_FIRST:
                        case B_COMPARE:
                                if (fVisitedEntries != NULL
                                        && fVisitedEntries->find(direntBuffer->d_name)
                                                != fVisitedEntries->end()) {
                                        continue;
                                }

                                if (fVisitedEntries != NULL) {
                                        try {
                                                fVisitedEntries->insert(direntBuffer->d_name);
                                        } catch (std::bad_alloc&) {
                                                return B_NO_MEMORY;
                                        }
                                }

                                if (fPolicy == B_ALWAYS_FIRST
                                        || _IsBestEntry(direntBuffer->d_name)) {
                                        return 1;
                                }

                                fVisitedEntries->erase(direntBuffer->d_name);
                                break;
                }
        }

        return B_ENTRY_NOT_FOUND;
}


status_t
BMergedDirectory::Rewind()
{
        for (int32 i = 0; BDirectory* directory = fDirectories.ItemAt(i); i++)
                directory->Rewind();

        if (fVisitedEntries != NULL)
                fVisitedEntries->clear();

        fDirectoryIndex = 0;
        return B_OK;
}


int32
BMergedDirectory::CountEntries()
{
        int32 count = 0;
        char buffer[offsetof(struct dirent, d_name) + B_FILE_NAME_LENGTH];
        while (GetNextDirents((dirent*)&buffer, sizeof(buffer), 1) == 1)
                count++;
        return count;
}


bool
BMergedDirectory::ShallPreferFirstEntry(const entry_ref& entry1, int32 index1,
        const entry_ref& entry2, int32 index2)
{
        // That's basically B_ALWAYS_FIRST semantics. A derived class will implement
        // the desired semantics.
        return true;
}


bool
BMergedDirectory::_IsBestEntry(const char* name)
{
        entry_ref bestEntry;
        if (BEntry(fDirectories.ItemAt(fDirectoryIndex), name).GetRef(&bestEntry)
                        != B_OK) {
                return false;
        }

        int32 directoryCount = fDirectories.CountItems();
        for (int32 i = fDirectoryIndex + 1; i < directoryCount; i++) {
                BEntry entry(fDirectories.ItemAt(i), name);
                entry_ref ref;
                if (entry.Exists() && entry.GetRef(&ref) == B_OK
                        && !ShallPreferFirstEntry(bestEntry, fDirectoryIndex, ref, i)) {
                        return false;
                }
        }

        return true;
}