/*
 * Copyright 2008, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              François Revol <revol@free.fr>
 */


#include "Stream.h"

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <algorithm>

#include <boot/FileMapDisk.h>

#include "CachedBlock.h"
#include "Directory.h"
#include "File.h"


//#define TRACE(x) dprintf x
#define TRACE(x) do {} while (0)


using namespace FATFS;


Stream::Stream(Volume &volume, uint32 chain, off_t size, const char *name)
        :
        fVolume(volume),
        fFirstCluster(chain),
        //fClusters(NULL),
        fClusterMapCacheLast(0),
        fSize(size)
{
        TRACE(("FATFS::Stream::(, %d, %lld, %s)\n", chain, size, name));
        fName[FATFS_NAME_LENGTH] = '\0';
        strlcpy(fName, name, FATFS_NAME_LENGTH+1);
        fClusterCount = (fSize + fVolume.ClusterSize() - 1) / fVolume.ClusterSize();
        if (size == UINT32_MAX)
                fClusterCount = 10; // ?
        for (int i = 0; i < CLUSTER_MAP_CACHE_SIZE; i++) {
                fClusterMapCache[i].block = -1;
                fClusterMapCache[i].cluster = fVolume.InvalidClusterID();
        }
}


Stream::~Stream()
{
        TRACE(("FATFS::Stream::~()\n"));
}


status_t
Stream::InitCheck()
{
        if (fSize && !fVolume.IsValidCluster(fFirstCluster))
                return B_BAD_VALUE;
        return B_OK;
}


status_t
Stream::GetName(char *nameBuffer, size_t bufferSize) const
{
        return strlcpy(nameBuffer, fName, bufferSize);
}


status_t
Stream::GetFileMap(struct file_map_run *runs, int32 *count)
{
        int32 i;
        uint32 cluster = fFirstCluster;
        uint32 next = fVolume.InvalidClusterID();
        off_t offset = 0LL;

        for (i = 0; i < *count; i++) {
                runs[i].offset = offset;
                runs[i].block = fVolume.ToBlock(cluster);
                runs[i].len = fVolume.ClusterSize();
                do {
                        next = fVolume.NextCluster(cluster);
                        if (next != cluster + 1)
                                break;
                        runs[i].len += fVolume.ClusterSize();
                } while (true);
                if (!fVolume.IsValidCluster(next))
                        break;
                cluster = next;
                offset += runs[i].len;
        }

        // too big
        if (i == *count && fVolume.IsValidCluster(next))
                return B_ERROR;

        *count = i;
        return B_OK;
}


status_t
Stream::_FindCluster(off_t pos, uint32& _cluster)
{
        //TRACE(("FATFS::Stream::%s(%lld,,)\n", __FUNCTION__, pos));
        uint32 index = (uint32)(pos / fVolume.ClusterSize());
        if (pos > fSize || index >= fClusterCount)
                return B_BAD_VALUE;

        uint32 cluster = 0;
        bool found = false;
        uint32 i;
        for (i = 0; i < CLUSTER_MAP_CACHE_SIZE; i++) {
                if (fClusterMapCache[i].block == index) {
                        cluster = fClusterMapCache[i].cluster;
                        found = true;
                        break;
                }
        }
        if (!found) {
#if 1
                cluster = fFirstCluster;
                for (i = 0; i < index && fVolume.IsValidCluster(cluster); i++) {
                        if (fVolume.IsLastCluster(cluster))
                                break;
                        //TRACE(("FATFS::Stream::%s: [%d] = %d\n", __FUNCTION__, i, cluster));
                        cluster = fVolume.NextCluster(cluster);
                        //TRACE(("FATFS::Stream::%s: %04lx ?\n", __FUNCTION__, cluster));
                }
#endif
#if 0
                cluster = fVolume.NextCluster(cluster, index);
#endif
        }
        if (!fVolume.IsValidCluster(cluster))
                return B_ENTRY_NOT_FOUND;

        fClusterMapCache[fClusterMapCacheLast].block = index;
        fClusterMapCache[fClusterMapCacheLast].cluster = cluster;
        fClusterMapCacheLast++;
        fClusterMapCacheLast %= CLUSTER_MAP_CACHE_SIZE;

        _cluster = cluster;
        return B_OK;
}


