/*

 *  VersionDictionary.cpp

 *  Ottoman

 *

 *  Created by Jens Alfke on 8/21/09.

 *  Copyright 2009 Jens Alfke. All rights reserved.

 *  BSD-Licensed: See the file "LICENSE.txt" for details.

 */

#include "VersionDictionary.h"

#include "Chunk.h"

#include "Index.h"

#include "File.h"

#include "Chunk.h"

#include <assert.h>

#include <errno.h>

#include <algorithm>

namespace Mooseyard {

    // Trailer is stored in file; all numbers are little-endian.

    class VersionDictionary::Trailer :public Chunk {

    public:

        LittleEndian<uint32_t>          magicNumber1;

        LittleEndian<uint32_t>          count;

        VersionDictionary::IndexPositions  indexPositions;

        LittleEndian<FilePosition>      previousTrailerPosition;

        LittleEndian<uint32_t>          generation;

        LittleEndianDouble              timestamp;

        LittleEndian<uint32_t>          magicNumber2;

        Trailer ()

            :Chunk(sizeof(Trailer), kChunkType)

        { }

        Trailer (int c,

                     VersionDictionary::IndexPositions indexPos, 

                     FilePosition previousTrailerPos,

                     uint32_t gen)

            :Chunk(sizeof(Trailer), kChunkType),

             magicNumber1(kMagicNumber1),

             count(c),

             indexPositions(indexPos),

             previousTrailerPosition(previousTrailerPos),

             generation(gen),

             timestamp(::time(NULL)),

             magicNumber2(kMagicNumber2)

        { }

        static const uint32_t kMagicNumber1 = 0xfe83b1cd;

        static const uint32_t kMagicNumber2 = 0xff84b2c1;

    };

    VersionDictionary::VersionDictionary (File *file)

        :_file(file),

         _trailerPosition(0),

         _previousTrailerPosition(0),

         _indexPositions(),

         _count(0),

         _previousVersion()

    {

        if (file->length() > sizeof(Trailer))

            _read();

    }

    VersionDictionary::VersionDictionary (File *file, FilePosition trailerPosition)

        :_file(file),

         _trailerPosition(trailerPosition),

         _previousTrailerPosition(0),

         _indexPositions(),

         _count(0),

         _previousVersion()

    {

        _read(trailerPosition);

    }

    int VersionDictionary::count() const {

        return _count;

    }

    const VersionDictionary::Trailer* VersionDictionary::_trailer() const {

        if (_trailerPosition > 0)

            return (const VersionDictionary::Trailer*) _file->mappedPosition(_trailerPosition);

        else 

            return NULL;      // Only happens in the empty-file case

    }

    const Index* VersionDictionary::_index (int i) const {

        if (_indexPositions[i] > 0)

            return (const Index*) _file->mappedPosition(_indexPositions[i]);

        else

            return NULL;

    }

    int VersionDictionary::generation() const {

        const VersionDictionary::Trailer *trailer = _trailer();

        return trailer ? (int)trailer->generation : -1;

    }

    time_t VersionDictionary::timestamp() const {

        const VersionDictionary::Trailer *trailer = _trailer();

        return trailer ? (time_t)trailer->timestamp : 0;

    }

    const VersionDictionary* VersionDictionary::previousVersion() const {

        if (!_previousVersion)

            if (_previousTrailerPosition > 0)

                _previousVersion = new VersionDictionary(_file, _previousTrailerPosition);

        return _previousVersion;

    }

    Blob VersionDictionary::get (Key key) const {

        const Index *index = _index(key.hash >> 24);

        return index ?index->get(_file, key) :Blob();

    }

    void VersionDictionary::_read (FilePosition trailerPos) {

        assert(_file);

        if (trailerPos > 0) {

            _file->setPosition(trailerPos);

        } else {

            // Determine position of trailer, at EOF:

            off_t pos = _file->setPositionToEnd(sizeof(VersionDictionary::Trailer));

            if (pos < 0 || (pos & 0x03) || pos > UINT32_MAX)

                throw File::Error(ERANGE, "No trailer found in file (wrong EOF)");

            trailerPos = pos;

        }

        // Read & verify trailer:

        VersionDictionary::Trailer trailer;

        _file->read(trailer);

        _trailerPosition = trailerPos;

        _count = trailer.count;

        _indexPositions = trailer.indexPositions;

        if (trailer.magicNumber1 != VersionDictionary::Trailer::kMagicNumber1

            || trailer.magicNumber2 != VersionDictionary::Trailer::kMagicNumber2)

            throw File::Error(ERANGE, "No trailer found in file (invalid magic numbers)");\

        // Map in the file:

        _file->mapRegion(0, _trailerPosition+sizeof(trailer));

        // Verify Indexes:

        for (int i=0; i<256; i++) {

            const Index *index = _index(i);

            if (index)

                index->validate();

        }

}

