/*
 * Copyright 2007, Ingo Weinhold, ingo_weinhold@gmx.de.
 * All rights reserved. Distributed under the terms of the MIT license.
 */

#include <TypeConstants.h>

#include "Entry.h"
#include "EntryListener.h"
#include "IndexImpl.h"
#include "Node.h"
#include "NodeListener.h"
#include "SizeIndex.h"
#include "Volume.h"

#include <util/AutoLock.h>


// SizeIndexPrimaryKey
class SizeIndexPrimaryKey {
public:
        SizeIndexPrimaryKey(Node *node, off_t size)
                : node(node), size(size) {}
        SizeIndexPrimaryKey(Node *node)
                : node(node), size(node->GetSize()) {}
        SizeIndexPrimaryKey(off_t size)
                : node(NULL), size(size) {}

        Node    *node;
        off_t   size;
};

// SizeIndexGetPrimaryKey
class SizeIndexGetPrimaryKey {
public:
        inline SizeIndexPrimaryKey operator()(Node *a)
        {
                return SizeIndexPrimaryKey(a);
        }

        inline SizeIndexPrimaryKey operator()(Node *a) const
        {
                return SizeIndexPrimaryKey(a);
        }
};

// SizeIndexPrimaryKeyCompare
class SizeIndexPrimaryKeyCompare
{
public:
        inline int operator()(const SizeIndexPrimaryKey &a,
                                                  const SizeIndexPrimaryKey &b) const
        {
                if (a.node != NULL && a.node == b.node)
                        return 0;
                if (a.size < b.size)
                        return -1;
                if (a.size > b.size)
                        return 1;
                return 0;
        }
};


// NodeTree
typedef TwoKeyAVLTree<Node*, SizeIndexPrimaryKey,
                                          SizeIndexPrimaryKeyCompare,
                                          SizeIndexGetPrimaryKey>
                _NodeTree;
class SizeIndex::NodeTree : public _NodeTree {};


// IteratorList
class SizeIndex::IteratorList : public DoublyLinkedList<Iterator> {};


// Iterator
class SizeIndex::Iterator
        : public NodeEntryIterator<SizeIndex::NodeTree::Iterator>,
          public DoublyLinkedListLinkImpl<Iterator>, public EntryListener,
          public NodeListener {
public:
        Iterator();
        virtual ~Iterator();

        virtual Entry *GetCurrent();
        virtual Entry *GetCurrent(uint8 *buffer, size_t *keyLength);

        virtual status_t Suspend();
        virtual status_t Resume();

        bool SetTo(SizeIndex *index, off_t size, bool ignoreValue = false);
        void Unset();

        virtual void EntryRemoved(Entry *entry);
        virtual void NodeRemoved(Node *node);

private:
        typedef NodeEntryIterator<SizeIndex::NodeTree::Iterator> BaseClass;

private:
        SizeIndex                                               *fIndex;
};


// SizeIndex

// constructor
SizeIndex::SizeIndex(Volume *volume)
        : Index(volume, "size", B_INT64_TYPE, true, sizeof(off_t)),
          fNodes(new(nothrow) NodeTree),
          fIterators(new(nothrow) IteratorList)
{
        if (fInitStatus == B_OK && (!fNodes || !fIterators))
                fInitStatus = B_NO_MEMORY;
        if (fInitStatus == B_OK) {
                fInitStatus = fVolume->AddNodeListener(this,
                        NULL, NODE_LISTEN_ANY_NODE | NODE_LISTEN_ALL);
        }
}

// destructor
SizeIndex::~SizeIndex()
{
        if (fVolume)
                fVolume->RemoveNodeListener(this, NULL);
        if (fIterators) {
                // unset the iterators
                for (Iterator *iterator = fIterators->First();
                         iterator;
                         iterator = fIterators->GetNext(iterator)) {
                        iterator->SetTo(NULL, 0);
                }
                delete fIterators;
        }
        if (fNodes)
                delete fNodes;
}

// CountEntries
int32
SizeIndex::CountEntries() const
{
        return fNodes->CountItems();
}

// Changed
status_t
SizeIndex::Changed(Node *node, off_t oldSize)
{
        fVolume->AssertWriteLocked();

        status_t error = B_BAD_VALUE;
        if (node) {
                NodeTree::Iterator it;
                Node **foundNode = fNodes->Find(SizeIndexPrimaryKey(node, oldSize),
                                                                                node, &it);
                if (foundNode && *foundNode == node) {
                        // update the iterators
                        for (Iterator *iterator = fIterators->First();
                                 iterator;
                                 iterator = fIterators->GetNext(iterator)) {
                                if (iterator->GetCurrentNode() == node)
                                        iterator->NodeRemoved(node);
                        }

                        // remove and re-insert the node
                        it.Remove();
                        error = fNodes->Insert(node);

                        // udpate live queries
                        off_t newSize = node->GetSize();
                        fVolume->UpdateLiveQueries(NULL, node, GetName(), GetType(),
                                (const uint8*)&oldSize, sizeof(oldSize), (const uint8*)&newSize,
                                sizeof(newSize));
                }
        }
        return error;
}