status_t
Stream::_FindOrCreateCluster(off_t pos, uint32& _cluster, bool& _added)
{
        status_t error = _FindCluster(pos, _cluster);
        if (error == B_OK) {
                _added = false;
                return B_OK;
        }

        // iterate through the cluster list
        uint32 index = (uint32)(pos / fVolume.ClusterSize());
        uint32 cluster = fFirstCluster;
        uint32 clusterCount = 0;
        if (cluster != 0) {
                uint32 nextCluster = cluster;
                while (clusterCount <= index) {
                        if (!fVolume.IsValidCluster(nextCluster)
                                        || fVolume.IsLastCluster(nextCluster)) {
                                break;
                        }

                        cluster = nextCluster;
                        clusterCount++;
                        nextCluster = fVolume.NextCluster(nextCluster);
                }
        }

        if (clusterCount > index) {
                // the cluster existed after all
                _cluster = cluster;
                _added = false;
                return B_OK;
        }

        while (clusterCount <= index) {
                uint32 newCluster;
                error = fVolume.AllocateCluster(cluster, newCluster);
                if (error != B_OK)
                        return error;

                if (clusterCount == 0)
                        fFirstCluster = newCluster;

                // TODO: We should support to zero out the new cluster. Maybe make this
                // and optional parameter of WriteAt().

                cluster = newCluster;
                clusterCount++;
        }

        _cluster = cluster;
        _added = true;
        return B_OK;
}


status_t
Stream::FindBlock(off_t pos, off_t &block, off_t &offset)
{
        uint32 cluster;
        status_t error = _FindCluster(pos, cluster);
        if (error != B_OK)
                return error;

        // convert to position
        offset = fVolume.ClusterToOffset(cluster);
        offset += (pos %= fVolume.ClusterSize());

        // convert to block + offset
        block = fVolume.ToBlock(offset);
        offset %= fVolume.BlockSize();

        return B_OK;
}


status_t
Stream::ReadAt(off_t pos, void *_buffer, size_t *_length, off_t *diskOffset)
{
        TRACE(("FATFS::Stream::%s(%lld, )\n", __FUNCTION__, pos));

        uint8* buffer = (uint8*)_buffer;

        // set/check boundaries for pos/length
        if (pos < 0)
                return B_BAD_VALUE;
        if (pos >= fSize) {
                *_length = 0;
                return B_OK;
        }

#if 0
        // lazily build the cluster list
        if (!fClusters) {
                status_t status = BuildClusterList();
                if (status != B_OK)
                        return status;
        }
#endif

        size_t length = *_length;

        if (pos + (off_t)length > fSize)
                length = fSize - pos;

        off_t num; // block number
        off_t offset;
        if (FindBlock(pos, num, offset) < B_OK) {
                *_length = 0;
                return B_BAD_VALUE;
        }

        if (diskOffset != NULL)
                *diskOffset = fVolume.BlockToOffset(num) + offset;

        uint32 bytesRead = 0;
        uint32 blockSize = fVolume.BlockSize();
        uint8 *block;

        // the first block_run we read could not be aligned to the block_size boundary
        // (read partial block at the beginning)

        // pos % block_size == (pos - offset) % block_size, offset % block_size == 0
        if (pos % blockSize != 0) {
                CachedBlock cached(fVolume, num);
                if ((block = cached.Block()) == NULL) {
                        *_length = 0;
                        return B_BAD_VALUE;
                }

                bytesRead = blockSize - (pos % blockSize);
                if (length < bytesRead)
                        bytesRead = length;

                memcpy(buffer, block + (pos % blockSize), bytesRead);
                pos += bytesRead;

                length -= bytesRead;
                if (length == 0) {
                        *_length = bytesRead;
                        return B_OK;
                }

                if (FindBlock(pos, num, offset) < B_OK) {
                        *_length = bytesRead;
                        return B_BAD_VALUE;
                }
        }

        // the first block_run is already filled in at this point
        // read the following complete blocks using cached_read(),
        // the last partial block is read using the generic Cache class

        while (length > 0) {
                // offset is the offset to the current pos in the block_run

                if (length < blockSize) {
                        CachedBlock cached(fVolume, num);
                        if ((block = cached.Block()) == NULL) {
                                *_length = bytesRead;
                                return B_BAD_VALUE;
                        }
                        memcpy(buffer + bytesRead, block, length);
                        bytesRead += length;
                        break;
                }

                if (read_pos(fVolume.Device(), fVolume.BlockToOffset(num),
                        buffer + bytesRead, fVolume.BlockSize()) < B_OK) {
                        *_length = bytesRead;
                        return B_BAD_VALUE;
                }

                int32 bytes = fVolume.BlockSize();
                length -= bytes;
                bytesRead += bytes;
                if (length == 0)
                        break;

                pos += bytes;

                if (FindBlock(pos, num, offset) < B_OK) {
                        *_length = bytesRead;
                        return B_BAD_VALUE;
                }
        }

        *_length = bytesRead;
        return B_OK;
}


