/*
 * Copyright 2005-2014 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stefano Ceccherini, burton666@libero.it
 */


#include <DataIO.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <Errors.h>

#if defined(_KERNEL_MODE) && !defined(_BOOT_MODE)
// for user_memcpy() and IS_USER_ADDRESS()
#include <KernelExport.h>

#include <kernel.h>
#endif


BDataIO::BDataIO()
{
}


BDataIO::~BDataIO()
{
}


ssize_t
BDataIO::Read(void* buffer, size_t size)
{
        return B_NOT_SUPPORTED;
}


ssize_t
BDataIO::Write(const void* buffer, size_t size)
{
        return B_NOT_SUPPORTED;
}


status_t
BDataIO::Flush()
{
        return B_OK;
}


status_t
BDataIO::ReadExactly(void* buffer, size_t size, size_t* _bytesRead)
{
        uint8* out = (uint8*)buffer;
        size_t bytesRemaining = size;
        status_t error = B_OK;

        while (bytesRemaining > 0) {
                ssize_t bytesRead = Read(out, bytesRemaining);
                if (bytesRead < 0) {
                        error = bytesRead;
                        break;
                }

                if (bytesRead == 0) {
                        error = B_PARTIAL_READ;
                        break;
                }

                out += bytesRead;
                bytesRemaining -= bytesRead;
        }

        if (_bytesRead != NULL)
                *_bytesRead = size - bytesRemaining;

        return error;
}


status_t
BDataIO::WriteExactly(const void* buffer, size_t size, size_t* _bytesWritten)
{
        const uint8* in = (const uint8*)buffer;
        size_t bytesRemaining = size;
        status_t error = B_OK;

        while (bytesRemaining > 0) {
                ssize_t bytesWritten = Write(in, bytesRemaining);
                if (bytesWritten < 0) {
                        error = bytesWritten;
                        break;
                }

                if (bytesWritten == 0) {
                        error = B_PARTIAL_WRITE;
                        break;
                }

                in += bytesWritten;
                bytesRemaining -= bytesWritten;
        }

        if (_bytesWritten != NULL)
                *_bytesWritten = size - bytesRemaining;

        return error;
}


// Private or Reserved

BDataIO::BDataIO(const BDataIO &)
{
        // Copying not allowed
}


BDataIO &
BDataIO::operator=(const BDataIO &)
{
        // Copying not allowed
        return *this;
}


#if __GNUC__ == 2


extern "C" status_t
_ReservedDataIO1__7BDataIO(BDataIO* self)
{
        return self->BDataIO::Flush();
}


#else


// TODO: RELEASE: Remove!

extern "C" status_t
_ZN7BDataIO16_ReservedDataIO1Ev(BDataIO* self)
{
        return self->BDataIO::Flush();
}


#endif


// FBC
void BDataIO::_ReservedDataIO2(){}
void BDataIO::_ReservedDataIO3(){}
void BDataIO::_ReservedDataIO4(){}
void BDataIO::_ReservedDataIO5(){}
void BDataIO::_ReservedDataIO6(){}
void BDataIO::_ReservedDataIO7(){}
void BDataIO::_ReservedDataIO8(){}
void BDataIO::_ReservedDataIO9(){}
void BDataIO::_ReservedDataIO10(){}
void BDataIO::_ReservedDataIO11(){}
void BDataIO::_ReservedDataIO12(){}


//      #pragma mark -


BPositionIO::BPositionIO()
{
}


BPositionIO::~BPositionIO()
{
}


ssize_t
BPositionIO::Read(void* buffer, size_t size)
{
        off_t curPos = Position();
        ssize_t result = ReadAt(curPos, buffer, size);
        if (result > 0)
                Seek(result, SEEK_CUR);

        return result;
}


ssize_t
BPositionIO::Write(const void* buffer, size_t size)
{
        off_t curPos = Position();
        ssize_t result = WriteAt(curPos, buffer, size);
        if (result > 0)
                Seek(result, SEEK_CUR);

        return result;
}


status_t
BPositionIO::ReadAtExactly(off_t position, void* buffer, size_t size,
        size_t* _bytesRead)
{
        uint8* out = (uint8*)buffer;
        size_t bytesRemaining = size;
        status_t error = B_OK;

        while (bytesRemaining > 0) {
                ssize_t bytesRead = ReadAt(position, out, bytesRemaining);
                if (bytesRead < 0) {
                        error = bytesRead;
                        break;
                }

                if (bytesRead == 0) {
                        error = B_PARTIAL_READ;
                        break;
                }

                out += bytesRead;
                bytesRemaining -= bytesRead;
                position += bytesRead;
        }

        if (_bytesRead != NULL)
                *_bytesRead = size - bytesRemaining;

        return error;
}


