/*
 * Copyright 2010, Axel Dörfler, axeld@pinc-software.de.
 * This file may be used under the terms of the MIT License.
 */


#include <QueryFile.h>

#include <fs_attr.h>
#include <Volume.h>
#include <VolumeRoster.h>

#include "tracker/MimeTypes.h"
#include "tracker/Utilities.h"


// TODO: add write support
// TODO: let Tracker use it?
// TODO: live query support?


const char*     kAttrQueryString = "_trk/qrystr";
const char* kAttrQueryVolume = "_trk/qryvol1";


BQueryFile::BQueryFile(const entry_ref& ref)
{
        SetTo(ref);
}


BQueryFile::BQueryFile(const BEntry& entry)
{
        SetTo(entry);
}


BQueryFile::BQueryFile(const char* path)
{
        SetTo(path);
}


BQueryFile::BQueryFile(BQuery& query)
{
        SetTo(query);
}


BQueryFile::~BQueryFile()
{
}


status_t
BQueryFile::InitCheck() const
{
        return fStatus;
}


status_t
BQueryFile::SetTo(const entry_ref& ref)
{
        Unset();

        BNode node(&ref);
        fStatus = node.InitCheck();
        if (fStatus != B_OK)
                return fStatus;

        ssize_t bytesRead = node.ReadAttrString(kAttrQueryString, &fPredicate);
        if (bytesRead < 0)
                return fStatus = bytesRead;

        bool searchAllVolumes = true;
        attr_info info;
        if (node.GetAttrInfo(kAttrQueryVolume, &info) == B_OK) {
                void* buffer = malloc(info.size);
                if (buffer == NULL)
                        return fStatus = B_NO_MEMORY;

                BMessage message;
                fStatus = message.Unflatten((const char*)buffer);
                if (fStatus == B_OK) {
                        for (int32 index = 0; index < 100; index++) {
                                BVolume volume;
                                status_t status = BPrivate::MatchArchivedVolume(&volume,
                                        &message, index);
                                if (status == B_OK) {
                                        fStatus = AddVolume(volume);
                                        if (fStatus != B_OK)
                                                break;

                                        searchAllVolumes = false;
                                } else if (status != B_DEV_BAD_DRIVE_NUM) {
                                        // Volume doesn't seem to be mounted
                                        fStatus = status;
                                        break;
                                }
                        }
                }

                free(buffer);
        }

        if (searchAllVolumes) {
                // add all volumes to query
                BVolumeRoster roster;
                BVolume volume;
                while (roster.GetNextVolume(&volume) == B_OK) {
                        if (volume.IsPersistent() && volume.KnowsQuery())
                                AddVolume(volume);
                }
        }

        return fStatus;
}


status_t
BQueryFile::SetTo(const BEntry& entry)
{
        entry_ref ref;
        fStatus = entry.GetRef(&ref);
        if (fStatus != B_OK)
                return fStatus;

        return SetTo(ref);
}


status_t
BQueryFile::SetTo(const char* path)
{
        entry_ref ref;
        fStatus = get_ref_for_path(path, &ref);
        if (fStatus != B_OK)
                return fStatus;

        return SetTo(ref);
}


status_t
BQueryFile::SetTo(BQuery& query)
{
        Unset();

        BString predicate;
        query.GetPredicate(&predicate);

        fStatus = SetPredicate(predicate.String());
        if (fStatus != B_OK)
                return fStatus;

        return fStatus = AddVolume(query.TargetDevice());
}


void
BQueryFile::Unset()
{
        fStatus = B_NO_INIT;
        fCurrentVolumeIndex = -1;
        fVolumes.MakeEmpty();
        fQuery.Clear();
        fPredicate = "";
}


status_t
BQueryFile::SetPredicate(const char* predicate)
{
        fPredicate = predicate;
        return B_OK;
}


