/*

 *  Ottoman.cpp

 *  Ottoman

 *

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

 *  Copyright 2009 Jens Alfke. All rights reserved.

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

 */

#include "Ottoman.h"

#include "VersionDictionary.h"

#include "Chunk.h"

#include "Index.h"

#include "File.h"

#include <fcntl.h>

#include <stdio.h>

#include <unistd.h>

namespace Mooseyard {

    class DictionaryFileHeader :public Chunk {

    public:

        DictionaryFileHeader()                      

            :Chunk(sizeof(DictionaryFileHeader),kChunkType) 

        {

            memcpy(&magicNumber, &kMagicNumber, sizeof(magicNumber));

        }

        bool valid() const {

            return type()==kChunkType && memcmp(&magicNumber,&kMagicNumber,sizeof(magicNumber))==0;

        }

        uint8_t magicNumber[8];

        static const uint16_t kChunkType = 4;

        static const uint8_t kMagicNumber[8];

    };

    const uint8_t DictionaryFileHeader::kMagicNumber[8] = {0x4A, 0x54, 0xF1, 0x1E, 'h', 'A', 's', 'H'};

    Ottoman::Ottoman()

    :_writeable(true),

     _file(NULL),

     _filename(NULL),

     _lastVersion(NULL),

     _current( new OverlayDictionary(&Dictionary::kEmpty) )

    {

    }

    Ottoman::Ottoman (const char *filename, bool writeable)

    :_writeable(writeable),

     _filename(strdup(filename)),

     _lastVersion(),

     _current()

    {

        _file = new File(_filename, writeable ?O_RDWR :O_RDONLY);

        _lastVersion = new VersionDictionary(_file);

        if (writeable)

            _current = new OverlayDictionary(_lastVersion);

    }

    Ottoman::~Ottoman() {

        delete _current;

        delete _lastVersion;

        delete _file;

        free(_filename);

    }

    bool Ottoman::needsSync() const {

        return _file && (!_lastVersion->isLatestVersion() || !_file->hasPath(_filename));

    }

    bool Ottoman::sync() {

        if (!needsSync())

            return false;

        File *curFile = _file;

        if (!curFile->hasPath(_filename))

            curFile = new File(_filename, _writeable ?O_RDWR :O_RDONLY);

        VersionDictionary *newest = new VersionDictionary(curFile);

        bool changed = (newest->generation() != _lastVersion->generation());

        if (changed) {

            if (newest->generation() < _lastVersion->generation())

                throw File::Error("Versions got lost in file update");

            if (_current)

                _current->rebase(newest);

            delete _lastVersion;

            _lastVersion = newest;

        }

        if (_file != curFile) {

            delete _file;

            _file = curFile;

        }

        if (changed)

            versionsChanged();

        return changed;

    }

    ChunkIterator* Ottoman::chunkIterator() const {

        return _file ?new ChunkIterator(_file, sizeof(DictionaryFileHeader)) :NULL;

    }

