/*

  *  File.cpp

  *  Ottoman

  *

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

  *  Copyright 2009 Jens Alfke. All rights reserved.

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

  */

 #include "File.h"

 #include "MemoryMap.h"

 #include <sys/file.h>

 #include <assert.h>

 #include <errno.h>

 #include <fcntl.h>

 #include <stdio.h>

 #include <sys/stat.h>

 #include <sys/uio.h>

 #include <unistd.h>

 namespace Mooseyard {

     File::File (const char *filename, int oflag, bool locked)  throw(Error)

 #ifdef _DARWIN_C_SOURCE

         :_fd(_check( ::open(filename, oflag | (locked ? O_EXLOCK : 0), 0644) )),

 #else

         :_fd(_check( ::open(filename, oflag, 0644) )),

 #endif

          _memoryMap(NULL),

          _locked( locked ? 1 : 0)

     {

 #ifndef _DARWIN_C_SOURCE

       _check( ::flock(_fd, LOCK_EX) );

 #endif

     }

     File::~File() {

         delete _memoryMap;

         _unlock();

         ::close(_fd);

     }

     off_t File::length() const  throw(Error) {

         struct stat s;

         _check( ::fstat(_fd,&s) );

         return s.st_size;

     }

     void File::setLength (off_t length)  throw(Error) {

         _check( ftruncate(_fd,length) );

     }

     off_t File::position() const  throw(Error) {

         off_t pos = lseek(_fd,0,SEEK_CUR);

         if (pos < 0)

             _check(-1);

         return pos;

     }

     void File::setPosition (off_t pos)  throw(Error) {

         _check( (int) lseek(_fd,pos,SEEK_SET) );

     }

     off_t File::setPositionToEnd (off_t bytesBefore)  throw(Error) {

         off_t pos = lseek(_fd,-bytesBefore,SEEK_END);

         if (pos < 0)

             _check(-1);

         return pos;

     }

     void File::read (void *dst, size_t size)  throw(Error) {

         _checkRead( ::read(_fd, dst, size), size );

     }

     size_t File::write (const void *src, size_t size)  throw(Error) {

         return _check( ::write(_fd, src, size) );

     }

     void File::readFrom (off_t where, void *dst, size_t size)  throw(Error) {

         _checkRead( ::pread(_fd, dst, size, where), size );

     }

     void File::writeTo (off_t where, const void *src, size_t size)  throw(Error) {

         _check( ::pwrite(_fd, src, size, where) );

     }

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

         struct iovec vec[count];

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

             vec[i].iov_base = (void*) blobs[i].bytes;

             vec[i].iov_len = blobs[i].length;

         }

         return _check( ::writev(_fd, vec, count) );

     }

     size_t File::writePadding (int alignment) {

         int pad = alignment - (int)(position() & (alignment-1));

         if (pad == alignment)

             return 0;

         uint8_t zero[pad];

         memset(zero, 0, pad);

         return write(zero, pad);

     }

     void File::flush()  throw(Error) {

         _check( ::fsync(_fd) );

     }

     void File::flushDisk()  throw(Error) {

 #if _DARWIN_C_SOURCE

         /* F_FULLFSYNC is Mac/Darwin specific. From the man page:

          Does the same thing as fsync(2) then asks the drive to flush all buffered data to

          the permanent storage device (arg is ignored).  This is currently implemented on

          HFS, MS-DOS (FAT), and Universal Disk Format (UDF) file systems.  The operation may

          take quite a while to complete.  Certain FireWire drives have also been known to

          ignore the request to flush their buffered data. */

         _check( ::fcntl(_fd,F_FULLFSYNC) );

 #else

         _check( fsync(_fd) );

 #endif

     }

     bool File::hasPath (const char *path) const  throw(Error) {

         struct stat myStat, pathStat;

         _check( ::fstat(_fd, &myStat) );

         if ( ::stat(path, &pathStat) != 0 ) {

             if (errno == ENOENT)

                 return false;

             _check(errno);

         }

         // Compare my inode number with that of the file at path:

         return myStat.st_ino == pathStat.st_ino;

     }

     void File::unlink (const char *filename)  throw(Error) {

         _check( ::unlink(filename) );

     }

     void File::rename (const char *srcFilename, const char *dstFilename)  throw(Error) {

         _check( ::rename(srcFilename, dstFilename) );

     }

 #pragma mark -

 #pragma mark UTILITIES:

     int File::_check (int result)  throw(Error) {

         if (result >= 0)

             return result;

         //printf("*** File::_check: Error %i: %s\n", errno, strerror(errno));

         throw Error(errno, strerror(errno));

     }

     void File::_checkRead (ssize_t result, size_t expectedSize)  throw(Error) {

         if ((size_t)result < expectedSize) {

             if (result < 0)

                 throw Error(errno, strerror(errno));

             else

                 throw Error(kEOF, "unexpected EOF");

         }

     }

     File::Error::Error(const char *m)

         :code(ERANGE), 

          message(m) 

     { }

 #pragma mark -

 #pragma mark LOCKS:

     bool File::_lock (bool block) {

         if (_locked) {

             _locked++;

         } else {

             int mode = LOCK_EX;

             if (block)

                 mode |= LOCK_NB;

             if (::flock(_fd, mode) == 0)

                 _locked = 1;

             else if (errno != EWOULDBLOCK)          // may be returned in LOCK_UN mode

                 _check(-1);

         }

         return _locked > 0;

     }

     void File::_unlock() {

         if (_locked > 0) {

             _locked--;

             ::flock(_fd, LOCK_UN);

         }

     }

     File::Lock::Lock (File *file, bool block)  throw(Error)

         :_file(file),

          _locked( _file->_lock(block) )

     { }

     File::Lock::~Lock() {

         if (_locked)

             _file->_unlock();

     }

     bool File::Lock::retry() {

         if (!_locked)

             _locked = _file->_lock(false);

         return _locked;

     }

 #pragma mark -

 #pragma mark MEMORY MAP:

     MemoryMap* File::map() {

         if (!_memoryMap)

             _memoryMap = new MemoryMap(this);

         return _memoryMap;

     }

     void File::mapRegion (off_t position, size_t length) {

         return map()->mapRegion(position,length);

     }

     const void* File::mappedPosition (off_t position) const {

         return map()->mappedPosition(position);

     }

 }