    bool VersionDictionary::isLatestVersion() const {

        return _file->length() <= _trailerPosition+sizeof(VersionDictionary::Trailer);

    }

    /*  Append addDict to baseDict, writing the results into dstFile (which is usually the same

        as baseDict->file().) If 'replace' is true, ignore the old contents of baseDict.

        Returns the position of the new trailer. */

    FilePosition VersionDictionary::_append (const VersionDictionary *baseDict, 

                                          const Dictionary *addDict, 

                                          File *dstFile, 

                                          bool replace) 

    {

        File *srcFile = baseDict->_file;

        bool incremental = !replace && dstFile==srcFile;

        Index* newIndex[256];

        {

            // Work out the needed capacity for each Index bucket:

            int newCounts[256] = {0};

            if (!replace) {

                for (int i=0; i<256; i++) {

                    const Index *oldIndex = baseDict->_index(i);

                    if (oldIndex)

                        newCounts[i] = oldIndex->count();

                }

            }

            Dictionary::Iterator *it = addDict->iterate();

            for (; *it; ++*it)

                newCounts[it->key().hash >> 24]++;

            delete it;

            // Allocate new Indexes, of sufficient capacity, for each growing bucket:

            for (int i=0; i<256; i++) {

                const Index *oldIndex = baseDict->_index(i);

                if (newCounts[i] && (!incremental || !oldIndex || newCounts[i] > oldIndex->count())) {

                    newIndex[i] = Index::create(newCounts[i]);

                    if (incremental && oldIndex)

                        newIndex[i]->copyFrom(srcFile, oldIndex);

                } else

                    newIndex[i] = NULL;

            }

        }

        // Lock the file now, seek to the end, and make sure it's been prepared with a header,

        // since FilePositions of 0 and 1 are reserved.

        File::Lock lock(dstFile);

        const FilePosition startPos = dstFile->setPositionToEnd();

        if (startPos <= 1)

            throw File::Error(ERANGE, "Cannot write VersionDictionary to empty file");

        // For safety's sake, make sure the old file hasn't been destroyed:

        FilePosition oldEOF = baseDict->_trailerPosition;

        if (oldEOF > 0)

            oldEOF += sizeof(VersionDictionary::Trailer);

        if (srcFile->length() < oldEOF)

            throw File::Error(ERANGE, "File has been truncated since being read");

        try{

            FilePosition pos = startPos;

            int newCount;

            if (replace)

                newCount = 0;

            else if (dstFile == srcFile)

                newCount = baseDict->_count;

            else {

                // Write out the surviving pre-existing entries from the old file:

                newCount = 0;

                for (VersionDictionary::Iterator it(baseDict); it; ++it) {

                    Key key = it.key();

                    if (!addDict->contains(key)) {

                        int bucket = key.hash >> 24;

                        int size = KeyValueChunk::write(dstFile,pos, key, it.value());

                        newIndex[bucket]->put(srcFile, key, pos, startPos);

                        pos += size;

                        newCount++;

                    }

                }

            }

            // Now write the items from the new dict:

            Dictionary::Iterator *it = addDict->iterate();

            for (; *it; ++*it) {

                Key key=it->key();

                Blob value=it->value();

                int bucket = key.hash >> 24;

                Index *index = newIndex[bucket];

                assert(index);

                if (value.bytes) {

                    int size = KeyValueChunk::write(dstFile,pos, key, value);

                    if (index->put(srcFile, key, pos, startPos))

                        newCount++;

                    pos += size;

                } else if (incremental) {

                    // NULL value is a deleted-entry marker used by OverlayDictionary

                    if (index->remove(srcFile, key, startPos))

                        newCount--;

                }

            }

            delete it;

            // Write out the new indexes:

            IndexPositions newIndexPositions;

            if (incremental)

                newIndexPositions = baseDict->_indexPositions;

            else

                memset(&newIndexPositions, 0, sizeof(newIndexPositions));

            pos += Chunk::writePadding(dstFile);

            for (int i=0; i<256; i++) {

                if (newIndex[i]) {

                    Index *index = newIndex[i];

                    newIndexPositions[i] = pos;

                    pos += dstFile->write(index, index->size());

                    delete index;

                }

            }

            // Flush everything out to disk, with maximum paranoia, before writing the trailer.

            // Since scavenging corrupt files looks for trailers, we don't want to append a

            // trailer until we're certain that all of the real data is safely on-disk.

            dstFile->flushDisk();

            // Write the trailer:

            FilePosition newTrailerPosition = pos;

            VersionDictionary::Trailer trailer(newCount,

                                            newIndexPositions,

                                            baseDict->_trailerPosition,

                                            baseDict->generation() + 1);

            pos += dstFile->write(trailer);

            // Just a mild flush here; flushDisk() is very expensive and can be disruptive to

            // real-time I/O in other apps, so it's bad to call it too often.

            dstFile->flush();

            assert(pos==dstFile->position());

            return newTrailerPosition;

        } catch (...) {

            // If something goes wrong, try to back out everything we wrote:

            try{

                dstFile->setLength(startPos);

            }catch(...) { }

            throw;

        }

    }

#pragma mark -

#pragma mark TESTING-ONLY:

