/*

  *  Chunk.cpp

  *  Ottoman

  *

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

  *  Copyright 2009 Jens Alfke. All rights reserved.

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

  */

 #include "Chunk.h"

 #include <assert.h>

 #include <errno.h>

 #include <stddef.h>

 namespace Mooseyard {

     uint16_t Chunk::type() const {

         return _keyLength == 0xFFFF ?(uint16_t)_type :KeyValueChunk::kChunkType;

     }

     const KeyValueChunk* Chunk::asKeyValue() const {

         return _keyLength == 0xFFFF ?NULL :(const KeyValueChunk*)this;

     }

     size_t Chunk::writeMultiple (File *file, uint16_t type,

                                  Blob blobs[], int count)  throw(File::Error) {

         assert(type != KeyValueChunk::kChunkType);

         Blob nuBlobs[count+1];

         uint32_t size = sizeof(Chunk);

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

             nuBlobs[i+1] = blobs[i];

             size += blobs[i].length;

         }

         Chunk chunk(size, type);

         nuBlobs[0] = Blob(&chunk, sizeof(chunk));

         return file->writeMultiple(nuBlobs, count+1);

     }

     size_t Chunk::writePadding (File *file) {

         off_t padding = file->position() & 0x03;

         if (padding == 0)

             return 0;

         else {

             padding = 4 - padding;

             uint32_t zero = 0;

             Blob pad(&zero, (size_t)padding);

             return writeMultiple(file, kChunkTypePadding, &pad, 1);

         }

     }

     void KeyValueChunk::validate() const  throw(File::Error) {

         if (_keyLength >= 0xFFFFU)

             throw File::Error(ERANGE, "Invalid key length (0xFFFF)");

         if (valuePtr() > end())

             throw File::Error(ERANGE, "Bad KeyValueChunk (key-length too large to fit)");

     }

     Blob KeyValueChunk::key() const {

         return Blob(&_keyLength +1, _keyLength);  // KeyValueChunk doesn't have _type

     }

     const char* KeyValueChunk::valuePtr() const {

         size_t vptr = (size_t) key().end();

         vptr = (vptr+3) & ~3;     // 4-byte align

         return (const char*)vptr;

     }

     Blob KeyValueChunk::value() const {

         const char *vp = valuePtr();

         return Blob(vp, (const char*)end()-vp);

     }

     bool KeyValueChunk::hasKey (Blob key) const {

         return key.length==_keyLength 

             && memcmp(key.bytes, &_keyLength +1, key.length)==0;

     }

     size_t KeyValueChunk::write (File* file, FilePosition pos, Blob key, Blob value)  throw(File::Error) {

         if (key.length >= 0xFFFFU)

             throw File::Error(ERANGE, "Key too long (>=64k)");

         uint16_t keyLength = key.length;

         uint32_t size = sizeof(uint32_t) + sizeof(uint16_t) + keyLength;

         size_t pad = (pos + size) & 0x3;

         if (pad)

             pad = 4-pad;

         uint32_t zeros = 0;

         size += pad + value.length;

         Chunk chunk(size, KeyValueChunk::kChunkType);

         chunk._keyLength = keyLength;

         Blob b[4] = {

             Blob(&chunk, sizeof(chunk._size)+sizeof(chunk._keyLength)),

             key,

             Blob(&zeros, pad),

             value};

         return file->writeMultiple(b,4);

     }

     ChunkIterator::ChunkIterator (File* file, FilePosition start)

         :_file(file),

          _pos(start),

          _length((FilePosition)_file->length()),

          _chunk(NULL)

     { 

         _loadChunk();

     }

     void ChunkIterator::_loadChunk() {

         if (_pos < _length) {

             _chunk = (const Chunk*) _file->mappedPosition(_pos);

             if (_chunk->size() < sizeof(Chunk) || _pos+_chunk->size() > _length)

                 _chunk = NULL;

         } else {

             _chunk = NULL;

         }

     }

     bool ChunkIterator::atEOF() const {

         return _pos == _length;

     }

     bool ChunkIterator::next() {

         if (_chunk) {

             _pos += _chunk->size();

             _loadChunk();

         }

         return _chunk != NULL;

     }

 }