/*

  *  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),

      _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;

         }

         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);

     }

     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);

         _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;

     }

 }