status_t
BPositionIO::WriteAtExactly(off_t position, const void* buffer, size_t size,
        size_t* _bytesWritten)
{
        const uint8* in = (const uint8*)buffer;
        size_t bytesRemaining = size;
        status_t error = B_OK;

        while (bytesRemaining > 0) {
                ssize_t bytesWritten = WriteAt(position, in, bytesRemaining);
                if (bytesWritten < 0) {
                        error = bytesWritten;
                        break;
                }

                if (bytesWritten == 0) {
                        error = B_PARTIAL_WRITE;
                        break;
                }

                in += bytesWritten;
                bytesRemaining -= bytesWritten;
                position += bytesWritten;
        }

        if (_bytesWritten != NULL)
                *_bytesWritten = size - bytesRemaining;

        return error;
}


status_t
BPositionIO::SetSize(off_t size)
{
        return B_ERROR;
}


status_t
BPositionIO::GetSize(off_t* size) const
{
        if (!size)
                return B_BAD_VALUE;

        off_t currentPos = Position();
        if (currentPos < 0)
                return (status_t)currentPos;

        *size = const_cast<BPositionIO*>(this)->Seek(0, SEEK_END);
        if (*size < 0)
                return (status_t)*size;

        off_t pos = const_cast<BPositionIO*>(this)->Seek(currentPos, SEEK_SET);

        if (pos != currentPos)
                return pos < 0 ? (status_t)pos : B_ERROR;

        return B_OK;
}


// FBC
extern "C" void _ReservedPositionIO1__11BPositionIO() {}
void BPositionIO::_ReservedPositionIO2(){}
void BPositionIO::_ReservedPositionIO3(){}
void BPositionIO::_ReservedPositionIO4(){}
void BPositionIO::_ReservedPositionIO5(){}
void BPositionIO::_ReservedPositionIO6(){}
void BPositionIO::_ReservedPositionIO7(){}
void BPositionIO::_ReservedPositionIO8(){}
void BPositionIO::_ReservedPositionIO9(){}
void BPositionIO::_ReservedPositionIO10(){}
void BPositionIO::_ReservedPositionIO11(){}
void BPositionIO::_ReservedPositionIO12(){}


//      #pragma mark -


BMemoryIO::BMemoryIO(void* buffer, size_t length)
        :
        fReadOnly(false),
        fBuffer(static_cast<char*>(buffer)),
        fLength(length),
        fBufferSize(length),
        fPosition(0)
{
}


BMemoryIO::BMemoryIO(const void* buffer, size_t length)
        :
        fReadOnly(true),
        fBuffer(const_cast<char*>(static_cast<const char*>(buffer))),
        fLength(length),
        fBufferSize(length),
        fPosition(0)
{
}


BMemoryIO::~BMemoryIO()
{
}


ssize_t
BMemoryIO::ReadAt(off_t pos, void* buffer, size_t size)
{
        if (buffer == NULL || pos < 0)
                return B_BAD_VALUE;

        ssize_t sizeRead = 0;
        if (pos < (off_t)fLength) {
                sizeRead = min_c((off_t)size, (off_t)fLength - pos);
                memcpy(buffer, fBuffer + pos, sizeRead);
        }

        return sizeRead;
}


ssize_t
BMemoryIO::WriteAt(off_t pos, const void* buffer, size_t size)
{
        if (fReadOnly)
                return B_NOT_ALLOWED;

        if (buffer == NULL || pos < 0)
                return B_BAD_VALUE;

        ssize_t sizeWritten = 0;
        if (pos < (off_t)fBufferSize) {
                sizeWritten = min_c((off_t)size, (off_t)fBufferSize - pos);
#if defined(_KERNEL_MODE) && !defined(_BOOT_MODE)
                if (IS_USER_ADDRESS(fBuffer)) {
                        if (user_memcpy(fBuffer + pos, buffer, sizeWritten) != B_OK)
                                return B_BAD_ADDRESS;
                } else
#endif
                memcpy(fBuffer + pos, buffer, sizeWritten);
        }

        if (pos + sizeWritten > (off_t)fLength)
                fLength = pos + sizeWritten;

        return sizeWritten;
}