status_t
BQueryFile::AddVolume(const BVolume& volume)
{
        return fVolumes.AddItem((void*)(addr_t)volume.Device()) ? B_OK : B_NO_MEMORY;
}


status_t
BQueryFile::AddVolume(dev_t device)
{
        return fVolumes.AddItem((void*)(addr_t)device) ? B_OK : B_NO_MEMORY;
}


const char*
BQueryFile::Predicate() const
{
        return fPredicate.String();
}


int32
BQueryFile::CountVolumes() const
{
        return fVolumes.CountItems();
}


dev_t
BQueryFile::VolumeAt(int32 index) const
{
        if (index < 0 || index >= fVolumes.CountItems())
                return -1;

        return (dev_t)(addr_t)fVolumes.ItemAt(index);
}


status_t
BQueryFile::WriteTo(const entry_ref& ref)
{
        // TODO: implement
        return B_NOT_SUPPORTED;
}


status_t
BQueryFile::WriteTo(const char* path)
{
        entry_ref ref;
        status_t status = get_ref_for_path(path, &ref);
        if (status != B_OK)
                return status;

        return WriteTo(ref);
}


// #pragma mark - BEntryList implementation


status_t
BQueryFile::GetNextEntry(BEntry* entry, bool traverse)
{
        if (fCurrentVolumeIndex == -1) {
                // Start with first volume
                fCurrentVolumeIndex = 0;

                status_t status = _SetQuery(0);
                if (status != B_OK)
                        return status;
        }

        status_t status = B_ENTRY_NOT_FOUND;

        while (fCurrentVolumeIndex < CountVolumes()) {
                status = fQuery.GetNextEntry(entry, traverse);
                if (status != B_ENTRY_NOT_FOUND)
                        break;

                // Continue with next volume, if any
                status = _SetQuery(++fCurrentVolumeIndex);
        }

        return status;
}


status_t
BQueryFile::GetNextRef(entry_ref* ref)
{
        if (fCurrentVolumeIndex == -1) {
                // Start with first volume
                fCurrentVolumeIndex = 0;

                status_t status = _SetQuery(0);
                if (status != B_OK)
                        return status;
        }

        status_t status = B_ENTRY_NOT_FOUND;

        while (fCurrentVolumeIndex < CountVolumes()) {
                status = fQuery.GetNextRef(ref);
                if (status != B_ENTRY_NOT_FOUND)
                        break;

                // Continue with next volume, if any
                status = _SetQuery(++fCurrentVolumeIndex);
        }

        return status;
}


int32
BQueryFile::GetNextDirents(struct dirent* buffer, size_t length, int32 count)
{
        if (fCurrentVolumeIndex == -1) {
                // Start with first volume
                fCurrentVolumeIndex = 0;

                status_t status = _SetQuery(0);
                if (status != B_OK)
                        return status;
        }

        status_t status = B_ENTRY_NOT_FOUND;

        while (fCurrentVolumeIndex < CountVolumes()) {
                status = fQuery.GetNextDirents(buffer, length, count);
                if (status != B_ENTRY_NOT_FOUND)
                        break;

                // Continue with next volume, if any
                status = _SetQuery(++fCurrentVolumeIndex);
        }

        return status;
}


status_t
BQueryFile::Rewind()
{
        fCurrentVolumeIndex = -1;
        return B_OK;
}


int32
BQueryFile::CountEntries()
{
        // not supported
        return -1;
}


/*static*/ const char*
BQueryFile::MimeType()
{
        return B_QUERY_MIMETYPE;
}


status_t
BQueryFile::_SetQuery(int32 index)
{
        if (fCurrentVolumeIndex >= CountVolumes())
                return B_ENTRY_NOT_FOUND;

        BVolume volume(VolumeAt(fCurrentVolumeIndex));
        fQuery.Clear();
        fQuery.SetPredicate(fPredicate.String());
        fQuery.SetVolume(&volume);

        return fQuery.Fetch();
}