status_t
Stream::WriteAt(off_t pos, const void* _buffer, size_t* _length,
        off_t* diskOffset)
{
        if (pos < 0)
                return B_BAD_VALUE;

        const uint8* buffer = (const uint8*)_buffer;
        size_t length = *_length;
        size_t totalWritten = 0;
        status_t error = B_OK;

        CachedBlock cachedBlock(fVolume);

        while (length > 0) {
                // get the cluster
                uint32 cluster;
                bool added;
                error = _FindOrCreateCluster(pos, cluster, added);
                if (error != B_OK)
                        break;

                // convert to position
                off_t inClusterOffset = pos % fVolume.ClusterSize();
                off_t offset = fVolume.ClusterToOffset(cluster) + inClusterOffset;

                if (diskOffset != NULL) {
                        *diskOffset = offset;
                        diskOffset = NULL;
                }

                // convert to block + offset
                off_t block = fVolume.ToBlock(offset);
                size_t inBlockOffset = offset % fVolume.BlockSize();

                // write
                size_t toWrite = std::min((size_t)fVolume.BlockSize() - inBlockOffset,
                        length);
                if (toWrite == (size_t)fVolume.BlockSize()) {
                        // write the whole block
                        ssize_t written = write_pos(fVolume.Device(),
                                fVolume.BlockToOffset(block), buffer, fVolume.BlockSize());
                        if (written < 0) {
                                error = written;
                                break;
                        }
                        if (written != fVolume.BlockSize()) {
                                error = B_ERROR;
                                break;
                        }
                } else {
                        // write a partial block -- need to read it from disk first
                        error = cachedBlock.SetTo(block, CachedBlock::READ);
                        if (error != B_OK)
                                break;

                        memcpy(cachedBlock.Block() + inBlockOffset, buffer, toWrite);

                        error = cachedBlock.Flush();
                        if (error != B_OK)
                                break;
                }

                totalWritten += toWrite;
                pos += toWrite;
                buffer += toWrite;
                length -= toWrite;

                if (pos > fSize)
                        fSize = pos;
        }

        *_length = totalWritten;
        return totalWritten > 0 ? B_OK : error;
}


status_t
Stream::BuildClusterList()
{
#if 0
        TRACE(("FATFS::Stream::%s()\n", __FUNCTION__));
        uint32 count = (fSize + fVolume.ClusterSize() - 1) / fVolume.ClusterSize();
        uint32 c = fFirstCluster;
        int i;

        if (fSize == UINT32_MAX) // it's a directory, try a large enough value
                count = 10;
        //fClusters = (uint32 *)malloc(count * sizeof(uint32));
        for (i = 0; i < count && fVolume.IsValidCluster(c); i++) {
                if (fVolume.IsLastCluster(c))
                        break;
                TRACE(("FATFS::Stream::%s: [%d] = %d\n", __FUNCTION__, i, c));
                fClusters[i] = c;
                c = fVolume.NextCluster(c);
                TRACE(("FATFS::Stream::%s: %04lx ?\n", __FUNCTION__, c));
                // XXX: try to realloc() for dirs maybe ?
        }
        fClusterCount = i;
        TRACE(("FATFS::Stream::%s: %d clusters in chain\n", __FUNCTION__, i));
#endif
        return B_OK;
}