off_t
BMemoryIO::Seek(off_t position, uint32 seek_mode)
{
        switch (seek_mode) {
                case SEEK_SET:
                        fPosition = position;
                        break;
                case SEEK_CUR:
                        fPosition += position;
                        break;
                case SEEK_END:
                        fPosition = fLength + position;
                        break;
                default:
                        break;
        }

        return fPosition;
}


off_t
BMemoryIO::Position() const
{
        return fPosition;
}


status_t
BMemoryIO::SetSize(off_t size)
{
        if (fReadOnly)
                return B_NOT_ALLOWED;

        if (size > (off_t)fBufferSize)
                return B_ERROR;

        fLength = size;

        return B_OK;
}


// Private or Reserved

BMemoryIO::BMemoryIO(const BMemoryIO &)
{
        //Copying not allowed
}


BMemoryIO &
BMemoryIO::operator=(const BMemoryIO &)
{
        //Copying not allowed
        return *this;
}


// FBC
void BMemoryIO::_ReservedMemoryIO1(){}
void BMemoryIO::_ReservedMemoryIO2(){}


//      #pragma mark -


BMallocIO::BMallocIO()
        :
        fBlockSize(256),
        fMallocSize(0),
        fLength(0),
        fData(NULL),
        fPosition(0)
{
}


BMallocIO::~BMallocIO()
{
        free(fData);
}


ssize_t
BMallocIO::ReadAt(off_t pos, void* buffer, size_t size)
{
        if (buffer == NULL)
                return B_BAD_VALUE;

        ssize_t sizeRead = 0;
        if (pos < (off_t)fLength) {
                sizeRead = min_c((off_t)size, (off_t)fLength - pos);
                memcpy(buffer, fData + pos, sizeRead);
        }

        return sizeRead;
}


ssize_t
BMallocIO::WriteAt(off_t pos, const void* buffer, size_t size)
{
        if (buffer == NULL)
                return B_BAD_VALUE;

        size_t newSize = max_c(pos + (off_t)size, (off_t)fLength);
        status_t error = B_OK;

        if (newSize > fMallocSize)
                error = SetSize(newSize);

        if (error == B_OK) {
                memcpy(fData + pos, buffer, size);
                if (pos + size > fLength)
                        fLength = pos + size;
        }

        return error != B_OK ? error : size;
}


off_t
BMallocIO::Seek(off_t position, uint32 seekMode)
{
        switch (seekMode) {
                case SEEK_SET:
                        fPosition = position;
                        break;
                case SEEK_END:
                        fPosition = fLength + position;
                        break;
                case SEEK_CUR:
                        fPosition += position;
                        break;
                default:
                        break;
        }
        return fPosition;
}


off_t
BMallocIO::Position() const
{
        return fPosition;
}


status_t
BMallocIO::SetSize(off_t size)
{
        status_t error = B_OK;
        if (size == 0) {
                // size == 0, free the memory
                free(fData);
                fData = NULL;
                fMallocSize = 0;
        } else {
                // size != 0, see, if necessary to resize
                size_t newSize = (size + fBlockSize - 1) / fBlockSize * fBlockSize;
                if (size != (off_t)fMallocSize) {
                        // we need to resize
                        if (char* newData = static_cast<char*>(realloc(fData, newSize))) {
                                // set the new area to 0
                                if (newSize > fMallocSize)
                                        memset(newData + fMallocSize, 0, newSize - fMallocSize);
                                fData = newData;
                                fMallocSize = newSize;
                        } else  // couldn't alloc the memory
                                error = B_NO_MEMORY;
                }
        }

        if (error == B_OK)
                fLength = size;

        return error;
}


void
BMallocIO::SetBlockSize(size_t blockSize)
{
        if (blockSize == 0)
                blockSize = 1;

        if (blockSize != fBlockSize)
                fBlockSize = blockSize;
}


const void*
BMallocIO::Buffer() const
{
        return fData;
}


size_t
BMallocIO::BufferLength() const
{
        return fLength;
}


// Private or Reserved

BMallocIO::BMallocIO(const BMallocIO &)
{
        // copying not allowed...
}


BMallocIO &
BMallocIO::operator=(const BMallocIO &)
{
        // copying not allowed...
        return *this;
}


// FBC
void BMallocIO::_ReservedMallocIO1() {}
void BMallocIO::_ReservedMallocIO2() {}