// NodeAdded
void
SizeIndex::NodeAdded(Node *node)
{
        if (node)
                fNodes->Insert(node);
}

// NodeRemoved
void
SizeIndex::NodeRemoved(Node *node)
{
        if (node)
                fNodes->Remove(node, node);
}

// InternalGetIterator
AbstractIndexEntryIterator *
SizeIndex::InternalGetIterator()
{
        Iterator *iterator = new(nothrow) Iterator;
        if (iterator) {
                if (!iterator->SetTo(this, 0, true)) {
                        delete iterator;
                        iterator = NULL;
                }
        }
        return iterator;
}

// InternalFind
AbstractIndexEntryIterator *
SizeIndex::InternalFind(const uint8 *key, size_t length)
{
        if (!key || length != sizeof(off_t))
                return NULL;
        Iterator *iterator = new(nothrow) Iterator;
        if (iterator) {
                if (!iterator->SetTo(this, *(const off_t*)key)) {
                        delete iterator;
                        iterator = NULL;
                }
        }
        return iterator;
}

// _AddIterator
void
SizeIndex::_AddIterator(Iterator *iterator)
{
        RecursiveLocker locker(fVolume->GetAttributeIteratorLock());
        fIterators->Insert(iterator);
}

// _RemoveIterator
void
SizeIndex::_RemoveIterator(Iterator *iterator)
{
        RecursiveLocker locker(fVolume->GetAttributeIteratorLock());
        fIterators->Remove(iterator);
}


// Iterator

// constructor
SizeIndex::Iterator::Iterator()
        : BaseClass(),
          fIndex(NULL)
{
}

// destructor
SizeIndex::Iterator::~Iterator()
{
        SetTo(NULL, 0);
}

// GetCurrent
Entry *
SizeIndex::Iterator::GetCurrent()
{
        return BaseClass::GetCurrent();
}

// GetCurrent
Entry *
SizeIndex::Iterator::GetCurrent(uint8 *buffer, size_t *keyLength)
{
        Entry *entry = GetCurrent();
        if (entry) {
                *(off_t*)buffer = entry->GetNode()->GetSize();
                *keyLength = sizeof(size_t);
        }
        return entry;
}

// Suspend
status_t
SizeIndex::Iterator::Suspend()
{
        status_t error = BaseClass::Suspend();
        if (error == B_OK) {
                if (fNode) {
                        error = fIndex->GetVolume()->AddNodeListener(this, fNode,
                                                                                                                 NODE_LISTEN_REMOVED);
                        if (error == B_OK && fEntry) {
                                error = fIndex->GetVolume()->AddEntryListener(this, fEntry,
                                        ENTRY_LISTEN_REMOVED);
                                if (error != B_OK)
                                        fIndex->GetVolume()->RemoveNodeListener(this, fNode);
                        }
                        if (error != B_OK)
                                BaseClass::Resume();
                }
        }
        return error;
}

// Resume
status_t
SizeIndex::Iterator::Resume()
{
        status_t error = BaseClass::Resume();
        if (error == B_OK) {
                if (fEntry)
                        error = fIndex->GetVolume()->RemoveEntryListener(this, fEntry);
                if (fNode) {
                        if (error == B_OK)
                                error = fIndex->GetVolume()->RemoveNodeListener(this, fNode);
                        else
                                fIndex->GetVolume()->RemoveNodeListener(this, fNode);
                }
        }
        return error;
}

// SetTo
bool
SizeIndex::Iterator::SetTo(SizeIndex *index, off_t size, bool ignoreValue)
{
        Resume();
        Unset();
        // set the new values
        fIndex = index;
        if (fIndex)
                fIndex->_AddIterator(this);
        fInitialized = fIndex;
        // get the node's first entry
        if (fIndex) {
                // get the first node
                bool found = true;
                if (ignoreValue)
                        fIndex->fNodes->GetIterator(&fIterator);
                else
                        found = fIndex->fNodes->FindFirst(size, &fIterator);
                // get the first entry
                if (found) {
                        if (Node **nodeP = fIterator.GetCurrent()) {
                                fNode = *nodeP;
                                fEntry = fNode->GetFirstReferrer();
                                if (!fEntry)
                                        BaseClass::GetNext();
                                if (!ignoreValue && fNode && fNode->GetSize() != size)
                                        Unset();
                        }
                }
        }
        return fEntry;
}

// Unset
void
SizeIndex::Iterator::Unset()
{
        if (fIndex) {
                fIndex->_RemoveIterator(this);
                fIndex = NULL;
        }
        BaseClass::Unset();
}

// EntryRemoved
void
SizeIndex::Iterator::EntryRemoved(Entry */*entry*/)
{
        Resume();
        fIsNext = BaseClass::GetNext();
        Suspend();
}

// NodeRemoved
void
SizeIndex::Iterator::NodeRemoved(Node */*node*/)
{
        Resume();
        fEntry = NULL;
        fIsNext = BaseClass::GetNext();
        Suspend();
}