    bool Ottoman::scavenge (bool repair) {

        if (!_file)

            return true;

        const off_t actualEOF = _file->length();

        fprintf(stderr, "Ottoman::scavenge: Scanning %s (%llu / 0x%llX bytes) ...\n", 

                _filename, actualEOF, actualEOF);

        _file->setPosition(0);

        ChunkIterator it(_file, 0);

        const DictionaryFileHeader *header = (const DictionaryFileHeader *) it.chunk();

        if (!header || !header->valid()) {

            fprintf(stderr, "Ottoman::scavenge: No valid file header at all!\n");

            return false;

        }

        // Scan through all the chunks:

        FilePosition lastValidTrailer = 0;

        FilePosition validEOF = 0;

        int lastType = -1;

        int count = 0;

        try{

            for (; it; ++it) {

                const Chunk *chunk = it.chunk();

                uint16_t type = it.chunk()->type();

                if (type != lastType) {

                    if (count > 0)

                        printf("%6d\n", count);

                    fprintf(stderr, "Ottoman::scavenge:    at 0x%08X: type %u ... ", 

                            it.position(), type);

                    lastType = type;

                    count = 0;

                }

                count++;

                switch (type) {

                    case KeyValueChunk::kChunkType:

                        ((const KeyValueChunk*)chunk)->validate();

                        break;

                    case Index::kChunkType:

                        ((const Index*)chunk)->validateEntries(_file);

                        break;

                    case VersionDictionary::kChunkType: {

                        fprintf(stderr, "Found dictionary trailer at %u!\n", it.position());

                        count = 0;

                        // Validate by instantiating the VersionDictionary:

                        VersionDictionary tempDict(_file, it.position());

                        // If constructor succeeded, it's valid, so remember it:

                        lastValidTrailer = it.position();

                        validEOF = lastValidTrailer + chunk->size();

                        fprintf(stderr, "Ottoman::scavenge:    Valid dictionary trailer at %X--%X\n",

                                lastValidTrailer, validEOF);

                        break;

                    }

                }

            }

            if (count > 0)

                fprintf(stderr, "%6d\n", count);

        } catch (File::Error &err) {

            fprintf(stderr, "Ottoman::scavenge caught File::Error(%i,\"%s\") at pos %llX\n",

                    err.code, err.message, _file->position());

            // Keep going; we can recover the dictionary(ies) before the bad one.

        }

        if (lastValidTrailer == 0) {

            fprintf(stderr, "Ottoman::scavenge: No valid dictionaries found!\n");

            return false;

        } else if (validEOF < actualEOF) {

            fprintf(stderr, "Ottoman::scavenge: Need to truncate to 0x%X (0x%llX bytes)\n",

                    lastValidTrailer, actualEOF-lastValidTrailer);

            if (repair) {

                _file->setLength(validEOF);

                _file->flushDisk();

            }

            return false;

        }

        fprintf(stderr, "Ottoman::scavenge: File is OK!\n");

        return true;

    }

#pragma mark -

#pragma mark SAVING:

    // low-level write. Does not lock or check for conflicts!

    void Ottoman::_append (File *dstFile) {

        VersionDictionary *lastVersion = _lastVersion;

        if (!lastVersion)

            lastVersion = new VersionDictionary(dstFile);

        VersionDictionary *saved = lastVersion->_appendAndOpen(_current->overlay(), 

                                                               dstFile,

                                                               _current->baseReplaced());

        // (don't delete _lastVersion: saved->_previousVersion now points to it.)

        _lastVersion = saved;

        _current->revertTo(_lastVersion);

        versionsChanged();

    }

    bool Ottoman::save() {

        if (!_file)

            return false;

        if (_current && _current->isChanged()) {

            File::Lock lock(_file);

            if (needsSync())

                return false;       // conflict!

            _append(_file);

        }

        return true;

    }

    File* Ottoman::_writeTo (const char *dstFileName, bool overwriteAllowed) {

        int mode = O_RDWR | O_CREAT | O_TRUNC | O_EXLOCK;

        if (!overwriteAllowed)

            mode |= O_EXCL;

        File *dstFile = new File(dstFileName, mode);

        try {

            dstFile->write(DictionaryFileHeader());

            _append(dstFile);

        } catch (...) {

            delete dstFile;

            File::unlink(dstFileName);

            throw;

        }

        return dstFile;

    }

    void Ottoman::saveAs (const char *dstFileName, bool overwriteAllowed) {

        File *dstFile = _writeTo(dstFileName, overwriteAllowed);

        free(_filename);

        _filename = strdup(dstFileName);

        delete _file;

        _file = dstFile;

    }

    bool Ottoman::saveAndCompact() {

        if (!_file)

            return false;

        char tempFileName[1024];

        strlcpy(tempFileName, _filename, sizeof(tempFileName)-1);

        strlcat(tempFileName, "~", sizeof(tempFileName));

        File *tempFile;

        {

            // Check for conflict in existing file:

            File::Lock lock(_file);

            if (needsSync())

                return false;

            tempFile = _writeTo(tempFileName, false);

            File::rename(tempFileName, _filename);

        }

        delete _file;

        _file = tempFile;

        return true;

    }

}