/*

 *  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 <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, bool writeable, bool create)  throw(Error)

        :_fd(_check( ::open(filename, writeable ?(create ?O_RDWR|O_CREAT :O_RDWR) :O_RDONLY, 0644) )),

         _memoryMap(NULL),

         _locked(0)

    { }

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

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

         _memoryMap(NULL),

         _locked( (oflag | O_EXLOCK) ?1 :0)

    { }

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

        return _check( lseek(_fd,0,SEEK_CUR) );

    }

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

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

    }

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

        return _check( lseek(_fd,-bytesBefore,SEEK_END) );

    }

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

        off_t pad = alignment - (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) {

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

    }

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

    }

}