/******************************************************************************
/
/       File:                   FileUtils.cpp
/
/   Description:        Utility functions for copying file data and attributes.
/
/       Copyright 1998-1999, Be Incorporated, All Rights Reserved
/
******************************************************************************/
#include "FileUtils.h"

#include <algorithm>
#include <new>
#include <stdio.h>
#include <string.h>

#include <fs_attr.h>

#include "AutoDeleter.h"


using std::nothrow;


status_t
CopyFileData(BFile& dst, BFile& src)
{
        struct stat src_stat;
        status_t err = src.GetStat(&src_stat);
        if (err != B_OK) {
                printf("couldn't get stat: %#010" B_PRIx32 "\n", err);
                return err;
        }
                
        size_t bufSize = src_stat.st_blksize;
        if (bufSize == 0)
                bufSize = 32768;
        
        char* buf = new (nothrow) char[bufSize];
        if (buf == NULL)
                return B_NO_MEMORY;
        ArrayDeleter<char> _(buf);
        
        printf("copy data, bufSize = %ld\n", bufSize);
        // copy data
        while (true) {
                ssize_t bytes = src.Read(buf, bufSize);
                if (bytes > 0) {
                        ssize_t result = dst.Write(buf, bytes);
                        if (result != bytes) {
                                fprintf(stderr, "Failed to write %ld bytes: %s\n", bytes,
                                        strerror((status_t)result));
                                if (result < 0)
                                        return (status_t)result;
                                else
                                        return B_IO_ERROR;
                        }
                } else {
                        if (bytes < 0) {
                                fprintf(stderr, "Failed to read file: %s\n", strerror(
                                        (status_t)bytes));
                                return (status_t)bytes;
                        } else {
                                // EOF
                                break;
                        }
                }
        }

        // finish up miscellaneous stat stuff
        dst.SetPermissions(src_stat.st_mode);
        dst.SetOwner(src_stat.st_uid);
        dst.SetGroup(src_stat.st_gid);
        dst.SetModificationTime(src_stat.st_mtime);
        dst.SetCreationTime(src_stat.st_crtime);

        return B_OK;
}


status_t
CopyAttributes(BNode& dst, BNode& src)
{
        // copy attributes
        src.RewindAttrs();
        char attrName[B_ATTR_NAME_LENGTH];
        while (src.GetNextAttrName(attrName) == B_OK) {
                attr_info info;
                if (src.GetAttrInfo(attrName, &info) != B_OK) {
                        fprintf(stderr, "Failed to read info for attribute '%s'\n",
                                attrName);
                        continue;
                }
                // copy one attribute in chunks of 4096 bytes
                size_t size = 4096;
                uint8 buffer[size];
                off_t offset = 0;
                ssize_t read = src.ReadAttr(attrName, info.type, offset, buffer,
                        std::min((off_t)size, info.size));
                if (read < 0) {
                        fprintf(stderr, "Error reading attribute '%s'\n", attrName);
                        return (status_t)read;
                }
                // NOTE: Attributes of size 0 are perfectly valid!
                while (read >= 0) {
                        ssize_t written = dst.WriteAttr(attrName, info.type, offset, 
                                buffer, read);
                        if (written != read) {
                                fprintf(stderr, "Error writing attribute '%s'\n", attrName);
                                if (written < 0)
                                        return (status_t)written;
                                else
                                        return B_IO_ERROR;
                        }
                        offset += read;
                        read = src.ReadAttr(attrName, info.type, offset, buffer,
                                std::min((off_t)size, info.size - offset));
                        if (read < 0) {
                                fprintf(stderr, "Error reading attribute '%s'\n", attrName);
                                return (status_t)read;
                        }
                        if (read == 0)
                                break;
                }
        }

        return B_OK;            
}


status_t
CopyFile(BFile& dst, BFile& src)
{
        status_t err = CopyFileData(dst, src);
        if (err != B_OK)
                return err;
                
        return CopyAttributes(dst, src);
}