    VersionDictionary* VersionDictionary::_appendAndOpen (const Dictionary *addDict,

                                                    File *dstFile, 

                                                    bool replace) const

    {

        FilePosition nextVersionPos = _append(this, addDict, dstFile, replace);

        VersionDictionary *nextVersion = new VersionDictionary(dstFile, nextVersionPos);

        nextVersion->_previousVersion = this;

        return nextVersion;

    }

    VersionDictionary* VersionDictionary::create (File *file, const Dictionary *srcDict) {

        return VersionDictionary(file)._appendAndOpen(srcDict, file, true);

    }

#pragma mark -

#pragma mark ITERATOR:

    Dictionary::Iterator* VersionDictionary::iterate() const {

        return new VersionDictionary::Iterator(this);

    }

    VersionDictionary::Iterator::Iterator (const VersionDictionary *file)

    :_file(file),

     _bucket(-1),

     _iter(NULL)

    { 

        nextIndex();

    }

    VersionDictionary::Iterator::~Iterator() {

        delete _iter;

    }

    bool VersionDictionary::Iterator::hasValue() const               {return _iter && _iter->hasValue();}

    Key VersionDictionary::Iterator::key() const                     {return _iter->key();}

    Blob VersionDictionary::Iterator::value() const                  {return _iter->value();}

    bool VersionDictionary::Iterator::next() {

        if (_iter->next())

            return true;

        else {

            delete _iter;

            return nextIndex();

        }

    }

    bool VersionDictionary::Iterator::nextIndex() {

        while (++_bucket < 256) {

            const Index *index = _file->_index(_bucket);

            if (index) {

                _iter = new Index::Iterator(_file->_file, index);

                if (*_iter)

                    return true;

                else

                    delete _iter;

            }

        }

        _iter = NULL;

        return false;

    }

#pragma mark -

#pragma mark CHANGE ITERATOR:

    VersionDictionary::ChangeIterator* VersionDictionary::iterateChanges() const {

        return new VersionDictionary::ChangeIterator(this);

    }

    VersionDictionary::ChangeIterator::ChangeIterator (const VersionDictionary *file)

    :_file(file),

     _bucket(-1),

     _iter(NULL)

    { 

        next();            

    }

    VersionDictionary::ChangeIterator::~ChangeIterator() {

        delete _iter;

    }

    bool VersionDictionary::ChangeIterator::hasValue() const               {return _iter && _iter->hasValue();}

    Key VersionDictionary::ChangeIterator::key() const                     {return _iter->key();}

    Blob VersionDictionary::ChangeIterator::value() const                  {return _iter->value();}

    bool VersionDictionary::ChangeIterator::next() {

        const VersionDictionary::Trailer *trailer = _file->_trailer();

        for (;;) {

            // Check if current iterator has a value that's from this version:

            if (_iter && _iter->hasValue()) {

                if (((Index::Iterator*)_iter)->valuePosition() > trailer->previousTrailerPosition)

                    return true;

                else if (_iter->next())

                    continue;

            }

            // If not, go to next Index:

            if (!nextIndex())

                return false;

        }

    }

    bool VersionDictionary::ChangeIterator::nextIndex() {

        delete _iter;

        const VersionDictionary::Trailer *trailer = _file->_trailer();

        while (++_bucket < 256) {

            const Index *index = _file->_index(_bucket);

            if (index) {

                // Skip indexes that weren't updated in this version:

                if (trailer->indexPositions[_bucket] > trailer->previousTrailerPosition) {

                    _iter = new Index::Iterator(_file->_file, index);

                    return true;

                }

            }

        }

        _iter = NULL;

        return false;

    }

}